From f87fdca8e3df86e62d6552f11a640b71691b57cd Mon Sep 17 00:00:00 2001 From: Chris Johnson Date: Sun, 17 Nov 2019 19:33:24 -0500 Subject: PocketVerbs --- plugins/LinuxVST/CMakeLists.txt | 1 + plugins/LinuxVST/src/PocketVerbs/PocketVerbs.cpp | 325 + plugins/LinuxVST/src/PocketVerbs/PocketVerbs.h | 295 + .../LinuxVST/src/PocketVerbs/PocketVerbsProc.cpp | 18358 +++++++++++++++++++ .../PocketVerbs/English.lproj/InfoPlist.strings | Bin 0 -> 388 bytes plugins/MacAU/PocketVerbs/Info.plist | 28 + plugins/MacAU/PocketVerbs/PocketVerbs.cpp | 4909 +++++ plugins/MacAU/PocketVerbs/PocketVerbs.exp | 1 + plugins/MacAU/PocketVerbs/PocketVerbs.h | 271 + plugins/MacAU/PocketVerbs/PocketVerbs.r | 61 + .../christopherjohnson.mode1v3 | 1374 ++ .../christopherjohnson.pbxuser | 149 + .../christopherjohnson.perspectivev3 | 1485 ++ .../PocketVerbs.xcodeproj/project.pbxproj | 490 + plugins/MacAU/PocketVerbs/PocketVerbsVersion.h | 58 + .../PocketVerbs.pbxindex/categories.pbxbtree | Bin 0 -> 84 bytes .../PocketVerbs.pbxindex/cdecls.pbxbtree | Bin 0 -> 324808 bytes .../PocketVerbs.pbxindex/decls.pbxbtree | Bin 0 -> 328468 bytes .../PocketVerbs.pbxindex/files.pbxbtree | Bin 0 -> 3808 bytes .../PocketVerbs.pbxindex/imports.pbxbtree | Bin 0 -> 10652 bytes .../PocketVerbs.pbxindex/pbxindex.header | Bin 0 -> 24 bytes .../PocketVerbs.pbxindex/protocols.pbxbtree | Bin 0 -> 84 bytes .../PocketVerbs.pbxindex/refs.pbxbtree | Bin 0 -> 244932 bytes .../strings.pbxstrings/control | Bin 0 -> 524308 bytes .../strings.pbxstrings/strings | Bin 0 -> 714783 bytes .../PocketVerbs.pbxindex/subclasses.pbxbtree | Bin 0 -> 824 bytes .../PocketVerbs.pbxindex/symbols0.pbxsymbols | Bin 0 -> 1389968 bytes plugins/MacAU/PocketVerbs/version.plist | 16 + .../christopherjohnson.pbxuser | 132 + .../christopherjohnson.perspectivev3 | 1528 ++ .../PocketVerbs.xcodeproj/project.pbxproj | 2201 +++ .../project.xcworkspace/contents.xcworkspacedata | 7 + .../UserInterfaceState.xcuserstate | Bin 0 -> 12075 bytes .../UserInterfaceState.xcuserstate | Bin 0 -> 10373 bytes .../PocketVerbs.xcodeproj/spiadmin.mode1v3 | 1372 ++ .../PocketVerbs.xcodeproj/spiadmin.pbxuser | 143 + .../xcschemes/Gain.xcscheme | 80 + .../xcschemes/xcschememanagement.plist | 22 + .../xcschemes/xcschememanagement.plist | 22 + .../\302\253PROJECTNAME\302\273.xcscheme" | 57 + plugins/MacVST/PocketVerbs/mac/Info.plist | 24 + plugins/MacVST/PocketVerbs/mac/PkgInfo | 1 + plugins/MacVST/PocketVerbs/mac/xcode_vst_prefix.h | 17 + plugins/MacVST/PocketVerbs/source/PocketVerbs.cpp | 325 + plugins/MacVST/PocketVerbs/source/PocketVerbs.h | 295 + .../MacVST/PocketVerbs/source/PocketVerbsProc.cpp | 18358 +++++++++++++++++++ .../PocketVerbs/.vs/Console4Channel64/v14/.suo | Bin 0 -> 32768 bytes plugins/WinVST/PocketVerbs/.vs/VSTProject/v14/.suo | Bin 0 -> 23040 bytes plugins/WinVST/PocketVerbs/PocketVerbs.cpp | 325 + plugins/WinVST/PocketVerbs/PocketVerbs.h | 295 + plugins/WinVST/PocketVerbs/PocketVerbsProc.cpp | 18358 +++++++++++++++++++ plugins/WinVST/PocketVerbs/VSTProject.sln | 28 + plugins/WinVST/PocketVerbs/VSTProject.vcxproj | 183 + .../WinVST/PocketVerbs/VSTProject.vcxproj.filters | 48 + plugins/WinVST/PocketVerbs/VSTProject.vcxproj.user | 19 + plugins/WinVST/PocketVerbs/vstplug.def | 3 + 56 files changed, 71664 insertions(+) create mode 100755 plugins/LinuxVST/src/PocketVerbs/PocketVerbs.cpp create mode 100755 plugins/LinuxVST/src/PocketVerbs/PocketVerbs.h create mode 100755 plugins/LinuxVST/src/PocketVerbs/PocketVerbsProc.cpp create mode 100755 plugins/MacAU/PocketVerbs/English.lproj/InfoPlist.strings create mode 100755 plugins/MacAU/PocketVerbs/Info.plist create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbs.cpp create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbs.exp create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbs.h create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbs.r create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.mode1v3 create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj create mode 100755 plugins/MacAU/PocketVerbs/PocketVerbsVersion.h create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/categories.pbxbtree create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/cdecls.pbxbtree create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/decls.pbxbtree create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/files.pbxbtree create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/imports.pbxbtree create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/pbxindex.header create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/protocols.pbxbtree create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/refs.pbxbtree create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/control create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/strings create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/subclasses.pbxbtree create mode 100755 plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/symbols0.pbxsymbols create mode 100755 plugins/MacAU/PocketVerbs/version.plist create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/contents.xcworkspacedata create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/christopherjohnson.xcuserdatad/UserInterfaceState.xcuserstate create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/spiadmin.xcuserdatad/UserInterfaceState.xcuserstate create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.mode1v3 create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.pbxuser create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/Gain.xcscheme create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/xcschememanagement.plist create mode 100755 plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/xcschememanagement.plist create mode 100755 "plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/\302\253PROJECTNAME\302\273.xcscheme" create mode 100755 plugins/MacVST/PocketVerbs/mac/Info.plist create mode 100755 plugins/MacVST/PocketVerbs/mac/PkgInfo create mode 100755 plugins/MacVST/PocketVerbs/mac/xcode_vst_prefix.h create mode 100755 plugins/MacVST/PocketVerbs/source/PocketVerbs.cpp create mode 100755 plugins/MacVST/PocketVerbs/source/PocketVerbs.h create mode 100755 plugins/MacVST/PocketVerbs/source/PocketVerbsProc.cpp create mode 100755 plugins/WinVST/PocketVerbs/.vs/Console4Channel64/v14/.suo create mode 100755 plugins/WinVST/PocketVerbs/.vs/VSTProject/v14/.suo create mode 100755 plugins/WinVST/PocketVerbs/PocketVerbs.cpp create mode 100755 plugins/WinVST/PocketVerbs/PocketVerbs.h create mode 100755 plugins/WinVST/PocketVerbs/PocketVerbsProc.cpp create mode 100755 plugins/WinVST/PocketVerbs/VSTProject.sln create mode 100755 plugins/WinVST/PocketVerbs/VSTProject.vcxproj create mode 100755 plugins/WinVST/PocketVerbs/VSTProject.vcxproj.filters create mode 100755 plugins/WinVST/PocketVerbs/VSTProject.vcxproj.user create mode 100755 plugins/WinVST/PocketVerbs/vstplug.def diff --git a/plugins/LinuxVST/CMakeLists.txt b/plugins/LinuxVST/CMakeLists.txt index 57ddebe..a2de68f 100755 --- a/plugins/LinuxVST/CMakeLists.txt +++ b/plugins/LinuxVST/CMakeLists.txt @@ -127,6 +127,7 @@ add_airwindows_plugin(PeaksOnly) add_airwindows_plugin(PDBuss) add_airwindows_plugin(PDChannel) add_airwindows_plugin(PhaseNudge) +add_airwindows_plugin(PocketVerbs) add_airwindows_plugin(Podcast) add_airwindows_plugin(PodcastDeluxe) add_airwindows_plugin(Point) diff --git a/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.cpp b/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.cpp new file mode 100755 index 0000000..4426e4b --- /dev/null +++ b/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.cpp @@ -0,0 +1,325 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#include "PocketVerbs.h" +#endif + +AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new PocketVerbs(audioMaster);} + +PocketVerbs::PocketVerbs(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 0.0; + B = 0.5; + C = 0.0; + D = 0.5; + + for(count = 0; count < 6; count++) {dAL[count] = 0.0; dBL[count] = 0.0; dCL[count] = 0.0; dDL[count] = 0.0; dEL[count] = 0.0; + dFL[count] = 0.0; dGL[count] = 0.0; dHL[count] = 0.0; dIL[count] = 0.0; dJL[count] = 0.0; dKL[count] = 0.0; dLL[count] = 0.0; + dML[count] = 0.0; dNL[count] = 0.0; dOL[count] = 0.0; dPL[count] = 0.0; dQL[count] = 0.0; dRL[count] = 0.0; dSL[count] = 0.0; + dTL[count] = 0.0; dUL[count] = 0.0; dVL[count] = 0.0; dWL[count] = 0.0; dXL[count] = 0.0; dYL[count] = 0.0; dZL[count] = 0.0;} + + for(count = 0; count < 15149; count++) {aAL[count] = 0.0;} + for(count = 0; count < 15149; count++) {oAL[count] = 0.0;} + for(count = 0; count < 14617; count++) {aBL[count] = 0.0;} + for(count = 0; count < 14617; count++) {oBL[count] = 0.0;} + for(count = 0; count < 14357; count++) {aCL[count] = 0.0;} + for(count = 0; count < 14357; count++) {oCL[count] = 0.0;} + for(count = 0; count < 13817; count++) {aDL[count] = 0.0;} + for(count = 0; count < 13817; count++) {oDL[count] = 0.0;} + for(count = 0; count < 13561; count++) {aEL[count] = 0.0;} + for(count = 0; count < 13561; count++) {oEL[count] = 0.0;} + for(count = 0; count < 13045; count++) {aFL[count] = 0.0;} + for(count = 0; count < 13045; count++) {oFL[count] = 0.0;} + for(count = 0; count < 11965; count++) {aGL[count] = 0.0;} + for(count = 0; count < 11965; count++) {oGL[count] = 0.0;} + for(count = 0; count < 11129; count++) {aHL[count] = 0.0;} + for(count = 0; count < 11129; count++) {oHL[count] = 0.0;} + for(count = 0; count < 10597; count++) {aIL[count] = 0.0;} + for(count = 0; count < 10597; count++) {oIL[count] = 0.0;} + for(count = 0; count < 9809; count++) {aJL[count] = 0.0;} + for(count = 0; count < 9809; count++) {oJL[count] = 0.0;} + for(count = 0; count < 9521; count++) {aKL[count] = 0.0;} + for(count = 0; count < 9521; count++) {oKL[count] = 0.0;} + for(count = 0; count < 8981; count++) {aLL[count] = 0.0;} + for(count = 0; count < 8981; count++) {oLL[count] = 0.0;} + for(count = 0; count < 8785; count++) {aML[count] = 0.0;} + for(count = 0; count < 8785; count++) {oML[count] = 0.0;} + for(count = 0; count < 8461; count++) {aNL[count] = 0.0;} + for(count = 0; count < 8461; count++) {oNL[count] = 0.0;} + for(count = 0; count < 8309; count++) {aOL[count] = 0.0;} + for(count = 0; count < 8309; count++) {oOL[count] = 0.0;} + for(count = 0; count < 7981; count++) {aPL[count] = 0.0;} + for(count = 0; count < 7981; count++) {oPL[count] = 0.0;} + for(count = 0; count < 7321; count++) {aQL[count] = 0.0;} + for(count = 0; count < 7321; count++) {oQL[count] = 0.0;} + for(count = 0; count < 6817; count++) {aRL[count] = 0.0;} + for(count = 0; count < 6817; count++) {oRL[count] = 0.0;} + for(count = 0; count < 6505; count++) {aSL[count] = 0.0;} + for(count = 0; count < 6505; count++) {oSL[count] = 0.0;} + for(count = 0; count < 6001; count++) {aTL[count] = 0.0;} + for(count = 0; count < 6001; count++) {oTL[count] = 0.0;} + for(count = 0; count < 5837; count++) {aUL[count] = 0.0;} + for(count = 0; count < 5837; count++) {oUL[count] = 0.0;} + for(count = 0; count < 5501; count++) {aVL[count] = 0.0;} + for(count = 0; count < 5501; count++) {oVL[count] = 0.0;} + for(count = 0; count < 5009; count++) {aWL[count] = 0.0;} + for(count = 0; count < 5009; count++) {oWL[count] = 0.0;} + for(count = 0; count < 4849; count++) {aXL[count] = 0.0;} + for(count = 0; count < 4849; count++) {oXL[count] = 0.0;} + for(count = 0; count < 4295; count++) {aYL[count] = 0.0;} + for(count = 0; count < 4295; count++) {oYL[count] = 0.0;} + for(count = 0; count < 4179; count++) {aZL[count] = 0.0;} + for(count = 0; count < 4179; count++) {oZL[count] = 0.0;} + + for(count = 0; count < 6; count++) {dAR[count] = 0.0; dBR[count] = 0.0; dCR[count] = 0.0; dDR[count] = 0.0; dER[count] = 0.0; + dFR[count] = 0.0; dGR[count] = 0.0; dHR[count] = 0.0; dIR[count] = 0.0; dJR[count] = 0.0; dKR[count] = 0.0; dLR[count] = 0.0; + dMR[count] = 0.0; dNR[count] = 0.0; dOR[count] = 0.0; dPR[count] = 0.0; dQR[count] = 0.0; dRR[count] = 0.0; dSR[count] = 0.0; + dTR[count] = 0.0; dUR[count] = 0.0; dVR[count] = 0.0; dWR[count] = 0.0; dXR[count] = 0.0; dYR[count] = 0.0; dZR[count] = 0.0;} + + for(count = 0; count < 15149; count++) {aAR[count] = 0.0;} + for(count = 0; count < 15149; count++) {oAR[count] = 0.0;} + for(count = 0; count < 14617; count++) {aBR[count] = 0.0;} + for(count = 0; count < 14617; count++) {oBR[count] = 0.0;} + for(count = 0; count < 14357; count++) {aCR[count] = 0.0;} + for(count = 0; count < 14357; count++) {oCR[count] = 0.0;} + for(count = 0; count < 13817; count++) {aDR[count] = 0.0;} + for(count = 0; count < 13817; count++) {oDR[count] = 0.0;} + for(count = 0; count < 13561; count++) {aER[count] = 0.0;} + for(count = 0; count < 13561; count++) {oER[count] = 0.0;} + for(count = 0; count < 13045; count++) {aFR[count] = 0.0;} + for(count = 0; count < 13045; count++) {oFR[count] = 0.0;} + for(count = 0; count < 11965; count++) {aGR[count] = 0.0;} + for(count = 0; count < 11965; count++) {oGR[count] = 0.0;} + for(count = 0; count < 11129; count++) {aHR[count] = 0.0;} + for(count = 0; count < 11129; count++) {oHR[count] = 0.0;} + for(count = 0; count < 10597; count++) {aIR[count] = 0.0;} + for(count = 0; count < 10597; count++) {oIR[count] = 0.0;} + for(count = 0; count < 9809; count++) {aJR[count] = 0.0;} + for(count = 0; count < 9809; count++) {oJR[count] = 0.0;} + for(count = 0; count < 9521; count++) {aKR[count] = 0.0;} + for(count = 0; count < 9521; count++) {oKR[count] = 0.0;} + for(count = 0; count < 8981; count++) {aLR[count] = 0.0;} + for(count = 0; count < 8981; count++) {oLR[count] = 0.0;} + for(count = 0; count < 8785; count++) {aMR[count] = 0.0;} + for(count = 0; count < 8785; count++) {oMR[count] = 0.0;} + for(count = 0; count < 8461; count++) {aNR[count] = 0.0;} + for(count = 0; count < 8461; count++) {oNR[count] = 0.0;} + for(count = 0; count < 8309; count++) {aOR[count] = 0.0;} + for(count = 0; count < 8309; count++) {oOR[count] = 0.0;} + for(count = 0; count < 7981; count++) {aPR[count] = 0.0;} + for(count = 0; count < 7981; count++) {oPR[count] = 0.0;} + for(count = 0; count < 7321; count++) {aQR[count] = 0.0;} + for(count = 0; count < 7321; count++) {oQR[count] = 0.0;} + for(count = 0; count < 6817; count++) {aRR[count] = 0.0;} + for(count = 0; count < 6817; count++) {oRR[count] = 0.0;} + for(count = 0; count < 6505; count++) {aSR[count] = 0.0;} + for(count = 0; count < 6505; count++) {oSR[count] = 0.0;} + for(count = 0; count < 6001; count++) {aTR[count] = 0.0;} + for(count = 0; count < 6001; count++) {oTR[count] = 0.0;} + for(count = 0; count < 5837; count++) {aUR[count] = 0.0;} + for(count = 0; count < 5837; count++) {oUR[count] = 0.0;} + for(count = 0; count < 5501; count++) {aVR[count] = 0.0;} + for(count = 0; count < 5501; count++) {oVR[count] = 0.0;} + for(count = 0; count < 5009; count++) {aWR[count] = 0.0;} + for(count = 0; count < 5009; count++) {oWR[count] = 0.0;} + for(count = 0; count < 4849; count++) {aXR[count] = 0.0;} + for(count = 0; count < 4849; count++) {oXR[count] = 0.0;} + for(count = 0; count < 4295; count++) {aYR[count] = 0.0;} + for(count = 0; count < 4295; count++) {oYR[count] = 0.0;} + for(count = 0; count < 4179; count++) {aZR[count] = 0.0;} + for(count = 0; count < 4179; count++) {oZR[count] = 0.0;} + + outAL = 1; alpAL = 1; + outBL = 1; alpBL = 1; + outCL = 1; alpCL = 1; + outDL = 1; alpDL = 1; + outEL = 1; alpEL = 1; + outFL = 1; alpFL = 1; + outGL = 1; alpGL = 1; + outHL = 1; alpHL = 1; + outIL = 1; alpIL = 1; + outJL = 1; alpJL = 1; + outKL = 1; alpKL = 1; + outLL = 1; alpLL = 1; + outML = 1; alpML = 1; + outNL = 1; alpNL = 1; + outOL = 1; alpOL = 1; + outPL = 1; alpPL = 1; + outQL = 1; alpQL = 1; + outRL = 1; alpRL = 1; + outSL = 1; alpSL = 1; + outTL = 1; alpTL = 1; + outUL = 1; alpUL = 1; + outVL = 1; alpVL = 1; + outWL = 1; alpWL = 1; + outXL = 1; alpXL = 1; + outYL = 1; alpYL = 1; + outZL = 1; alpZL = 1; + + outAR = 1; alpAR = 1; delayA = 4; maxdelayA = 7573; + outBR = 1; alpBR = 1; delayB = 4; maxdelayB = 7307; + outCR = 1; alpCR = 1; delayC = 4; maxdelayC = 7177; + outDR = 1; alpDR = 1; delayD = 4; maxdelayD = 6907; + outER = 1; alpER = 1; delayE = 4; maxdelayE = 6779; + outFR = 1; alpFR = 1; delayF = 4; maxdelayF = 6521; + outGR = 1; alpGR = 1; delayG = 4; maxdelayG = 5981; + outHR = 1; alpHR = 1; delayH = 4; maxdelayH = 5563; + outIR = 1; alpIR = 1; delayI = 4; maxdelayI = 5297; + outJR = 1; alpJR = 1; delayJ = 4; maxdelayJ = 4903; + outKR = 1; alpKR = 1; delayK = 4; maxdelayK = 4759; + outLR = 1; alpLR = 1; delayL = 4; maxdelayL = 4489; + outMR = 1; alpMR = 1; delayM = 4; maxdelayM = 4391; + outNR = 1; alpNR = 1; delayN = 4; maxdelayN = 4229; + outOR = 1; alpOR = 1; delayO = 4; maxdelayO = 4153; + outPR = 1; alpPR = 1; delayP = 4; maxdelayP = 3989; + outQR = 1; alpQR = 1; delayQ = 4; maxdelayQ = 3659; + outRR = 1; alpRR = 1; delayR = 4; maxdelayR = 3407; + outSR = 1; alpSR = 1; delayS = 4; maxdelayS = 3251; + outTR = 1; alpTR = 1; delayT = 4; maxdelayT = 2999; + outUR = 1; alpUR = 1; delayU = 4; maxdelayU = 2917; + outVR = 1; alpVR = 1; delayV = 4; maxdelayV = 2749; + outWR = 1; alpWR = 1; delayW = 4; maxdelayW = 2503; + outXR = 1; alpXR = 1; delayX = 4; maxdelayX = 2423; + outYR = 1; alpYR = 1; delayY = 4; maxdelayY = 2146; + outZR = 1; alpZR = 1; delayZ = 4; maxdelayZ = 2088; + + savedRoomsize = -1.0; //force update to begin + countdown = -1; + peakL = 1.0; + peakR = 1.0; + fpd = 17; + //this is reset: values being initialized only once. Startup values, whatever they are. + + _canDo.insert("plugAsChannelInsert"); // plug-in can be used as a channel insert effect. + _canDo.insert("plugAsSend"); // plug-in can be used as a send effect. + _canDo.insert("x2in2out"); + setNumInputs(kNumInputs); + setNumOutputs(kNumOutputs); + setUniqueID(kUniqueId); + canProcessReplacing(); // supports output replacing + canDoubleReplacing(); // supports double precision processing + programsAreChunks(true); + vst_strncpy (_programName, "Default", kVstMaxProgNameLen); // default program name +} + +PocketVerbs::~PocketVerbs() {} +VstInt32 PocketVerbs::getVendorVersion () {return 1000;} +void PocketVerbs::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void PocketVerbs::getProgramName(char *name) {vst_strncpy (name, _programName, kVstMaxProgNameLen);} +//airwindows likes to ignore this stuff. Make your own programs, and make a different plugin rather than +//trying to do versioning and preventing people from using older versions. Maybe they like the old one! + +static float pinParameter(float data) +{ + if (data < 0.0f) return 0.0f; + if (data > 1.0f) return 1.0f; + return data; +} + +VstInt32 PocketVerbs::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + chunkData[1] = B; + chunkData[2] = C; + chunkData[3] = D; + /* Note: The way this is set up, it will break if you manage to save settings on an Intel + machine and load them on a PPC Mac. However, it's fine if you stick to the machine you + started with. */ + + *data = chunkData; + return kNumParameters * sizeof(float); +} + +VstInt32 PocketVerbs::setChunk (void* data, VstInt32 byteSize, bool isPreset) +{ + float *chunkData = (float *)data; + A = pinParameter(chunkData[0]); + B = pinParameter(chunkData[1]); + C = pinParameter(chunkData[2]); + D = pinParameter(chunkData[3]); + /* We're ignoring byteSize as we found it to be a filthy liar */ + + /* calculate any other fields you need here - you could copy in + code from setParameter() here. */ + return 0; +} + +void PocketVerbs::setParameter(VstInt32 index, float value) { + switch (index) { + case kParamA: A = value; break; + case kParamB: B = value; break; + case kParamC: C = value; break; + case kParamD: D = value; break; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float PocketVerbs::getParameter(VstInt32 index) { + switch (index) { + case kParamA: return A; break; + case kParamB: return B; break; + case kParamC: return C; break; + case kParamD: return D; break; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void PocketVerbs::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Type", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Size", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "Gating", kVstMaxParamStrLen); break; + case kParamD: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this is our labels for displaying in the VST host +} + +void PocketVerbs::getParameterDisplay(VstInt32 index, char *text) { + switch (index) { + case kParamA: switch((VstInt32)( A * 5.999 )) //0 to almost edge of # of params + { case 0: vst_strncpy (text, "Chamber", kVstMaxParamStrLen); break; + case 1: vst_strncpy (text, "Spring", kVstMaxParamStrLen); break; + case 2: vst_strncpy (text, "Tiled", kVstMaxParamStrLen); break; + case 3: vst_strncpy (text, "Room", kVstMaxParamStrLen); break; + case 4: vst_strncpy (text, "Stretch", kVstMaxParamStrLen); break; + case 5: vst_strncpy (text, "Zarathu", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } break; + case kParamB: float2string (B, text, kVstMaxParamStrLen); break; + case kParamC: float2string (C, text, kVstMaxParamStrLen); break; + case kParamD: float2string (D, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void PocketVerbs::getParameterLabel(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 PocketVerbs::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool PocketVerbs::getEffectName(char* name) { + vst_strncpy(name, "PocketVerbs", kVstMaxProductStrLen); return true; +} + +VstPlugCategory PocketVerbs::getPlugCategory() {return kPlugCategEffect;} + +bool PocketVerbs::getProductString(char* text) { + vst_strncpy (text, "airwindows PocketVerbs", kVstMaxProductStrLen); return true; +} + +bool PocketVerbs::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.h b/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.h new file mode 100755 index 0000000..7feaf8e --- /dev/null +++ b/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.h @@ -0,0 +1,295 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#define __PocketVerbs_H + +#ifndef __audioeffect__ +#include "audioeffectx.h" +#endif + +#include +#include +#include + +enum { + kParamA = 0, + kParamB = 1, + kParamC = 2, + kParamD = 3, + kNumParameters = 4 +}; // + +const int kNumPrograms = 0; +const int kNumInputs = 2; +const int kNumOutputs = 2; +const unsigned long kUniqueId = 'pkvb'; //Change this to what the AU identity is! + +class PocketVerbs : + public AudioEffectX +{ +public: + PocketVerbs(audioMasterCallback audioMaster); + ~PocketVerbs(); + virtual bool getEffectName(char* name); // The plug-in name + virtual VstPlugCategory getPlugCategory(); // The general category for the plug-in + virtual bool getProductString(char* text); // This is a unique plug-in string provided by Steinberg + virtual bool getVendorString(char* text); // Vendor info + virtual VstInt32 getVendorVersion(); // Version number + virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames); + virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames); + virtual void getProgramName(char *name); // read the name from the host + virtual void setProgramName(char *name); // changes the name of the preset displayed in the host + virtual VstInt32 getChunk (void** data, bool isPreset); + virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset); + virtual float getParameter(VstInt32 index); // get the parameter value at the specified index + virtual void setParameter(VstInt32 index, float value); // set the parameter at index to value + virtual void getParameterLabel(VstInt32 index, char *text); // label for the parameter (eg dB) + virtual void getParameterName(VstInt32 index, char *text); // name of the parameter + virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value + virtual VstInt32 canDo(char *text); +private: + char _programName[kVstMaxProgNameLen + 1]; + std::set< std::string > _canDo; + + int count; + + + + double dAR[7]; + double dBR[7]; + double dCR[7]; + double dDR[7]; + double dER[7]; + double dFR[7]; + double dGR[7]; + double dHR[7]; + double dIR[7]; + double dJR[7]; + double dKR[7]; + double dLR[7]; + double dMR[7]; + double dNR[7]; + double dOR[7]; + double dPR[7]; + double dQR[7]; + double dRR[7]; + double dSR[7]; + double dTR[7]; + double dUR[7]; + double dVR[7]; + double dWR[7]; + double dXR[7]; + double dYR[7]; + double dZR[7]; + + double aAR[15150]; + double aBR[14618]; + double aCR[14358]; + double aDR[13818]; + double aER[13562]; + double aFR[13046]; + double aGR[11966]; + double aHR[11130]; + double aIR[10598]; + double aJR[9810]; + double aKR[9522]; + double aLR[8982]; + double aMR[8786]; + double aNR[8462]; + double aOR[8310]; + double aPR[7982]; + double aQR[7322]; + double aRR[6818]; + double aSR[6506]; + double aTR[6002]; + double aUR[5838]; + double aVR[5502]; + double aWR[5010]; + double aXR[4850]; + double aYR[4296]; + double aZR[4180]; + + double oAR[15150]; + double oBR[14618]; + double oCR[14358]; + double oDR[13818]; + double oER[13562]; + double oFR[13046]; + double oGR[11966]; + double oHR[11130]; + double oIR[10598]; + double oJR[9810]; + double oKR[9522]; + double oLR[8982]; + double oMR[8786]; + double oNR[8462]; + double oOR[8310]; + double oPR[7982]; + double oQR[7322]; + double oRR[6818]; + double oSR[6506]; + double oTR[6002]; + double oUR[5838]; + double oVR[5502]; + double oWR[5010]; + double oXR[4850]; + double oYR[4296]; + double oZR[4180]; + + double dAL[7]; + double dBL[7]; + double dCL[7]; + double dDL[7]; + double dEL[7]; + double dFL[7]; + double dGL[7]; + double dHL[7]; + double dIL[7]; + double dJL[7]; + double dKL[7]; + double dLL[7]; + double dML[7]; + double dNL[7]; + double dOL[7]; + double dPL[7]; + double dQL[7]; + double dRL[7]; + double dSL[7]; + double dTL[7]; + double dUL[7]; + double dVL[7]; + double dWL[7]; + double dXL[7]; + double dYL[7]; + double dZL[7]; + + double aAL[15150]; + double aBL[14618]; + double aCL[14358]; + double aDL[13818]; + double aEL[13562]; + double aFL[13046]; + double aGL[11966]; + double aHL[11130]; + double aIL[10598]; + double aJL[9810]; + double aKL[9522]; + double aLL[8982]; + double aML[8786]; + double aNL[8462]; + double aOL[8310]; + double aPL[7982]; + double aQL[7322]; + double aRL[6818]; + double aSL[6506]; + double aTL[6002]; + double aUL[5838]; + double aVL[5502]; + double aWL[5010]; + double aXL[4850]; + double aYL[4296]; + double aZL[4180]; + + double oAL[15150]; + double oBL[14618]; + double oCL[14358]; + double oDL[13818]; + double oEL[13562]; + double oFL[13046]; + double oGL[11966]; + double oHL[11130]; + double oIL[10598]; + double oJL[9810]; + double oKL[9522]; + double oLL[8982]; + double oML[8786]; + double oNL[8462]; + double oOL[8310]; + double oPL[7982]; + double oQL[7322]; + double oRL[6818]; + double oSL[6506]; + double oTL[6002]; + double oUL[5838]; + double oVL[5502]; + double oWL[5010]; + double oXL[4850]; + double oYL[4296]; + double oZL[4180]; + + + + int outAL, alpAL; + int outBL, alpBL; + int outCL, alpCL; + int outDL, alpDL; + int outEL, alpEL; + int outFL, alpFL; + int outGL, alpGL; + int outHL, alpHL; + int outIL, alpIL; + int outJL, alpJL; + int outKL, alpKL; + int outLL, alpLL; + int outML, alpML; + int outNL, alpNL; + int outOL, alpOL; + int outPL, alpPL; + int outQL, alpQL; + int outRL, alpRL; + int outSL, alpSL; + int outTL, alpTL; + int outUL, alpUL; + int outVL, alpVL; + int outWL, alpWL; + int outXL, alpXL; + int outYL, alpYL; + int outZL, alpZL; + + int outAR, alpAR, maxdelayA, delayA; + int outBR, alpBR, maxdelayB, delayB; + int outCR, alpCR, maxdelayC, delayC; + int outDR, alpDR, maxdelayD, delayD; + int outER, alpER, maxdelayE, delayE; + int outFR, alpFR, maxdelayF, delayF; + int outGR, alpGR, maxdelayG, delayG; + int outHR, alpHR, maxdelayH, delayH; + int outIR, alpIR, maxdelayI, delayI; + int outJR, alpJR, maxdelayJ, delayJ; + int outKR, alpKR, maxdelayK, delayK; + int outLR, alpLR, maxdelayL, delayL; + int outMR, alpMR, maxdelayM, delayM; + int outNR, alpNR, maxdelayN, delayN; + int outOR, alpOR, maxdelayO, delayO; + int outPR, alpPR, maxdelayP, delayP; + int outQR, alpQR, maxdelayQ, delayQ; + int outRR, alpRR, maxdelayR, delayR; + int outSR, alpSR, maxdelayS, delayS; + int outTR, alpTR, maxdelayT, delayT; + int outUR, alpUR, maxdelayU, delayU; + int outVR, alpVR, maxdelayV, delayV; + int outWR, alpWR, maxdelayW, delayW; + int outXR, alpXR, maxdelayX, delayX; + int outYR, alpYR, maxdelayY, delayY; + int outZR, alpZR, maxdelayZ, delayZ; + + double savedRoomsize; + int countdown; + double peakL; + double peakR; + + uint32_t fpd; + //default stuff + + float A; + float B; + float C; + float D; + +}; + +#endif diff --git a/plugins/LinuxVST/src/PocketVerbs/PocketVerbsProc.cpp b/plugins/LinuxVST/src/PocketVerbs/PocketVerbsProc.cpp new file mode 100755 index 0000000..4ea8f51 --- /dev/null +++ b/plugins/LinuxVST/src/PocketVerbs/PocketVerbsProc.cpp @@ -0,0 +1,18358 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#include "PocketVerbs.h" +#endif + +void PocketVerbs::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + int verbtype = (VstInt32)( A * 5.999 )+1; + + double roomsize = (pow(B,2)*1.9)+0.1; + + double release = 0.00008 * pow(C,3); + if (release == 0.0) {peakL = 1.0; peakR = 1.0;} + double wetnesstarget = D; + double dryness = (1.0 - wetnesstarget); + //verbs use base wetness value internally + double wetness = wetnesstarget; + double constallpass = 0.618033988749894848204586; //golden ratio! + int allpasstemp; + int count; + int max = 70; //biggest divisor to test primes against + double bridgerectifier; + double gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive + //used as an aux, saturates when fed high levels + + //remap values to primes input number in question is 'i' + //max is the largest prime we care about- HF interactions more interesting than the big numbers + //pushing values larger and larger until we have a result + //for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}} + + if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAL; count < 15149; count++) {aAL[count] = 0.0;} + for(count = outAL; count < 15149; count++) {oAL[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBL; count < 14617; count++) {aBL[count] = 0.0;} + for(count = outBL; count < 14617; count++) {oBL[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCL; count < 14357; count++) {aCL[count] = 0.0;} + for(count = outCL; count < 14357; count++) {oCL[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDL; count < 13817; count++) {aDL[count] = 0.0;} + for(count = outDL; count < 13817; count++) {oDL[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpEL; count < 13561; count++) {aEL[count] = 0.0;} + for(count = outEL; count < 13561; count++) {oEL[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFL; count < 13045; count++) {aFL[count] = 0.0;} + for(count = outFL; count < 13045; count++) {oFL[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGL; count < 11965; count++) {aGL[count] = 0.0;} + for(count = outGL; count < 11965; count++) {oGL[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHL; count < 11129; count++) {aHL[count] = 0.0;} + for(count = outHL; count < 11129; count++) {oHL[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIL; count < 10597; count++) {aIL[count] = 0.0;} + for(count = outIL; count < 10597; count++) {oIL[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJL; count < 9809; count++) {aJL[count] = 0.0;} + for(count = outJL; count < 9809; count++) {oJL[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKL; count < 9521; count++) {aKL[count] = 0.0;} + for(count = outKL; count < 9521; count++) {oKL[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLL; count < 8981; count++) {aLL[count] = 0.0;} + for(count = outLL; count < 8981; count++) {oLL[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpML; count < 8785; count++) {aML[count] = 0.0;} + for(count = outML; count < 8785; count++) {oML[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNL; count < 8461; count++) {aNL[count] = 0.0;} + for(count = outNL; count < 8461; count++) {oNL[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOL; count < 8309; count++) {aOL[count] = 0.0;} + for(count = outOL; count < 8309; count++) {oOL[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPL; count < 7981; count++) {aPL[count] = 0.0;} + for(count = outPL; count < 7981; count++) {oPL[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQL; count < 7321; count++) {aQL[count] = 0.0;} + for(count = outQL; count < 7321; count++) {oQL[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRL; count < 6817; count++) {aRL[count] = 0.0;} + for(count = outRL; count < 6817; count++) {oRL[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSL; count < 6505; count++) {aSL[count] = 0.0;} + for(count = outSL; count < 6505; count++) {oSL[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTL; count < 6001; count++) {aTL[count] = 0.0;} + for(count = outTL; count < 6001; count++) {oTL[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUL; count < 5837; count++) {aUL[count] = 0.0;} + for(count = outUL; count < 5837; count++) {oUL[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVL; count < 5501; count++) {aVL[count] = 0.0;} + for(count = outVL; count < 5501; count++) {oVL[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWL; count < 5009; count++) {aWL[count] = 0.0;} + for(count = outWL; count < 5009; count++) {oWL[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXL; count < 4849; count++) {aXL[count] = 0.0;} + for(count = outXL; count < 4849; count++) {oXL[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYL; count < 4295; count++) {aYL[count] = 0.0;} + for(count = outYL; count < 4295; count++) {oYL[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZL; count < 4179; count++) {aZL[count] = 0.0;} + for(count = outZL; count < 4179; count++) {oZL[count] = 0.0;} + break; + } //end of switch statement + //countdown--; we are doing this after the second one + } + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAR; count < 15149; count++) {aAR[count] = 0.0;} + for(count = outAR; count < 15149; count++) {oAR[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBR; count < 14617; count++) {aBR[count] = 0.0;} + for(count = outBR; count < 14617; count++) {oBR[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCR; count < 14357; count++) {aCR[count] = 0.0;} + for(count = outCR; count < 14357; count++) {oCR[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDR; count < 13817; count++) {aDR[count] = 0.0;} + for(count = outDR; count < 13817; count++) {oDR[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpER; count < 13561; count++) {aER[count] = 0.0;} + for(count = outER; count < 13561; count++) {oER[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFR; count < 13045; count++) {aFR[count] = 0.0;} + for(count = outFR; count < 13045; count++) {oFR[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGR; count < 11965; count++) {aGR[count] = 0.0;} + for(count = outGR; count < 11965; count++) {oGR[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHR; count < 11129; count++) {aHR[count] = 0.0;} + for(count = outHR; count < 11129; count++) {oHR[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIR; count < 10597; count++) {aIR[count] = 0.0;} + for(count = outIR; count < 10597; count++) {oIR[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJR; count < 9809; count++) {aJR[count] = 0.0;} + for(count = outJR; count < 9809; count++) {oJR[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKR; count < 9521; count++) {aKR[count] = 0.0;} + for(count = outKR; count < 9521; count++) {oKR[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLR; count < 8981; count++) {aLR[count] = 0.0;} + for(count = outLR; count < 8981; count++) {oLR[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpMR; count < 8785; count++) {aMR[count] = 0.0;} + for(count = outMR; count < 8785; count++) {oMR[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNR; count < 8461; count++) {aNR[count] = 0.0;} + for(count = outNR; count < 8461; count++) {oNR[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOR; count < 8309; count++) {aOR[count] = 0.0;} + for(count = outOR; count < 8309; count++) {oOR[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPR; count < 7981; count++) {aPR[count] = 0.0;} + for(count = outPR; count < 7981; count++) {oPR[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQR; count < 7321; count++) {aQR[count] = 0.0;} + for(count = outQR; count < 7321; count++) {oQR[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRR; count < 6817; count++) {aRR[count] = 0.0;} + for(count = outRR; count < 6817; count++) {oRR[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSR; count < 6505; count++) {aSR[count] = 0.0;} + for(count = outSR; count < 6505; count++) {oSR[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTR; count < 6001; count++) {aTR[count] = 0.0;} + for(count = outTR; count < 6001; count++) {oTR[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUR; count < 5837; count++) {aUR[count] = 0.0;} + for(count = outUR; count < 5837; count++) {oUR[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVR; count < 5501; count++) {aVR[count] = 0.0;} + for(count = outVR; count < 5501; count++) {oVR[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWR; count < 5009; count++) {aWR[count] = 0.0;} + for(count = outWR; count < 5009; count++) {oWR[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXR; count < 4849; count++) {aXR[count] = 0.0;} + for(count = outXR; count < 4849; count++) {oXR[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYR; count < 4295; count++) {aYR[count] = 0.0;} + for(count = outYR; count < 4295; count++) {oYR[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZR; count < 4179; count++) {aZR[count] = 0.0;} + for(count = outZR; count < 4179; count++) {oZR[count] = 0.0;} + break; + } //end of switch statement + countdown--; //every buffer we'll do one of the recalculations for prime buffer sizes + } + + + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + + if (fabs(inputSampleL)<1.18e-37) inputSampleL = fpd * 1.18e-37; + if (fabs(inputSampleR)<1.18e-37) inputSampleR = fpd * 1.18e-37; + + long double drySampleL = inputSampleL; + long double drySampleR = inputSampleR; + + peakL -= release; + if (peakL < fabs(inputSampleL*2.0)) peakL = fabs(inputSampleL*2.0); + if (peakL > 1.0) peakL = 1.0; + peakR -= release; + if (peakR < fabs(inputSampleR*2.0)) peakR = fabs(inputSampleR*2.0); + if (peakR > 1.0) peakR = 1.0; + //chase the maximum signal to incorporate the wetter/louder behavior + //boost for more extreme effect when in use, cap it + + inputSampleL *= gain; + bridgerectifier = fabs(inputSampleL); + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + inputSampleR *= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + //here we apply the ADT2 console-on-steroids trick + + + + + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dYL[1] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dXL[1] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dWL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dVL[1] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dUL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dTL[1] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dSL[1] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dRL[1] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dQL[1] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dPL[1] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dOL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dNL[1] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dLL[1] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dKL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dJL[1] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dIL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dHL[1] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dGL[1] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dFL[1] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dEL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dDL[1] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dCL[1] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dAL[1] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dBL[1] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[5] + dZL[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = drySampleL; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[1]+dAL[2])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[1]+dBL[2])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[1]+dCL[2])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[1]+dDL[2])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[1]+dEL[2])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[1]+dFL[2])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[1]+dGL[2])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[1]+dHL[2])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[1]+dIL[2])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[1]+dJL[2])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[1]+dKL[2])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[1]+dLL[2])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1]+dML[2])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[1]+dNL[2])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[1]+dOL[2])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[1]+dPL[2])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[1]+dQL[2])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[1]+dRL[2])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[1]+dSL[2])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[1]+dTL[2])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[1]+dUL[2])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[1]+dVL[2])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[1]+dWL[2])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[1]+dXL[2])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[1]+dYL[2])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dBL[4] * dryness); + inputSampleL += (dCL[4] * dryness); + inputSampleL += dDL[4]; + inputSampleL += dEL[4]; + inputSampleL += dFL[4]; + inputSampleL += dGL[4]; + inputSampleL += dHL[4]; + inputSampleL += dIL[4]; + inputSampleL += dJL[4]; + inputSampleL += dKL[4]; + inputSampleL += dLL[4]; + inputSampleL += dML[4]; + inputSampleL += dNL[4]; + inputSampleL += dOL[4]; + inputSampleL += dPL[4]; + inputSampleL += dQL[4]; + inputSampleL += dRL[4]; + inputSampleL += dSL[4]; + inputSampleL += dTL[4]; + inputSampleL += dUL[4]; + inputSampleL += dVL[4]; + inputSampleL += dWL[4]; + inputSampleL += dXL[4]; + inputSampleL += dYL[4]; + inputSampleL += (dZL[4] * wetness); + + inputSampleL += (dBL[5] * dryness); + inputSampleL += (dCL[5] * dryness); + inputSampleL += dDL[5]; + inputSampleL += dEL[5]; + inputSampleL += dFL[5]; + inputSampleL += dGL[5]; + inputSampleL += dHL[5]; + inputSampleL += dIL[5]; + inputSampleL += dJL[5]; + inputSampleL += dKL[5]; + inputSampleL += dLL[5]; + inputSampleL += dML[5]; + inputSampleL += dNL[5]; + inputSampleL += dOL[5]; + inputSampleL += dPL[5]; + inputSampleL += dQL[5]; + inputSampleL += dRL[5]; + inputSampleL += dSL[5]; + inputSampleL += dTL[5]; + inputSampleL += dUL[5]; + inputSampleL += dVL[5]; + inputSampleL += dWL[5]; + inputSampleL += dXL[5]; + inputSampleL += dYL[5]; + inputSampleL += (dZL[5] * wetness); + + inputSampleL /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dZL[3])/3.0; //add feedback + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dCL[1] + dAL[5] + dAL[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dYR[1] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dXR[1] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dWR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dVR[1] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dUR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dTR[1] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dSR[1] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dRR[1] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dQR[1] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dPR[1] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dOR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dNR[1] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dLR[1] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dKR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dJR[1] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dIR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dHR[1] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dGR[1] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dFR[1] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dER[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dDR[1] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dCR[1] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dAR[1] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dBR[1] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[5] + dZR[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = drySampleR; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[1]+dAR[2])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[1]+dBR[2])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[1]+dCR[2])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[1]+dDR[2])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[1]+dER[2])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[1]+dFR[2])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[1]+dGR[2])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[1]+dHR[2])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[1]+dIR[2])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[1]+dJR[2])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[1]+dKR[2])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[1]+dLR[2])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1]+dMR[2])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[1]+dNR[2])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[1]+dOR[2])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[1]+dPR[2])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[1]+dQR[2])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[1]+dRR[2])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[1]+dSR[2])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[1]+dTR[2])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[1]+dUR[2])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[1]+dVR[2])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[1]+dWR[2])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[1]+dXR[2])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[1]+dYR[2])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dBR[4] * dryness); + inputSampleR += (dCR[4] * dryness); + inputSampleR += dDR[4]; + inputSampleR += dER[4]; + inputSampleR += dFR[4]; + inputSampleR += dGR[4]; + inputSampleR += dHR[4]; + inputSampleR += dIR[4]; + inputSampleR += dJR[4]; + inputSampleR += dKR[4]; + inputSampleR += dLR[4]; + inputSampleR += dMR[4]; + inputSampleR += dNR[4]; + inputSampleR += dOR[4]; + inputSampleR += dPR[4]; + inputSampleR += dQR[4]; + inputSampleR += dRR[4]; + inputSampleR += dSR[4]; + inputSampleR += dTR[4]; + inputSampleR += dUR[4]; + inputSampleR += dVR[4]; + inputSampleR += dWR[4]; + inputSampleR += dXR[4]; + inputSampleR += dYR[4]; + inputSampleR += (dZR[4] * wetness); + + inputSampleR += (dBR[5] * dryness); + inputSampleR += (dCR[5] * dryness); + inputSampleR += dDR[5]; + inputSampleR += dER[5]; + inputSampleR += dFR[5]; + inputSampleR += dGR[5]; + inputSampleR += dHR[5]; + inputSampleR += dIR[5]; + inputSampleR += dJR[5]; + inputSampleR += dKR[5]; + inputSampleR += dLR[5]; + inputSampleR += dMR[5]; + inputSampleR += dNR[5]; + inputSampleR += dOR[5]; + inputSampleR += dPR[5]; + inputSampleR += dQR[5]; + inputSampleR += dRR[5]; + inputSampleR += dSR[5]; + inputSampleR += dTR[5]; + inputSampleR += dUR[5]; + inputSampleR += dVR[5]; + inputSampleR += dWR[5]; + inputSampleR += dXR[5]; + inputSampleR += dYR[5]; + inputSampleR += (dZR[5] * wetness); + + inputSampleR /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dZR[3])/3.0; //add feedback + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dCR[1] + dAR[5] + dAR[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + + bridgerectifier = fabs(inputSampleL); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleL > 0) inputSampleL -= bridgerectifier; + else inputSampleL += bridgerectifier; + inputSampleL /= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleR > 0) inputSampleR -= bridgerectifier; + else inputSampleR += bridgerectifier; + inputSampleR /= gain; + //here we apply the ADT2 'console on steroids' trick + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakL; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleL *= (1.0-wetness); + inputSampleL *= wetness; + inputSampleL += drySampleL; + //here we combine the tanks with the dry signal + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakR; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleR *= (1.0-wetness); + inputSampleR *= wetness; + inputSampleR += drySampleR; + //here we combine the tanks with the dry signal + + //begin 32 bit stereo floating point dither + int expon; frexpf((float)inputSampleL, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleL += ((double(fpd)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + frexpf((float)inputSampleR, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleR += ((double(fpd)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + //end 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} + +void PocketVerbs::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + int verbtype = (VstInt32)( A * 5.999 )+1; + + double roomsize = (pow(B,2)*1.9)+0.1; + + double release = 0.00008 * pow(C,3); + if (release == 0.0) {peakL = 1.0; peakR = 1.0;} + double wetnesstarget = D; + double dryness = (1.0 - wetnesstarget); + //verbs use base wetness value internally + double wetness = wetnesstarget; + double constallpass = 0.618033988749894848204586; //golden ratio! + int allpasstemp; + int count; + int max = 70; //biggest divisor to test primes against + double bridgerectifier; + double gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive + //used as an aux, saturates when fed high levels + + //remap values to primes input number in question is 'i' + //max is the largest prime we care about- HF interactions more interesting than the big numbers + //pushing values larger and larger until we have a result + //for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}} + + if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAL; count < 15149; count++) {aAL[count] = 0.0;} + for(count = outAL; count < 15149; count++) {oAL[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBL; count < 14617; count++) {aBL[count] = 0.0;} + for(count = outBL; count < 14617; count++) {oBL[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCL; count < 14357; count++) {aCL[count] = 0.0;} + for(count = outCL; count < 14357; count++) {oCL[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDL; count < 13817; count++) {aDL[count] = 0.0;} + for(count = outDL; count < 13817; count++) {oDL[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpEL; count < 13561; count++) {aEL[count] = 0.0;} + for(count = outEL; count < 13561; count++) {oEL[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFL; count < 13045; count++) {aFL[count] = 0.0;} + for(count = outFL; count < 13045; count++) {oFL[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGL; count < 11965; count++) {aGL[count] = 0.0;} + for(count = outGL; count < 11965; count++) {oGL[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHL; count < 11129; count++) {aHL[count] = 0.0;} + for(count = outHL; count < 11129; count++) {oHL[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIL; count < 10597; count++) {aIL[count] = 0.0;} + for(count = outIL; count < 10597; count++) {oIL[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJL; count < 9809; count++) {aJL[count] = 0.0;} + for(count = outJL; count < 9809; count++) {oJL[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKL; count < 9521; count++) {aKL[count] = 0.0;} + for(count = outKL; count < 9521; count++) {oKL[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLL; count < 8981; count++) {aLL[count] = 0.0;} + for(count = outLL; count < 8981; count++) {oLL[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpML; count < 8785; count++) {aML[count] = 0.0;} + for(count = outML; count < 8785; count++) {oML[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNL; count < 8461; count++) {aNL[count] = 0.0;} + for(count = outNL; count < 8461; count++) {oNL[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOL; count < 8309; count++) {aOL[count] = 0.0;} + for(count = outOL; count < 8309; count++) {oOL[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPL; count < 7981; count++) {aPL[count] = 0.0;} + for(count = outPL; count < 7981; count++) {oPL[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQL; count < 7321; count++) {aQL[count] = 0.0;} + for(count = outQL; count < 7321; count++) {oQL[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRL; count < 6817; count++) {aRL[count] = 0.0;} + for(count = outRL; count < 6817; count++) {oRL[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSL; count < 6505; count++) {aSL[count] = 0.0;} + for(count = outSL; count < 6505; count++) {oSL[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTL; count < 6001; count++) {aTL[count] = 0.0;} + for(count = outTL; count < 6001; count++) {oTL[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUL; count < 5837; count++) {aUL[count] = 0.0;} + for(count = outUL; count < 5837; count++) {oUL[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVL; count < 5501; count++) {aVL[count] = 0.0;} + for(count = outVL; count < 5501; count++) {oVL[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWL; count < 5009; count++) {aWL[count] = 0.0;} + for(count = outWL; count < 5009; count++) {oWL[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXL; count < 4849; count++) {aXL[count] = 0.0;} + for(count = outXL; count < 4849; count++) {oXL[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYL; count < 4295; count++) {aYL[count] = 0.0;} + for(count = outYL; count < 4295; count++) {oYL[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZL; count < 4179; count++) {aZL[count] = 0.0;} + for(count = outZL; count < 4179; count++) {oZL[count] = 0.0;} + break; + } //end of switch statement + //countdown--; we are doing this after the second one + } + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAR; count < 15149; count++) {aAR[count] = 0.0;} + for(count = outAR; count < 15149; count++) {oAR[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBR; count < 14617; count++) {aBR[count] = 0.0;} + for(count = outBR; count < 14617; count++) {oBR[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCR; count < 14357; count++) {aCR[count] = 0.0;} + for(count = outCR; count < 14357; count++) {oCR[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDR; count < 13817; count++) {aDR[count] = 0.0;} + for(count = outDR; count < 13817; count++) {oDR[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpER; count < 13561; count++) {aER[count] = 0.0;} + for(count = outER; count < 13561; count++) {oER[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFR; count < 13045; count++) {aFR[count] = 0.0;} + for(count = outFR; count < 13045; count++) {oFR[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGR; count < 11965; count++) {aGR[count] = 0.0;} + for(count = outGR; count < 11965; count++) {oGR[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHR; count < 11129; count++) {aHR[count] = 0.0;} + for(count = outHR; count < 11129; count++) {oHR[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIR; count < 10597; count++) {aIR[count] = 0.0;} + for(count = outIR; count < 10597; count++) {oIR[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJR; count < 9809; count++) {aJR[count] = 0.0;} + for(count = outJR; count < 9809; count++) {oJR[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKR; count < 9521; count++) {aKR[count] = 0.0;} + for(count = outKR; count < 9521; count++) {oKR[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLR; count < 8981; count++) {aLR[count] = 0.0;} + for(count = outLR; count < 8981; count++) {oLR[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpMR; count < 8785; count++) {aMR[count] = 0.0;} + for(count = outMR; count < 8785; count++) {oMR[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNR; count < 8461; count++) {aNR[count] = 0.0;} + for(count = outNR; count < 8461; count++) {oNR[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOR; count < 8309; count++) {aOR[count] = 0.0;} + for(count = outOR; count < 8309; count++) {oOR[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPR; count < 7981; count++) {aPR[count] = 0.0;} + for(count = outPR; count < 7981; count++) {oPR[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQR; count < 7321; count++) {aQR[count] = 0.0;} + for(count = outQR; count < 7321; count++) {oQR[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRR; count < 6817; count++) {aRR[count] = 0.0;} + for(count = outRR; count < 6817; count++) {oRR[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSR; count < 6505; count++) {aSR[count] = 0.0;} + for(count = outSR; count < 6505; count++) {oSR[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTR; count < 6001; count++) {aTR[count] = 0.0;} + for(count = outTR; count < 6001; count++) {oTR[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUR; count < 5837; count++) {aUR[count] = 0.0;} + for(count = outUR; count < 5837; count++) {oUR[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVR; count < 5501; count++) {aVR[count] = 0.0;} + for(count = outVR; count < 5501; count++) {oVR[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWR; count < 5009; count++) {aWR[count] = 0.0;} + for(count = outWR; count < 5009; count++) {oWR[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXR; count < 4849; count++) {aXR[count] = 0.0;} + for(count = outXR; count < 4849; count++) {oXR[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYR; count < 4295; count++) {aYR[count] = 0.0;} + for(count = outYR; count < 4295; count++) {oYR[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZR; count < 4179; count++) {aZR[count] = 0.0;} + for(count = outZR; count < 4179; count++) {oZR[count] = 0.0;} + break; + } //end of switch statement + countdown--; //every buffer we'll do one of the recalculations for prime buffer sizes + } + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + + if (fabs(inputSampleL)<1.18e-43) inputSampleL = fpd * 1.18e-43; + if (fabs(inputSampleR)<1.18e-43) inputSampleR = fpd * 1.18e-43; + + long double drySampleL = inputSampleL; + long double drySampleR = inputSampleR; + + peakL -= release; + if (peakL < fabs(inputSampleL*2.0)) peakL = fabs(inputSampleL*2.0); + if (peakL > 1.0) peakL = 1.0; + peakR -= release; + if (peakR < fabs(inputSampleR*2.0)) peakR = fabs(inputSampleR*2.0); + if (peakR > 1.0) peakR = 1.0; + //chase the maximum signal to incorporate the wetter/louder behavior + //boost for more extreme effect when in use, cap it + + inputSampleL *= gain; + bridgerectifier = fabs(inputSampleL); + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + inputSampleR *= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + //here we apply the ADT2 console-on-steroids trick + + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dYL[1] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dXL[1] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dWL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dVL[1] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dUL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dTL[1] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dSL[1] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dRL[1] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dQL[1] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dPL[1] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dOL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dNL[1] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dLL[1] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dKL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dJL[1] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dIL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dHL[1] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dGL[1] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dFL[1] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dEL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dDL[1] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dCL[1] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dAL[1] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dBL[1] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[5] + dZL[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = drySampleL; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[1]+dAL[2])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[1]+dBL[2])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[1]+dCL[2])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[1]+dDL[2])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[1]+dEL[2])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[1]+dFL[2])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[1]+dGL[2])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[1]+dHL[2])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[1]+dIL[2])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[1]+dJL[2])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[1]+dKL[2])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[1]+dLL[2])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1]+dML[2])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[1]+dNL[2])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[1]+dOL[2])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[1]+dPL[2])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[1]+dQL[2])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[1]+dRL[2])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[1]+dSL[2])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[1]+dTL[2])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[1]+dUL[2])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[1]+dVL[2])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[1]+dWL[2])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[1]+dXL[2])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[1]+dYL[2])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dBL[4] * dryness); + inputSampleL += (dCL[4] * dryness); + inputSampleL += dDL[4]; + inputSampleL += dEL[4]; + inputSampleL += dFL[4]; + inputSampleL += dGL[4]; + inputSampleL += dHL[4]; + inputSampleL += dIL[4]; + inputSampleL += dJL[4]; + inputSampleL += dKL[4]; + inputSampleL += dLL[4]; + inputSampleL += dML[4]; + inputSampleL += dNL[4]; + inputSampleL += dOL[4]; + inputSampleL += dPL[4]; + inputSampleL += dQL[4]; + inputSampleL += dRL[4]; + inputSampleL += dSL[4]; + inputSampleL += dTL[4]; + inputSampleL += dUL[4]; + inputSampleL += dVL[4]; + inputSampleL += dWL[4]; + inputSampleL += dXL[4]; + inputSampleL += dYL[4]; + inputSampleL += (dZL[4] * wetness); + + inputSampleL += (dBL[5] * dryness); + inputSampleL += (dCL[5] * dryness); + inputSampleL += dDL[5]; + inputSampleL += dEL[5]; + inputSampleL += dFL[5]; + inputSampleL += dGL[5]; + inputSampleL += dHL[5]; + inputSampleL += dIL[5]; + inputSampleL += dJL[5]; + inputSampleL += dKL[5]; + inputSampleL += dLL[5]; + inputSampleL += dML[5]; + inputSampleL += dNL[5]; + inputSampleL += dOL[5]; + inputSampleL += dPL[5]; + inputSampleL += dQL[5]; + inputSampleL += dRL[5]; + inputSampleL += dSL[5]; + inputSampleL += dTL[5]; + inputSampleL += dUL[5]; + inputSampleL += dVL[5]; + inputSampleL += dWL[5]; + inputSampleL += dXL[5]; + inputSampleL += dYL[5]; + inputSampleL += (dZL[5] * wetness); + + inputSampleL /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dZL[3])/3.0; //add feedback + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dCL[1] + dAL[5] + dAL[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dYR[1] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dXR[1] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dWR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dVR[1] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dUR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dTR[1] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dSR[1] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dRR[1] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dQR[1] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dPR[1] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dOR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dNR[1] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dLR[1] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dKR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dJR[1] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dIR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dHR[1] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dGR[1] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dFR[1] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dER[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dDR[1] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dCR[1] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dAR[1] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dBR[1] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[5] + dZR[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = drySampleR; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[1]+dAR[2])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[1]+dBR[2])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[1]+dCR[2])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[1]+dDR[2])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[1]+dER[2])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[1]+dFR[2])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[1]+dGR[2])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[1]+dHR[2])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[1]+dIR[2])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[1]+dJR[2])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[1]+dKR[2])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[1]+dLR[2])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1]+dMR[2])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[1]+dNR[2])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[1]+dOR[2])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[1]+dPR[2])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[1]+dQR[2])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[1]+dRR[2])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[1]+dSR[2])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[1]+dTR[2])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[1]+dUR[2])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[1]+dVR[2])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[1]+dWR[2])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[1]+dXR[2])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[1]+dYR[2])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dBR[4] * dryness); + inputSampleR += (dCR[4] * dryness); + inputSampleR += dDR[4]; + inputSampleR += dER[4]; + inputSampleR += dFR[4]; + inputSampleR += dGR[4]; + inputSampleR += dHR[4]; + inputSampleR += dIR[4]; + inputSampleR += dJR[4]; + inputSampleR += dKR[4]; + inputSampleR += dLR[4]; + inputSampleR += dMR[4]; + inputSampleR += dNR[4]; + inputSampleR += dOR[4]; + inputSampleR += dPR[4]; + inputSampleR += dQR[4]; + inputSampleR += dRR[4]; + inputSampleR += dSR[4]; + inputSampleR += dTR[4]; + inputSampleR += dUR[4]; + inputSampleR += dVR[4]; + inputSampleR += dWR[4]; + inputSampleR += dXR[4]; + inputSampleR += dYR[4]; + inputSampleR += (dZR[4] * wetness); + + inputSampleR += (dBR[5] * dryness); + inputSampleR += (dCR[5] * dryness); + inputSampleR += dDR[5]; + inputSampleR += dER[5]; + inputSampleR += dFR[5]; + inputSampleR += dGR[5]; + inputSampleR += dHR[5]; + inputSampleR += dIR[5]; + inputSampleR += dJR[5]; + inputSampleR += dKR[5]; + inputSampleR += dLR[5]; + inputSampleR += dMR[5]; + inputSampleR += dNR[5]; + inputSampleR += dOR[5]; + inputSampleR += dPR[5]; + inputSampleR += dQR[5]; + inputSampleR += dRR[5]; + inputSampleR += dSR[5]; + inputSampleR += dTR[5]; + inputSampleR += dUR[5]; + inputSampleR += dVR[5]; + inputSampleR += dWR[5]; + inputSampleR += dXR[5]; + inputSampleR += dYR[5]; + inputSampleR += (dZR[5] * wetness); + + inputSampleR /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dZR[3])/3.0; //add feedback + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dCR[1] + dAR[5] + dAR[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + bridgerectifier = fabs(inputSampleL); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleL > 0) inputSampleL -= bridgerectifier; + else inputSampleL += bridgerectifier; + inputSampleL /= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleR > 0) inputSampleR -= bridgerectifier; + else inputSampleR += bridgerectifier; + inputSampleR /= gain; + //here we apply the ADT2 'console on steroids' trick + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakL; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleL *= (1.0-wetness); + inputSampleL *= wetness; + inputSampleL += drySampleL; + //here we combine the tanks with the dry signal + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakR; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleR *= (1.0-wetness); + inputSampleR *= wetness; + inputSampleR += drySampleR; + //here we combine the tanks with the dry signal + + //begin 64 bit stereo floating point dither + int expon; frexp((double)inputSampleL, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleL += ((double(fpd)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + frexp((double)inputSampleR, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleR += ((double(fpd)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //end 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} diff --git a/plugins/MacAU/PocketVerbs/English.lproj/InfoPlist.strings b/plugins/MacAU/PocketVerbs/English.lproj/InfoPlist.strings new file mode 100755 index 0000000..eaeed1c Binary files /dev/null and b/plugins/MacAU/PocketVerbs/English.lproj/InfoPlist.strings differ diff --git a/plugins/MacAU/PocketVerbs/Info.plist b/plugins/MacAU/PocketVerbs/Info.plist new file mode 100755 index 0000000..12f0517 --- /dev/null +++ b/plugins/MacAU/PocketVerbs/Info.plist @@ -0,0 +1,28 @@ + + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + ${EXECUTABLE_NAME} + CFBundleIconFile + + CFBundleIdentifier + com.airwindows.audiounit.${PRODUCT_NAME:identifier} + CFBundleName + ${PROJECTNAMEASIDENTIFIER} + CFBundleInfoDictionaryVersion + 6.0 + CFBundlePackageType + BNDL + CFBundleShortVersionString + 1.0 + CFBundleSignature + Dthr + CFBundleVersion + 1.0 + CSResourcesFileMapped + + + diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.cpp b/plugins/MacAU/PocketVerbs/PocketVerbs.cpp new file mode 100755 index 0000000..741b94e --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbs.cpp @@ -0,0 +1,4909 @@ +/* +* File: PocketVerbs.cpp +* +* Version: 1.0 +* +* Created: 8/19/12 +* +* Copyright: Copyright © 2012 Airwindows, All Rights Reserved +* +* Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in +* consideration of your agreement to the following terms, and your use, installation, modification +* or redistribution of this Apple software constitutes acceptance of these terms. If you do +* not agree with these terms, please do not use, install, modify or redistribute this Apple +* software. +* +* In consideration of your agreement to abide by the following terms, and subject to these terms, +* Apple grants you a personal, non-exclusive license, under Apple's copyrights in this +* original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the +* Apple Software, with or without modifications, in source and/or binary forms; provided that if you +* redistribute the Apple Software in its entirety and without modifications, you must retain this +* notice and the following text and disclaimers in all such redistributions of the Apple Software. +* Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to +* endorse or promote products derived from the Apple Software without specific prior written +* permission from Apple. Except as expressly stated in this notice, no other rights or +* licenses, express or implied, are granted by Apple herein, including but not limited to any +* patent rights that may be infringed by your derivative works or by other works in which the +* Apple Software may be incorporated. +* +* The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO WARRANTIES, EXPRESS OR +* IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY +* AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE +* OR IN COMBINATION WITH YOUR PRODUCTS. +* +* IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL +* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, +* REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER +* UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN +* IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*/ +/*============================================================================= + PocketVerbs.cpp + +=============================================================================*/ +#include "PocketVerbs.h" + + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +COMPONENT_ENTRY(PocketVerbs) + + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// PocketVerbs::PocketVerbs +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +PocketVerbs::PocketVerbs(AudioUnit component) + : AUEffectBase(component) +{ + CreateElements(); + Globals()->UseIndexedParameters(kNumberOfParameters); + SetParameter(kParam_One, kDefaultValue_ParamOne ); + SetParameter(kParam_Two, kDefaultValue_ParamTwo ); + SetParameter(kParam_Three, kDefaultValue_ParamThree ); + SetParameter(kParam_Four, kDefaultValue_ParamFour ); + +#if AU_DEBUG_DISPATCHER + mDebugDispatcher = new AUDebugDispatcher (this); +#endif + +} + + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// PocketVerbs::GetParameterValueStrings +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +ComponentResult PocketVerbs::GetParameterValueStrings(AudioUnitScope inScope, + AudioUnitParameterID inParameterID, + CFArrayRef * outStrings) +{ + if ((inScope == kAudioUnitScope_Global) && (inParameterID == kParam_One)) //ID must be actual name of parameter identifier, not number + { + if (outStrings == NULL) return noErr; + CFStringRef strings [] = + { + kMenuItem_Chamber, + kMenuItem_Spring, + kMenuItem_Tiled, + kMenuItem_Room, + kMenuItem_Stretch, + kMenuItem_Zarathustra, + }; + *outStrings = CFArrayCreate ( + NULL, + (const void **) strings, + (sizeof (strings) / sizeof (strings [0])), + NULL + ); + return noErr; + } + return kAudioUnitErr_InvalidProperty; +} + + + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// PocketVerbs::GetParameterInfo +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +ComponentResult PocketVerbs::GetParameterInfo(AudioUnitScope inScope, + AudioUnitParameterID inParameterID, + AudioUnitParameterInfo &outParameterInfo ) +{ + ComponentResult result = noErr; + + outParameterInfo.flags = kAudioUnitParameterFlag_IsWritable + | kAudioUnitParameterFlag_IsReadable; + + if (inScope == kAudioUnitScope_Global) { + switch(inParameterID) + { + case kParam_One: + AUBase::FillInParameterName (outParameterInfo, kParameterOneName, false); + outParameterInfo.unit = kAudioUnitParameterUnit_Indexed; + outParameterInfo.minValue = kChamber; + outParameterInfo.maxValue = kZarathustra; + outParameterInfo.defaultValue = kDefaultValue_ParamOne; + break; + case kParam_Two: + AUBase::FillInParameterName (outParameterInfo, kParameterTwoName, false); + outParameterInfo.unit = kAudioUnitParameterUnit_Generic; + outParameterInfo.minValue = 0.0; + outParameterInfo.maxValue = 1.0; + outParameterInfo.defaultValue = kDefaultValue_ParamTwo; + break; + case kParam_Three: + AUBase::FillInParameterName (outParameterInfo, kParameterThreeName, false); + outParameterInfo.unit = kAudioUnitParameterUnit_Generic; + outParameterInfo.minValue = 0.0; + outParameterInfo.maxValue = 1.0; + outParameterInfo.defaultValue = kDefaultValue_ParamThree; + break; + case kParam_Four: + AUBase::FillInParameterName (outParameterInfo, kParameterFourName, false); + outParameterInfo.unit = kAudioUnitParameterUnit_Generic; + outParameterInfo.minValue = 0.0; + outParameterInfo.maxValue = 1.0; + outParameterInfo.defaultValue = kDefaultValue_ParamFour; + break; + default: + result = kAudioUnitErr_InvalidParameter; + break; + } + } else { + result = kAudioUnitErr_InvalidParameter; + } + + + + return result; +} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// PocketVerbs::GetPropertyInfo +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +ComponentResult PocketVerbs::GetPropertyInfo (AudioUnitPropertyID inID, + AudioUnitScope inScope, + AudioUnitElement inElement, + UInt32 & outDataSize, + Boolean & outWritable) +{ + return AUEffectBase::GetPropertyInfo (inID, inScope, inElement, outDataSize, outWritable); +} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// PocketVerbs::GetProperty +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +ComponentResult PocketVerbs::GetProperty( AudioUnitPropertyID inID, + AudioUnitScope inScope, + AudioUnitElement inElement, + void * outData ) +{ + return AUEffectBase::GetProperty (inID, inScope, inElement, outData); +} + +// PocketVerbs::Initialize +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +ComponentResult PocketVerbs::Initialize() +{ + ComponentResult result = AUEffectBase::Initialize(); + if (result == noErr) + Reset(kAudioUnitScope_Global, 0); + return result; +} + +#pragma mark ____PocketVerbsEffectKernel + + + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// PocketVerbs::PocketVerbsKernel::Reset() +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +void PocketVerbs::PocketVerbsKernel::Reset() +{ + int count; + for(count = 0; count < 6; count++) {dA[count] = 0.0; dB[count] = 0.0; dC[count] = 0.0; dD[count] = 0.0; dE[count] = 0.0; + dF[count] = 0.0; dG[count] = 0.0; dH[count] = 0.0; dI[count] = 0.0; dJ[count] = 0.0; dK[count] = 0.0; dL[count] = 0.0; + dM[count] = 0.0; dN[count] = 0.0; dO[count] = 0.0; dP[count] = 0.0; dQ[count] = 0.0; dR[count] = 0.0; dS[count] = 0.0; + dT[count] = 0.0; dU[count] = 0.0; dV[count] = 0.0; dW[count] = 0.0; dX[count] = 0.0; dY[count] = 0.0; dZ[count] = 0.0;} + + for(count = 0; count < 15149; count++) {aA[count] = 0.0;} + for(count = 0; count < 15149; count++) {oA[count] = 0.0;} + for(count = 0; count < 14617; count++) {aB[count] = 0.0;} + for(count = 0; count < 14617; count++) {oB[count] = 0.0;} + for(count = 0; count < 14357; count++) {aC[count] = 0.0;} + for(count = 0; count < 14357; count++) {oC[count] = 0.0;} + for(count = 0; count < 13817; count++) {aD[count] = 0.0;} + for(count = 0; count < 13817; count++) {oD[count] = 0.0;} + for(count = 0; count < 13561; count++) {aE[count] = 0.0;} + for(count = 0; count < 13561; count++) {oE[count] = 0.0;} + for(count = 0; count < 13045; count++) {aF[count] = 0.0;} + for(count = 0; count < 13045; count++) {oF[count] = 0.0;} + for(count = 0; count < 11965; count++) {aG[count] = 0.0;} + for(count = 0; count < 11965; count++) {oG[count] = 0.0;} + for(count = 0; count < 11129; count++) {aH[count] = 0.0;} + for(count = 0; count < 11129; count++) {oH[count] = 0.0;} + for(count = 0; count < 10597; count++) {aI[count] = 0.0;} + for(count = 0; count < 10597; count++) {oI[count] = 0.0;} + for(count = 0; count < 9809; count++) {aJ[count] = 0.0;} + for(count = 0; count < 9809; count++) {oJ[count] = 0.0;} + for(count = 0; count < 9521; count++) {aK[count] = 0.0;} + for(count = 0; count < 9521; count++) {oK[count] = 0.0;} + for(count = 0; count < 8981; count++) {aL[count] = 0.0;} + for(count = 0; count < 8981; count++) {oL[count] = 0.0;} + for(count = 0; count < 8785; count++) {aM[count] = 0.0;} + for(count = 0; count < 8785; count++) {oM[count] = 0.0;} + for(count = 0; count < 8461; count++) {aN[count] = 0.0;} + for(count = 0; count < 8461; count++) {oN[count] = 0.0;} + for(count = 0; count < 8309; count++) {aO[count] = 0.0;} + for(count = 0; count < 8309; count++) {oO[count] = 0.0;} + for(count = 0; count < 7981; count++) {aP[count] = 0.0;} + for(count = 0; count < 7981; count++) {oP[count] = 0.0;} + for(count = 0; count < 7321; count++) {aQ[count] = 0.0;} + for(count = 0; count < 7321; count++) {oQ[count] = 0.0;} + for(count = 0; count < 6817; count++) {aR[count] = 0.0;} + for(count = 0; count < 6817; count++) {oR[count] = 0.0;} + for(count = 0; count < 6505; count++) {aS[count] = 0.0;} + for(count = 0; count < 6505; count++) {oS[count] = 0.0;} + for(count = 0; count < 6001; count++) {aT[count] = 0.0;} + for(count = 0; count < 6001; count++) {oT[count] = 0.0;} + for(count = 0; count < 5837; count++) {aU[count] = 0.0;} + for(count = 0; count < 5837; count++) {oU[count] = 0.0;} + for(count = 0; count < 5501; count++) {aV[count] = 0.0;} + for(count = 0; count < 5501; count++) {oV[count] = 0.0;} + for(count = 0; count < 5009; count++) {aW[count] = 0.0;} + for(count = 0; count < 5009; count++) {oW[count] = 0.0;} + for(count = 0; count < 4849; count++) {aX[count] = 0.0;} + for(count = 0; count < 4849; count++) {oX[count] = 0.0;} + for(count = 0; count < 4295; count++) {aY[count] = 0.0;} + for(count = 0; count < 4295; count++) {oY[count] = 0.0;} + for(count = 0; count < 4179; count++) {aZ[count] = 0.0;} + for(count = 0; count < 4179; count++) {oZ[count] = 0.0;} + + + outA = 1; alpA = 1; delayA = 4; maxdelayA = 7573; + outB = 1; alpB = 1; delayB = 4; maxdelayB = 7307; + outC = 1; alpC = 1; delayC = 4; maxdelayC = 7177; + outD = 1; alpD = 1; delayD = 4; maxdelayD = 6907; + outE = 1; alpE = 1; delayE = 4; maxdelayE = 6779; + outF = 1; alpF = 1; delayF = 4; maxdelayF = 6521; + outG = 1; alpG = 1; delayG = 4; maxdelayG = 5981; + outH = 1; alpH = 1; delayH = 4; maxdelayH = 5563; + outI = 1; alpI = 1; delayI = 4; maxdelayI = 5297; + outJ = 1; alpJ = 1; delayJ = 4; maxdelayJ = 4903; + outK = 1; alpK = 1; delayK = 4; maxdelayK = 4759; + outL = 1; alpL = 1; delayL = 4; maxdelayL = 4489; + outM = 1; alpM = 1; delayM = 4; maxdelayM = 4391; + outN = 1; alpN = 1; delayN = 4; maxdelayN = 4229; + outO = 1; alpO = 1; delayO = 4; maxdelayO = 4153; + outP = 1; alpP = 1; delayP = 4; maxdelayP = 3989; + outQ = 1; alpQ = 1; delayQ = 4; maxdelayQ = 3659; + outR = 1; alpR = 1; delayR = 4; maxdelayR = 3407; + outS = 1; alpS = 1; delayS = 4; maxdelayS = 3251; + outT = 1; alpT = 1; delayT = 4; maxdelayT = 2999; + outU = 1; alpU = 1; delayU = 4; maxdelayU = 2917; + outV = 1; alpV = 1; delayV = 4; maxdelayV = 2749; + outW = 1; alpW = 1; delayW = 4; maxdelayW = 2503; + outX = 1; alpX = 1; delayX = 4; maxdelayX = 2423; + outY = 1; alpY = 1; delayY = 4; maxdelayY = 2146; + outZ = 1; alpZ = 1; delayZ = 4; maxdelayZ = 2088; + + savedRoomsize = -1.0; //force update to begin + countdown = -1; + peak = 1.0; + fpd = 17; +} + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +// PocketVerbs::PocketVerbsKernel::Process +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +void PocketVerbs::PocketVerbsKernel::Process( const Float32 *inSourceP, + Float32 *inDestP, + UInt32 inFramesToProcess, + UInt32 inNumChannels, + bool &ioSilence ) +{ + UInt32 nSampleFrames = inFramesToProcess; + const Float32 *sourceP = inSourceP; + Float32 *destP = inDestP; + int verbtype = GetParameter( kParam_One ); + Float64 roomsize = (pow(GetParameter( kParam_Two ),2)*1.9)+0.1; + + Float64 release = 0.00008 * pow(GetParameter( kParam_Three ),3); + if (release == 0.0) peak = 1.0; + Float64 wetnesstarget = GetParameter( kParam_Four ); + Float64 dryness = (1.0 - wetnesstarget); + //verbs use base wetness value internally + Float64 wetness = wetnesstarget; + Float64 constallpass = 0.618033988749894848204586; //golden ratio! + int allpasstemp; + int count; + int max = 70; //biggest divisor to test primes against + Float64 bridgerectifier; + Float64 gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive + //used as an aux, saturates when fed high levels + + //remap values to primes input number in question is 'i' + //max is the largest prime we care about- HF interactions more interesting than the big numbers + //pushing values larger and larger until we have a result + //for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}} + + if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpA; count < 15149; count++) {aA[count] = 0.0;} + for(count = outA; count < 15149; count++) {oA[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpB; count < 14617; count++) {aB[count] = 0.0;} + for(count = outB; count < 14617; count++) {oB[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpC; count < 14357; count++) {aC[count] = 0.0;} + for(count = outC; count < 14357; count++) {oC[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpD; count < 13817; count++) {aD[count] = 0.0;} + for(count = outD; count < 13817; count++) {oD[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpE; count < 13561; count++) {aE[count] = 0.0;} + for(count = outE; count < 13561; count++) {oE[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpF; count < 13045; count++) {aF[count] = 0.0;} + for(count = outF; count < 13045; count++) {oF[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpG; count < 11965; count++) {aG[count] = 0.0;} + for(count = outG; count < 11965; count++) {oG[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpH; count < 11129; count++) {aH[count] = 0.0;} + for(count = outH; count < 11129; count++) {oH[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpI; count < 10597; count++) {aI[count] = 0.0;} + for(count = outI; count < 10597; count++) {oI[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJ; count < 9809; count++) {aJ[count] = 0.0;} + for(count = outJ; count < 9809; count++) {oJ[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpK; count < 9521; count++) {aK[count] = 0.0;} + for(count = outK; count < 9521; count++) {oK[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpL; count < 8981; count++) {aL[count] = 0.0;} + for(count = outL; count < 8981; count++) {oL[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpM; count < 8785; count++) {aM[count] = 0.0;} + for(count = outM; count < 8785; count++) {oM[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpN; count < 8461; count++) {aN[count] = 0.0;} + for(count = outN; count < 8461; count++) {oN[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpO; count < 8309; count++) {aO[count] = 0.0;} + for(count = outO; count < 8309; count++) {oO[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpP; count < 7981; count++) {aP[count] = 0.0;} + for(count = outP; count < 7981; count++) {oP[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQ; count < 7321; count++) {aQ[count] = 0.0;} + for(count = outQ; count < 7321; count++) {oQ[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpR; count < 6817; count++) {aR[count] = 0.0;} + for(count = outR; count < 6817; count++) {oR[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpS; count < 6505; count++) {aS[count] = 0.0;} + for(count = outS; count < 6505; count++) {oS[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpT; count < 6001; count++) {aT[count] = 0.0;} + for(count = outT; count < 6001; count++) {oT[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpU; count < 5837; count++) {aU[count] = 0.0;} + for(count = outU; count < 5837; count++) {oU[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpV; count < 5501; count++) {aV[count] = 0.0;} + for(count = outV; count < 5501; count++) {oV[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpW; count < 5009; count++) {aW[count] = 0.0;} + for(count = outW; count < 5009; count++) {oW[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpX; count < 4849; count++) {aX[count] = 0.0;} + for(count = outX; count < 4849; count++) {oX[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpY; count < 4295; count++) {aY[count] = 0.0;} + for(count = outY; count < 4295; count++) {oY[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZ; count < 4179; count++) {aZ[count] = 0.0;} + for(count = outZ; count < 4179; count++) {oZ[count] = 0.0;} + break; + } //end of switch statement + countdown--; + } + + + while (nSampleFrames-- > 0) { + long double inputSample = *sourceP; + if (fabs(inputSample)<1.18e-37) inputSample = fpd * 1.18e-37; + long double drySample = inputSample; + + peak -= release; + if (peak < fabs(inputSample*2.0)) peak = fabs(inputSample*2.0); + if (peak > 1.0) peak = 1.0; + //chase the maximum signal to incorporate the wetter/louder behavior + //boost for more extreme effect when in use, cap it + + inputSample *= gain; + bridgerectifier = fabs(inputSample); + bridgerectifier = sin(bridgerectifier); + if (inputSample > 0) inputSample = bridgerectifier; + else inputSample = -bridgerectifier; + //here we apply the ADT2 console-on-steroids trick + + switch (verbtype) + { + + +case 1://Chamber + allpasstemp = alpA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= aA[allpasstemp]*constallpass; + aA[alpA] = inputSample; + inputSample *= constallpass; + alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;} + inputSample += (aA[alpA]); + //allpass filter A + + dA[3] = dA[2]; + dA[2] = dA[1]; + dA[1] = inputSample; + inputSample = (dA[1] + dA[2] + dA[3])/3.0; + + allpasstemp = alpB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= aB[allpasstemp]*constallpass; + aB[alpB] = inputSample; + inputSample *= constallpass; + alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;} + inputSample += (aB[alpB]); + //allpass filter B + + dB[3] = dB[2]; + dB[2] = dB[1]; + dB[1] = inputSample; + inputSample = (dB[1] + dB[2] + dB[3])/3.0; + + allpasstemp = alpC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= aC[allpasstemp]*constallpass; + aC[alpC] = inputSample; + inputSample *= constallpass; + alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;} + inputSample += (aC[alpC]); + //allpass filter C + + dC[3] = dC[2]; + dC[2] = dC[1]; + dC[1] = inputSample; + inputSample = (dA[1] + dC[2] + dC[3])/3.0; + + allpasstemp = alpD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= aD[allpasstemp]*constallpass; + aD[alpD] = inputSample; + inputSample *= constallpass; + alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;} + inputSample += (aD[alpD]); + //allpass filter D + + dD[3] = dD[2]; + dD[2] = dD[1]; + dD[1] = inputSample; + inputSample = (dD[1] + dD[2] + dD[3])/3.0; + + allpasstemp = alpE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= aE[allpasstemp]*constallpass; + aE[alpE] = inputSample; + inputSample *= constallpass; + alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;} + inputSample += (aE[alpE]); + //allpass filter E + + dE[3] = dE[2]; + dE[2] = dE[1]; + dE[1] = inputSample; + inputSample = (dA[1] + dE[2] + dE[3])/3.0; + + allpasstemp = alpF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= aF[allpasstemp]*constallpass; + aF[alpF] = inputSample; + inputSample *= constallpass; + alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;} + inputSample += (aF[alpF]); + //allpass filter F + + dF[3] = dF[2]; + dF[2] = dF[1]; + dF[1] = inputSample; + inputSample = (dF[1] + dF[2] + dF[3])/3.0; + + allpasstemp = alpG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= aG[allpasstemp]*constallpass; + aG[alpG] = inputSample; + inputSample *= constallpass; + alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;} + inputSample += (aG[alpG]); + //allpass filter G + + dG[3] = dG[2]; + dG[2] = dG[1]; + dG[1] = inputSample; + inputSample = (dA[1] + dG[2] + dG[3])/3.0; + + allpasstemp = alpH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= aH[allpasstemp]*constallpass; + aH[alpH] = inputSample; + inputSample *= constallpass; + alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;} + inputSample += (aH[alpH]); + //allpass filter H + + dH[3] = dH[2]; + dH[2] = dH[1]; + dH[1] = inputSample; + inputSample = (dH[1] + dH[2] + dH[3])/3.0; + + allpasstemp = alpI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= aI[allpasstemp]*constallpass; + aI[alpI] = inputSample; + inputSample *= constallpass; + alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;} + inputSample += (aI[alpI]); + //allpass filter I + + dI[3] = dI[2]; + dI[2] = dI[1]; + dI[1] = inputSample; + inputSample = (dI[1] + dI[2] + dI[3])/3.0; + + allpasstemp = alpJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= aJ[allpasstemp]*constallpass; + aJ[alpJ] = inputSample; + inputSample *= constallpass; + alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;} + inputSample += (aJ[alpJ]); + //allpass filter J + + dJ[3] = dJ[2]; + dJ[2] = dJ[1]; + dJ[1] = inputSample; + inputSample = (dJ[1] + dJ[2] + dJ[3])/3.0; + + allpasstemp = alpK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= aK[allpasstemp]*constallpass; + aK[alpK] = inputSample; + inputSample *= constallpass; + alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;} + inputSample += (aK[alpK]); + //allpass filter K + + dK[3] = dK[2]; + dK[2] = dK[1]; + dK[1] = inputSample; + inputSample = (dA[1] + dK[2] + dK[3])/3.0; + + allpasstemp = alpL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= aL[allpasstemp]*constallpass; + aL[alpL] = inputSample; + inputSample *= constallpass; + alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;} + inputSample += (aL[alpL]); + //allpass filter L + + dL[3] = dL[2]; + dL[2] = dL[1]; + dL[1] = inputSample; + inputSample = (dL[1] + dL[2] + dL[3])/3.0; + + allpasstemp = alpM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= aM[allpasstemp]*constallpass; + aM[alpM] = inputSample; + inputSample *= constallpass; + alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;} + inputSample += (aM[alpM]); + //allpass filter M + + dM[3] = dM[2]; + dM[2] = dM[1]; + dM[1] = inputSample; + inputSample = (dA[1] + dM[2] + dM[3])/3.0; + + allpasstemp = alpN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= aN[allpasstemp]*constallpass; + aN[alpN] = inputSample; + inputSample *= constallpass; + alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;} + inputSample += (aN[alpN]); + //allpass filter N + + dN[3] = dN[2]; + dN[2] = dN[1]; + dN[1] = inputSample; + inputSample = (dN[1] + dN[2] + dN[3])/3.0; + + allpasstemp = alpO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= aO[allpasstemp]*constallpass; + aO[alpO] = inputSample; + inputSample *= constallpass; + alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;} + inputSample += (aO[alpO]); + //allpass filter O + + dO[3] = dO[2]; + dO[2] = dO[1]; + dO[1] = inputSample; + inputSample = (dO[1] + dO[2] + dO[3])/3.0; + + allpasstemp = alpP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= aP[allpasstemp]*constallpass; + aP[alpP] = inputSample; + inputSample *= constallpass; + alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;} + inputSample += (aP[alpP]); + //allpass filter P + + dP[3] = dP[2]; + dP[2] = dP[1]; + dP[1] = inputSample; + inputSample = (dP[1] + dP[2] + dP[3])/3.0; + + allpasstemp = alpQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= aQ[allpasstemp]*constallpass; + aQ[alpQ] = inputSample; + inputSample *= constallpass; + alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;} + inputSample += (aQ[alpQ]); + //allpass filter Q + + dQ[3] = dQ[2]; + dQ[2] = dQ[1]; + dQ[1] = inputSample; + inputSample = (dA[1] + dQ[2] + dQ[3])/3.0; + + allpasstemp = alpR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= aR[allpasstemp]*constallpass; + aR[alpR] = inputSample; + inputSample *= constallpass; + alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;} + inputSample += (aR[alpR]); + //allpass filter R + + dR[3] = dR[2]; + dR[2] = dR[1]; + dR[1] = inputSample; + inputSample = (dR[1] + dR[2] + dR[3])/3.0; + + allpasstemp = alpS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= aS[allpasstemp]*constallpass; + aS[alpS] = inputSample; + inputSample *= constallpass; + alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;} + inputSample += (aS[alpS]); + //allpass filter S + + dS[3] = dS[2]; + dS[2] = dS[1]; + dS[1] = inputSample; + inputSample = (dA[1] + dS[2] + dS[3])/3.0; + + allpasstemp = alpT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= aT[allpasstemp]*constallpass; + aT[alpT] = inputSample; + inputSample *= constallpass; + alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;} + inputSample += (aT[alpT]); + //allpass filter T + + dT[3] = dT[2]; + dT[2] = dT[1]; + dT[1] = inputSample; + inputSample = (dT[1] + dT[2] + dT[3])/3.0; + + allpasstemp = alpU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= aU[allpasstemp]*constallpass; + aU[alpU] = inputSample; + inputSample *= constallpass; + alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;} + inputSample += (aU[alpU]); + //allpass filter U + + dU[3] = dU[2]; + dU[2] = dU[1]; + dU[1] = inputSample; + inputSample = (dU[1] + dU[2] + dU[3])/3.0; + + allpasstemp = alpV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= aV[allpasstemp]*constallpass; + aV[alpV] = inputSample; + inputSample *= constallpass; + alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;} + inputSample += (aV[alpV]); + //allpass filter V + + dV[3] = dV[2]; + dV[2] = dV[1]; + dV[1] = inputSample; + inputSample = (dV[1] + dV[2] + dV[3])/3.0; + + allpasstemp = alpW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= aW[allpasstemp]*constallpass; + aW[alpW] = inputSample; + inputSample *= constallpass; + alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;} + inputSample += (aW[alpW]); + //allpass filter W + + dW[3] = dW[2]; + dW[2] = dW[1]; + dW[1] = inputSample; + inputSample = (dA[1] + dW[2] + dW[3])/3.0; + + allpasstemp = alpX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= aX[allpasstemp]*constallpass; + aX[alpX] = inputSample; + inputSample *= constallpass; + alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;} + inputSample += (aX[alpX]); + //allpass filter X + + dX[3] = dX[2]; + dX[2] = dX[1]; + dX[1] = inputSample; + inputSample = (dX[1] + dX[2] + dX[3])/3.0; + + allpasstemp = alpY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= aY[allpasstemp]*constallpass; + aY[alpY] = inputSample; + inputSample *= constallpass; + alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;} + inputSample += (aY[alpY]); + //allpass filter Y + + dY[3] = dY[2]; + dY[2] = dY[1]; + dY[1] = inputSample; + inputSample = (dY[1] + dY[2] + dY[3])/3.0; + + allpasstemp = alpZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= aZ[allpasstemp]*constallpass; + aZ[alpZ] = inputSample; + inputSample *= constallpass; + alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;} + inputSample += (aZ[alpZ]); + //allpass filter Z + + dZ[3] = dZ[2]; + dZ[2] = dZ[1]; + dZ[1] = inputSample; + inputSample = (dZ[1] + dZ[2] + dZ[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= oA[allpasstemp]*constallpass; + oA[outA] = inputSample; + inputSample *= constallpass; + outA--; if (outA < 0 || outA > delayA) {outA = delayA;} + inputSample += (oA[outA]); + //allpass filter A + + dA[6] = dA[5]; + dA[5] = dA[4]; + dA[4] = inputSample; + inputSample = (dA[4] + dA[5] + dA[6])/3.0; + + allpasstemp = outB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= oB[allpasstemp]*constallpass; + oB[outB] = inputSample; + inputSample *= constallpass; + outB--; if (outB < 0 || outB > delayB) {outB = delayB;} + inputSample += (oB[outB]); + //allpass filter B + + dB[6] = dB[5]; + dB[5] = dB[4]; + dB[4] = inputSample; + inputSample = (dB[4] + dB[5] + dB[6])/3.0; + + allpasstemp = outC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= oC[allpasstemp]*constallpass; + oC[outC] = inputSample; + inputSample *= constallpass; + outC--; if (outC < 0 || outC > delayC) {outC = delayC;} + inputSample += (oC[outC]); + //allpass filter C + + dC[6] = dC[5]; + dC[5] = dC[4]; + dC[4] = inputSample; + inputSample = (dA[1] + dC[5] + dC[6])/3.0; + + allpasstemp = outD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= oD[allpasstemp]*constallpass; + oD[outD] = inputSample; + inputSample *= constallpass; + outD--; if (outD < 0 || outD > delayD) {outD = delayD;} + inputSample += (oD[outD]); + //allpass filter D + + dD[6] = dD[5]; + dD[5] = dD[4]; + dD[4] = inputSample; + inputSample = (dD[4] + dD[5] + dD[6])/3.0; + + allpasstemp = outE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= oE[allpasstemp]*constallpass; + oE[outE] = inputSample; + inputSample *= constallpass; + outE--; if (outE < 0 || outE > delayE) {outE = delayE;} + inputSample += (oE[outE]); + //allpass filter E + + dE[6] = dE[5]; + dE[5] = dE[4]; + dE[4] = inputSample; + inputSample = (dA[1] + dE[5] + dE[6])/3.0; + + allpasstemp = outF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= oF[allpasstemp]*constallpass; + oF[outF] = inputSample; + inputSample *= constallpass; + outF--; if (outF < 0 || outF > delayF) {outF = delayF;} + inputSample += (oF[outF]); + //allpass filter F + + dF[6] = dF[5]; + dF[5] = dF[4]; + dF[4] = inputSample; + inputSample = (dF[4] + dF[5] + dF[6])/3.0; + + allpasstemp = outG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= oG[allpasstemp]*constallpass; + oG[outG] = inputSample; + inputSample *= constallpass; + outG--; if (outG < 0 || outG > delayG) {outG = delayG;} + inputSample += (oG[outG]); + //allpass filter G + + dG[6] = dG[5]; + dG[5] = dG[4]; + dG[4] = inputSample; + inputSample = (dG[4] + dG[5] + dG[6])/3.0; + + allpasstemp = outH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= oH[allpasstemp]*constallpass; + oH[outH] = inputSample; + inputSample *= constallpass; + outH--; if (outH < 0 || outH > delayH) {outH = delayH;} + inputSample += (oH[outH]); + //allpass filter H + + dH[6] = dH[5]; + dH[5] = dH[4]; + dH[4] = inputSample; + inputSample = (dH[4] + dH[5] + dH[6])/3.0; + + allpasstemp = outI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= oI[allpasstemp]*constallpass; + oI[outI] = inputSample; + inputSample *= constallpass; + outI--; if (outI < 0 || outI > delayI) {outI = delayI;} + inputSample += (oI[outI]); + //allpass filter I + + dI[6] = dI[5]; + dI[5] = dI[4]; + dI[4] = inputSample; + inputSample = (dI[4] + dI[5] + dI[6])/3.0; + + allpasstemp = outJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= oJ[allpasstemp]*constallpass; + oJ[outJ] = inputSample; + inputSample *= constallpass; + outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;} + inputSample += (oJ[outJ]); + //allpass filter J + + dJ[6] = dJ[5]; + dJ[5] = dJ[4]; + dJ[4] = inputSample; + inputSample = (dJ[4] + dJ[5] + dJ[6])/3.0; + + allpasstemp = outK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= oK[allpasstemp]*constallpass; + oK[outK] = inputSample; + inputSample *= constallpass; + outK--; if (outK < 0 || outK > delayK) {outK = delayK;} + inputSample += (oK[outK]); + //allpass filter K + + dK[6] = dK[5]; + dK[5] = dK[4]; + dK[4] = inputSample; + inputSample = (dA[1] + dK[5] + dK[6])/3.0; + + allpasstemp = outL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= oL[allpasstemp]*constallpass; + oL[outL] = inputSample; + inputSample *= constallpass; + outL--; if (outL < 0 || outL > delayL) {outL = delayL;} + inputSample += (oL[outL]); + //allpass filter L + + dL[6] = dL[5]; + dL[5] = dL[4]; + dL[4] = inputSample; + inputSample = (dL[4] + dL[5] + dL[6])/3.0; + + allpasstemp = outM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= oM[allpasstemp]*constallpass; + oM[outM] = inputSample; + inputSample *= constallpass; + outM--; if (outM < 0 || outM > delayM) {outM = delayM;} + inputSample += (oM[outM]); + //allpass filter M + + dM[6] = dM[5]; + dM[5] = dM[4]; + dM[4] = inputSample; + inputSample = (dM[4] + dM[5] + dM[6])/3.0; + + allpasstemp = outN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= oN[allpasstemp]*constallpass; + oN[outN] = inputSample; + inputSample *= constallpass; + outN--; if (outN < 0 || outN > delayN) {outN = delayN;} + inputSample += (oN[outN]); + //allpass filter N + + dN[6] = dN[5]; + dN[5] = dN[4]; + dN[4] = inputSample; + inputSample = (dN[4] + dN[5] + dN[6])/3.0; + + allpasstemp = outO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= oO[allpasstemp]*constallpass; + oO[outO] = inputSample; + inputSample *= constallpass; + outO--; if (outO < 0 || outO > delayO) {outO = delayO;} + inputSample += (oO[outO]); + //allpass filter O + + dO[6] = dO[5]; + dO[5] = dO[4]; + dO[4] = inputSample; + inputSample = (dA[1] + dO[5] + dO[6])/3.0; + + allpasstemp = outP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= oP[allpasstemp]*constallpass; + oP[outP] = inputSample; + inputSample *= constallpass; + outP--; if (outP < 0 || outP > delayP) {outP = delayP;} + inputSample += (oP[outP]); + //allpass filter P + + dP[6] = dP[5]; + dP[5] = dP[4]; + dP[4] = inputSample; + inputSample = (dP[4] + dP[5] + dP[6])/3.0; + + allpasstemp = outQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= oQ[allpasstemp]*constallpass; + oQ[outQ] = inputSample; + inputSample *= constallpass; + outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;} + inputSample += (oQ[outQ]); + //allpass filter Q + + dQ[6] = dQ[5]; + dQ[5] = dQ[4]; + dQ[4] = inputSample; + inputSample = (dA[1] + dQ[5] + dQ[6])/3.0; + + allpasstemp = outR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= oR[allpasstemp]*constallpass; + oR[outR] = inputSample; + inputSample *= constallpass; + outR--; if (outR < 0 || outR > delayR) {outR = delayR;} + inputSample += (oR[outR]); + //allpass filter R + + dR[6] = dR[5]; + dR[5] = dR[4]; + dR[4] = inputSample; + inputSample = (dR[4] + dR[5] + dR[6])/3.0; + + allpasstemp = outS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= oS[allpasstemp]*constallpass; + oS[outS] = inputSample; + inputSample *= constallpass; + outS--; if (outS < 0 || outS > delayS) {outS = delayS;} + inputSample += (oS[outS]); + //allpass filter S + + dS[6] = dS[5]; + dS[5] = dS[4]; + dS[4] = inputSample; + inputSample = (dS[4] + dS[5] + dS[6])/3.0; + + allpasstemp = outT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= oT[allpasstemp]*constallpass; + oT[outT] = inputSample; + inputSample *= constallpass; + outT--; if (outT < 0 || outT > delayT) {outT = delayT;} + inputSample += (oT[outT]); + //allpass filter T + + dT[6] = dT[5]; + dT[5] = dT[4]; + dT[4] = inputSample; + inputSample = (dT[4] + dT[5] + dT[6])/3.0; + + allpasstemp = outU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= oU[allpasstemp]*constallpass; + oU[outU] = inputSample; + inputSample *= constallpass; + outU--; if (outU < 0 || outU > delayU) {outU = delayU;} + inputSample += (oU[outU]); + //allpass filter U + + dU[6] = dU[5]; + dU[5] = dU[4]; + dU[4] = inputSample; + inputSample = (dA[1] + dU[5] + dU[6])/3.0; + + allpasstemp = outV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= oV[allpasstemp]*constallpass; + oV[outV] = inputSample; + inputSample *= constallpass; + outV--; if (outV < 0 || outV > delayV) {outV = delayV;} + inputSample += (oV[outV]); + //allpass filter V + + dV[6] = dV[5]; + dV[5] = dV[4]; + dV[4] = inputSample; + inputSample = (dV[4] + dV[5] + dV[6])/3.0; + + allpasstemp = outW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= oW[allpasstemp]*constallpass; + oW[outW] = inputSample; + inputSample *= constallpass; + outW--; if (outW < 0 || outW > delayW) {outW = delayW;} + inputSample += (oW[outW]); + //allpass filter W + + dW[6] = dW[5]; + dW[5] = dW[4]; + dW[4] = inputSample; + inputSample = (dW[4] + dW[5] + dW[6])/3.0; + + allpasstemp = outX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= oX[allpasstemp]*constallpass; + oX[outX] = inputSample; + inputSample *= constallpass; + outX--; if (outX < 0 || outX > delayX) {outX = delayX;} + inputSample += (oX[outX]); + //allpass filter X + + dX[6] = dX[5]; + dX[5] = dX[4]; + dX[4] = inputSample; + inputSample = (dX[4] + dX[5] + dX[6])/3.0; + + allpasstemp = outY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= oY[allpasstemp]*constallpass; + oY[outY] = inputSample; + inputSample *= constallpass; + outY--; if (outY < 0 || outY > delayY) {outY = delayY;} + inputSample += (oY[outY]); + //allpass filter Y + + dY[6] = dY[5]; + dY[5] = dY[4]; + dY[4] = inputSample; + inputSample = (dY[4] + dY[5] + dY[6])/3.0; + + allpasstemp = outZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= oZ[allpasstemp]*constallpass; + oZ[outZ] = inputSample; + inputSample *= constallpass; + outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;} + inputSample += (oZ[outZ]); + //allpass filter Z + + dZ[6] = dZ[5]; + dZ[5] = dZ[4]; + dZ[4] = inputSample; + inputSample = (dZ[4] + dZ[5] + dZ[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= aA[allpasstemp]*constallpass; + aA[alpA] = inputSample; + inputSample *= constallpass; + alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;} + inputSample += (aA[alpA]); + //allpass filter A + + dA[3] = dA[2]; + dA[2] = dA[1]; + dA[1] = inputSample; + inputSample = (dA[1] + dA[2] + dA[3])/3.0; + + allpasstemp = alpB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= aB[allpasstemp]*constallpass; + aB[alpB] = inputSample; + inputSample *= constallpass; + alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;} + inputSample += (aB[alpB]); + //allpass filter B + + dB[3] = dB[2]; + dB[2] = dB[1]; + dB[1] = inputSample; + inputSample = (dB[1] + dB[2] + dB[3])/3.0; + + allpasstemp = alpC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= aC[allpasstemp]*constallpass; + aC[alpC] = inputSample; + inputSample *= constallpass; + alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;} + inputSample += (aC[alpC]); + //allpass filter C + + dC[3] = dC[2]; + dC[2] = dC[1]; + dC[1] = inputSample; + inputSample = (dC[1] + dC[2] + dC[3])/3.0; + + allpasstemp = alpD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= aD[allpasstemp]*constallpass; + aD[alpD] = inputSample; + inputSample *= constallpass; + alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;} + inputSample += (aD[alpD]); + //allpass filter D + + dD[3] = dD[2]; + dD[2] = dD[1]; + dD[1] = inputSample; + inputSample = (dD[1] + dD[2] + dD[3])/3.0; + + allpasstemp = alpE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= aE[allpasstemp]*constallpass; + aE[alpE] = inputSample; + inputSample *= constallpass; + alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;} + inputSample += (aE[alpE]); + //allpass filter E + + dE[3] = dE[2]; + dE[2] = dE[1]; + dE[1] = inputSample; + inputSample = (dE[1] + dE[2] + dE[3])/3.0; + + allpasstemp = alpF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= aF[allpasstemp]*constallpass; + aF[alpF] = inputSample; + inputSample *= constallpass; + alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;} + inputSample += (aF[alpF]); + //allpass filter F + + dF[3] = dF[2]; + dF[2] = dF[1]; + dF[1] = inputSample; + inputSample = (dF[1] + dF[2] + dF[3])/3.0; + + allpasstemp = alpG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= aG[allpasstemp]*constallpass; + aG[alpG] = inputSample; + inputSample *= constallpass; + alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;} + inputSample += (aG[alpG]); + //allpass filter G + + dG[3] = dG[2]; + dG[2] = dG[1]; + dG[1] = inputSample; + inputSample = (dG[1] + dG[2] + dG[3])/3.0; + + allpasstemp = alpH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= aH[allpasstemp]*constallpass; + aH[alpH] = inputSample; + inputSample *= constallpass; + alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;} + inputSample += (aH[alpH]); + //allpass filter H + + dH[3] = dH[2]; + dH[2] = dH[1]; + dH[1] = inputSample; + inputSample = (dH[1] + dH[2] + dH[3])/3.0; + + allpasstemp = alpI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= aI[allpasstemp]*constallpass; + aI[alpI] = inputSample; + inputSample *= constallpass; + alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;} + inputSample += (aI[alpI]); + //allpass filter I + + dI[3] = dI[2]; + dI[2] = dI[1]; + dI[1] = inputSample; + inputSample = (dI[1] + dI[2] + dI[3])/3.0; + + allpasstemp = alpJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= aJ[allpasstemp]*constallpass; + aJ[alpJ] = inputSample; + inputSample *= constallpass; + alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;} + inputSample += (aJ[alpJ]); + //allpass filter J + + dJ[3] = dJ[2]; + dJ[2] = dJ[1]; + dJ[1] = inputSample; + inputSample = (dJ[1] + dJ[2] + dJ[3])/3.0; + + allpasstemp = alpK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= aK[allpasstemp]*constallpass; + aK[alpK] = inputSample; + inputSample *= constallpass; + alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;} + inputSample += (aK[alpK]); + //allpass filter K + + dK[3] = dK[2]; + dK[2] = dK[1]; + dK[1] = inputSample; + inputSample = (dK[1] + dK[2] + dK[3])/3.0; + + allpasstemp = alpL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= aL[allpasstemp]*constallpass; + aL[alpL] = inputSample; + inputSample *= constallpass; + alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;} + inputSample += (aL[alpL]); + //allpass filter L + + dL[3] = dL[2]; + dL[2] = dL[1]; + dL[1] = inputSample; + inputSample = (dL[1] + dL[2] + dL[3])/3.0; + + allpasstemp = alpM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= aM[allpasstemp]*constallpass; + aM[alpM] = inputSample; + inputSample *= constallpass; + alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;} + inputSample += (aM[alpM]); + //allpass filter M + + dM[3] = dM[2]; + dM[2] = dM[1]; + dM[1] = inputSample; + inputSample = (dM[1] + dM[2] + dM[3])/3.0; + + allpasstemp = alpN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= aN[allpasstemp]*constallpass; + aN[alpN] = inputSample; + inputSample *= constallpass; + alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;} + inputSample += (aN[alpN]); + //allpass filter N + + dN[3] = dN[2]; + dN[2] = dN[1]; + dN[1] = inputSample; + inputSample = (dN[1] + dN[2] + dN[3])/3.0; + + allpasstemp = alpO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= aO[allpasstemp]*constallpass; + aO[alpO] = inputSample; + inputSample *= constallpass; + alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;} + inputSample += (aO[alpO]); + //allpass filter O + + dO[3] = dO[2]; + dO[2] = dO[1]; + dO[1] = inputSample; + inputSample = (dO[1] + dO[2] + dO[3])/3.0; + + allpasstemp = alpP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= aP[allpasstemp]*constallpass; + aP[alpP] = inputSample; + inputSample *= constallpass; + alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;} + inputSample += (aP[alpP]); + //allpass filter P + + dP[3] = dP[2]; + dP[2] = dP[1]; + dP[1] = inputSample; + inputSample = (dP[1] + dP[2] + dP[3])/3.0; + + allpasstemp = alpQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= aQ[allpasstemp]*constallpass; + aQ[alpQ] = inputSample; + inputSample *= constallpass; + alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;} + inputSample += (aQ[alpQ]); + //allpass filter Q + + dQ[3] = dQ[2]; + dQ[2] = dQ[1]; + dQ[1] = inputSample; + inputSample = (dQ[1] + dQ[2] + dQ[3])/3.0; + + allpasstemp = alpR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= aR[allpasstemp]*constallpass; + aR[alpR] = inputSample; + inputSample *= constallpass; + alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;} + inputSample += (aR[alpR]); + //allpass filter R + + dR[3] = dR[2]; + dR[2] = dR[1]; + dR[1] = inputSample; + inputSample = (dR[1] + dR[2] + dR[3])/3.0; + + allpasstemp = alpS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= aS[allpasstemp]*constallpass; + aS[alpS] = inputSample; + inputSample *= constallpass; + alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;} + inputSample += (aS[alpS]); + //allpass filter S + + dS[3] = dS[2]; + dS[2] = dS[1]; + dS[1] = inputSample; + inputSample = (dS[1] + dS[2] + dS[3])/3.0; + + allpasstemp = alpT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= aT[allpasstemp]*constallpass; + aT[alpT] = inputSample; + inputSample *= constallpass; + alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;} + inputSample += (aT[alpT]); + //allpass filter T + + dT[3] = dT[2]; + dT[2] = dT[1]; + dT[1] = inputSample; + inputSample = (dT[1] + dT[2] + dT[3])/3.0; + + allpasstemp = alpU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= aU[allpasstemp]*constallpass; + aU[alpU] = inputSample; + inputSample *= constallpass; + alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;} + inputSample += (aU[alpU]); + //allpass filter U + + dU[3] = dU[2]; + dU[2] = dU[1]; + dU[1] = inputSample; + inputSample = (dU[1] + dU[2] + dU[3])/3.0; + + allpasstemp = alpV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= aV[allpasstemp]*constallpass; + aV[alpV] = inputSample; + inputSample *= constallpass; + alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;} + inputSample += (aV[alpV]); + //allpass filter V + + dV[3] = dV[2]; + dV[2] = dV[1]; + dV[1] = inputSample; + inputSample = (dV[1] + dV[2] + dV[3])/3.0; + + allpasstemp = alpW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= aW[allpasstemp]*constallpass; + aW[alpW] = inputSample; + inputSample *= constallpass; + alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;} + inputSample += (aW[alpW]); + //allpass filter W + + dW[3] = dW[2]; + dW[2] = dW[1]; + dW[1] = inputSample; + inputSample = (dW[1] + dW[2] + dW[3])/3.0; + + allpasstemp = alpX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= aX[allpasstemp]*constallpass; + aX[alpX] = inputSample; + inputSample *= constallpass; + alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;} + inputSample += (aX[alpX]); + //allpass filter X + + dX[3] = dX[2]; + dX[2] = dX[1]; + dX[1] = inputSample; + inputSample = (dX[1] + dX[2] + dX[3])/3.0; + + allpasstemp = alpY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= aY[allpasstemp]*constallpass; + aY[alpY] = inputSample; + inputSample *= constallpass; + alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;} + inputSample += (aY[alpY]); + //allpass filter Y + + dY[3] = dY[2]; + dY[2] = dY[1]; + dY[1] = inputSample; + inputSample = (dY[1] + dY[2] + dY[3])/3.0; + + allpasstemp = alpZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= aZ[allpasstemp]*constallpass; + aZ[alpZ] = inputSample; + inputSample *= constallpass; + alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;} + inputSample += (aZ[alpZ]); + //allpass filter Z + + dZ[3] = dZ[2]; + dZ[2] = dZ[1]; + dZ[1] = inputSample; + inputSample = (dZ[1] + dZ[2] + dZ[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= oA[allpasstemp]*constallpass; + oA[outA] = inputSample; + inputSample *= constallpass; + outA--; if (outA < 0 || outA > delayA) {outA = delayA;} + inputSample += (oA[outA]); + //allpass filter A + + dA[6] = dA[5]; + dA[5] = dA[4]; + dA[4] = inputSample; + inputSample = (dY[1] + dA[5] + dA[6])/3.0; + + allpasstemp = outB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= oB[allpasstemp]*constallpass; + oB[outB] = inputSample; + inputSample *= constallpass; + outB--; if (outB < 0 || outB > delayB) {outB = delayB;} + inputSample += (oB[outB]); + //allpass filter B + + dB[6] = dB[5]; + dB[5] = dB[4]; + dB[4] = inputSample; + inputSample = (dX[1] + dB[5] + dB[6])/3.0; + + allpasstemp = outC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= oC[allpasstemp]*constallpass; + oC[outC] = inputSample; + inputSample *= constallpass; + outC--; if (outC < 0 || outC > delayC) {outC = delayC;} + inputSample += (oC[outC]); + //allpass filter C + + dC[6] = dC[5]; + dC[5] = dC[4]; + dC[4] = inputSample; + inputSample = (dW[1] + dC[5] + dC[6])/3.0; + + allpasstemp = outD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= oD[allpasstemp]*constallpass; + oD[outD] = inputSample; + inputSample *= constallpass; + outD--; if (outD < 0 || outD > delayD) {outD = delayD;} + inputSample += (oD[outD]); + //allpass filter D + + dD[6] = dD[5]; + dD[5] = dD[4]; + dD[4] = inputSample; + inputSample = (dV[1] + dD[5] + dD[6])/3.0; + + allpasstemp = outE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= oE[allpasstemp]*constallpass; + oE[outE] = inputSample; + inputSample *= constallpass; + outE--; if (outE < 0 || outE > delayE) {outE = delayE;} + inputSample += (oE[outE]); + //allpass filter E + + dE[6] = dE[5]; + dE[5] = dE[4]; + dE[4] = inputSample; + inputSample = (dU[1] + dE[5] + dE[6])/3.0; + + allpasstemp = outF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= oF[allpasstemp]*constallpass; + oF[outF] = inputSample; + inputSample *= constallpass; + outF--; if (outF < 0 || outF > delayF) {outF = delayF;} + inputSample += (oF[outF]); + //allpass filter F + + dF[6] = dF[5]; + dF[5] = dF[4]; + dF[4] = inputSample; + inputSample = (dT[1] + dF[5] + dF[6])/3.0; + + allpasstemp = outG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= oG[allpasstemp]*constallpass; + oG[outG] = inputSample; + inputSample *= constallpass; + outG--; if (outG < 0 || outG > delayG) {outG = delayG;} + inputSample += (oG[outG]); + //allpass filter G + + dG[6] = dG[5]; + dG[5] = dG[4]; + dG[4] = inputSample; + inputSample = (dS[1] + dG[5] + dG[6])/3.0; + + allpasstemp = outH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= oH[allpasstemp]*constallpass; + oH[outH] = inputSample; + inputSample *= constallpass; + outH--; if (outH < 0 || outH > delayH) {outH = delayH;} + inputSample += (oH[outH]); + //allpass filter H + + dH[6] = dH[5]; + dH[5] = dH[4]; + dH[4] = inputSample; + inputSample = (dR[1] + dH[5] + dH[6])/3.0; + + allpasstemp = outI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= oI[allpasstemp]*constallpass; + oI[outI] = inputSample; + inputSample *= constallpass; + outI--; if (outI < 0 || outI > delayI) {outI = delayI;} + inputSample += (oI[outI]); + //allpass filter I + + dI[6] = dI[5]; + dI[5] = dI[4]; + dI[4] = inputSample; + inputSample = (dQ[1] + dI[5] + dI[6])/3.0; + + allpasstemp = outJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= oJ[allpasstemp]*constallpass; + oJ[outJ] = inputSample; + inputSample *= constallpass; + outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;} + inputSample += (oJ[outJ]); + //allpass filter J + + dJ[6] = dJ[5]; + dJ[5] = dJ[4]; + dJ[4] = inputSample; + inputSample = (dP[1] + dJ[5] + dJ[6])/3.0; + + allpasstemp = outK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= oK[allpasstemp]*constallpass; + oK[outK] = inputSample; + inputSample *= constallpass; + outK--; if (outK < 0 || outK > delayK) {outK = delayK;} + inputSample += (oK[outK]); + //allpass filter K + + dK[6] = dK[5]; + dK[5] = dK[4]; + dK[4] = inputSample; + inputSample = (dO[1] + dK[5] + dK[6])/3.0; + + allpasstemp = outL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= oL[allpasstemp]*constallpass; + oL[outL] = inputSample; + inputSample *= constallpass; + outL--; if (outL < 0 || outL > delayL) {outL = delayL;} + inputSample += (oL[outL]); + //allpass filter L + + dL[6] = dL[5]; + dL[5] = dL[4]; + dL[4] = inputSample; + inputSample = (dN[1] + dL[5] + dL[6])/3.0; + + allpasstemp = outM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= oM[allpasstemp]*constallpass; + oM[outM] = inputSample; + inputSample *= constallpass; + outM--; if (outM < 0 || outM > delayM) {outM = delayM;} + inputSample += (oM[outM]); + //allpass filter M + + dM[6] = dM[5]; + dM[5] = dM[4]; + dM[4] = inputSample; + inputSample = (dM[1] + dM[5] + dM[6])/3.0; + + allpasstemp = outN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= oN[allpasstemp]*constallpass; + oN[outN] = inputSample; + inputSample *= constallpass; + outN--; if (outN < 0 || outN > delayN) {outN = delayN;} + inputSample += (oN[outN]); + //allpass filter N + + dN[6] = dN[5]; + dN[5] = dN[4]; + dN[4] = inputSample; + inputSample = (dL[1] + dN[5] + dN[6])/3.0; + + allpasstemp = outO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= oO[allpasstemp]*constallpass; + oO[outO] = inputSample; + inputSample *= constallpass; + outO--; if (outO < 0 || outO > delayO) {outO = delayO;} + inputSample += (oO[outO]); + //allpass filter O + + dO[6] = dO[5]; + dO[5] = dO[4]; + dO[4] = inputSample; + inputSample = (dK[1] + dO[5] + dO[6])/3.0; + + allpasstemp = outP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= oP[allpasstemp]*constallpass; + oP[outP] = inputSample; + inputSample *= constallpass; + outP--; if (outP < 0 || outP > delayP) {outP = delayP;} + inputSample += (oP[outP]); + //allpass filter P + + dP[6] = dP[5]; + dP[5] = dP[4]; + dP[4] = inputSample; + inputSample = (dJ[1] + dP[5] + dP[6])/3.0; + + allpasstemp = outQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= oQ[allpasstemp]*constallpass; + oQ[outQ] = inputSample; + inputSample *= constallpass; + outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;} + inputSample += (oQ[outQ]); + //allpass filter Q + + dQ[6] = dQ[5]; + dQ[5] = dQ[4]; + dQ[4] = inputSample; + inputSample = (dI[1] + dQ[5] + dQ[6])/3.0; + + allpasstemp = outR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= oR[allpasstemp]*constallpass; + oR[outR] = inputSample; + inputSample *= constallpass; + outR--; if (outR < 0 || outR > delayR) {outR = delayR;} + inputSample += (oR[outR]); + //allpass filter R + + dR[6] = dR[5]; + dR[5] = dR[4]; + dR[4] = inputSample; + inputSample = (dH[1] + dR[5] + dR[6])/3.0; + + allpasstemp = outS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= oS[allpasstemp]*constallpass; + oS[outS] = inputSample; + inputSample *= constallpass; + outS--; if (outS < 0 || outS > delayS) {outS = delayS;} + inputSample += (oS[outS]); + //allpass filter S + + dS[6] = dS[5]; + dS[5] = dS[4]; + dS[4] = inputSample; + inputSample = (dG[1] + dS[5] + dS[6])/3.0; + + allpasstemp = outT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= oT[allpasstemp]*constallpass; + oT[outT] = inputSample; + inputSample *= constallpass; + outT--; if (outT < 0 || outT > delayT) {outT = delayT;} + inputSample += (oT[outT]); + //allpass filter T + + dT[6] = dT[5]; + dT[5] = dT[4]; + dT[4] = inputSample; + inputSample = (dF[1] + dT[5] + dT[6])/3.0; + + allpasstemp = outU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= oU[allpasstemp]*constallpass; + oU[outU] = inputSample; + inputSample *= constallpass; + outU--; if (outU < 0 || outU > delayU) {outU = delayU;} + inputSample += (oU[outU]); + //allpass filter U + + dU[6] = dU[5]; + dU[5] = dU[4]; + dU[4] = inputSample; + inputSample = (dE[1] + dU[5] + dU[6])/3.0; + + allpasstemp = outV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= oV[allpasstemp]*constallpass; + oV[outV] = inputSample; + inputSample *= constallpass; + outV--; if (outV < 0 || outV > delayV) {outV = delayV;} + inputSample += (oV[outV]); + //allpass filter V + + dV[6] = dV[5]; + dV[5] = dV[4]; + dV[4] = inputSample; + inputSample = (dD[1] + dV[5] + dV[6])/3.0; + + allpasstemp = outW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= oW[allpasstemp]*constallpass; + oW[outW] = inputSample; + inputSample *= constallpass; + outW--; if (outW < 0 || outW > delayW) {outW = delayW;} + inputSample += (oW[outW]); + //allpass filter W + + dW[6] = dW[5]; + dW[5] = dW[4]; + dW[4] = inputSample; + inputSample = (dC[1] + dW[5] + dW[6])/3.0; + + allpasstemp = outX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= oX[allpasstemp]*constallpass; + oX[outX] = inputSample; + inputSample *= constallpass; + outX--; if (outX < 0 || outX > delayX) {outX = delayX;} + inputSample += (oX[outX]); + //allpass filter X + + dX[6] = dX[5]; + dX[5] = dX[4]; + dX[4] = inputSample; + inputSample = (dA[1] + dX[5] + dX[6])/3.0; + + allpasstemp = outY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= oY[allpasstemp]*constallpass; + oY[outY] = inputSample; + inputSample *= constallpass; + outY--; if (outY < 0 || outY > delayY) {outY = delayY;} + inputSample += (oY[outY]); + //allpass filter Y + + dY[6] = dY[5]; + dY[5] = dY[4]; + dY[4] = inputSample; + inputSample = (dB[1] + dY[5] + dY[6])/3.0; + + allpasstemp = outZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= oZ[allpasstemp]*constallpass; + oZ[outZ] = inputSample; + inputSample *= constallpass; + outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;} + inputSample += (oZ[outZ]); + //allpass filter Z + + dZ[6] = dZ[5]; + dZ[5] = dZ[4]; + dZ[4] = inputSample; + inputSample = (dZ[5] + dZ[6]); + //output Spring + break; + + +case 3: //Tiled + allpasstemp = alpA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= aA[allpasstemp]*constallpass; + aA[alpA] = inputSample; + inputSample *= constallpass; + alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;} + inputSample += (aA[alpA]); + //allpass filter A + + dA[2] = dA[1]; + dA[1] = inputSample; + inputSample = (dA[1] + dA[2])/2.0; + + allpasstemp = alpB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= aB[allpasstemp]*constallpass; + aB[alpB] = inputSample; + inputSample *= constallpass; + alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;} + inputSample += (aB[alpB]); + //allpass filter B + + dB[2] = dB[1]; + dB[1] = inputSample; + inputSample = (dB[1] + dB[2])/2.0; + + allpasstemp = alpC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= aC[allpasstemp]*constallpass; + aC[alpC] = inputSample; + inputSample *= constallpass; + alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;} + inputSample += (aC[alpC]); + //allpass filter C + + dC[2] = dC[1]; + dC[1] = inputSample; + inputSample = (dA[1] + dC[2])/2.0; + + allpasstemp = alpD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= aD[allpasstemp]*constallpass; + aD[alpD] = inputSample; + inputSample *= constallpass; + alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;} + inputSample += (aD[alpD]); + //allpass filter D + + dD[2] = dD[1]; + dD[1] = inputSample; + inputSample = (dD[1] + dD[2])/2.0; + + allpasstemp = alpE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= aE[allpasstemp]*constallpass; + aE[alpE] = inputSample; + inputSample *= constallpass; + alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;} + inputSample += (aE[alpE]); + //allpass filter E + + dE[2] = dE[1]; + dE[1] = inputSample; + inputSample = (dA[1] + dE[2])/2.0; + + allpasstemp = alpF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= aF[allpasstemp]*constallpass; + aF[alpF] = inputSample; + inputSample *= constallpass; + alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;} + inputSample += (aF[alpF]); + //allpass filter F + + dF[2] = dF[1]; + dF[1] = inputSample; + inputSample = (dF[1] + dF[2])/2.0; + + allpasstemp = alpG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= aG[allpasstemp]*constallpass; + aG[alpG] = inputSample; + inputSample *= constallpass; + alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;} + inputSample += (aG[alpG]); + //allpass filter G + + dG[2] = dG[1]; + dG[1] = inputSample; + inputSample = (dA[1] + dG[2])/2.0; + + allpasstemp = alpH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= aH[allpasstemp]*constallpass; + aH[alpH] = inputSample; + inputSample *= constallpass; + alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;} + inputSample += (aH[alpH]); + //allpass filter H + + dH[2] = dH[1]; + dH[1] = inputSample; + inputSample = (dH[1] + dH[2])/2.0; + + allpasstemp = alpI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= aI[allpasstemp]*constallpass; + aI[alpI] = inputSample; + inputSample *= constallpass; + alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;} + inputSample += (aI[alpI]); + //allpass filter I + + dI[2] = dI[1]; + dI[1] = inputSample; + inputSample = (dI[1] + dI[2])/2.0; + + allpasstemp = alpJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= aJ[allpasstemp]*constallpass; + aJ[alpJ] = inputSample; + inputSample *= constallpass; + alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;} + inputSample += (aJ[alpJ]); + //allpass filter J + + dJ[2] = dJ[1]; + dJ[1] = inputSample; + inputSample = (dJ[1] + dJ[2])/2.0; + + allpasstemp = alpK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= aK[allpasstemp]*constallpass; + aK[alpK] = inputSample; + inputSample *= constallpass; + alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;} + inputSample += (aK[alpK]); + //allpass filter K + + dK[2] = dK[1]; + dK[1] = inputSample; + inputSample = (dA[1] + dK[2])/2.0; + + allpasstemp = alpL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= aL[allpasstemp]*constallpass; + aL[alpL] = inputSample; + inputSample *= constallpass; + alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;} + inputSample += (aL[alpL]); + //allpass filter L + + dL[2] = dL[1]; + dL[1] = inputSample; + inputSample = (dL[1] + dL[2])/2.0; + + allpasstemp = alpM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= aM[allpasstemp]*constallpass; + aM[alpM] = inputSample; + inputSample *= constallpass; + alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;} + inputSample += (aM[alpM]); + //allpass filter M + + dM[2] = dM[1]; + dM[1] = inputSample; + inputSample = (dA[1] + dM[2])/2.0; + + allpasstemp = alpN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= aN[allpasstemp]*constallpass; + aN[alpN] = inputSample; + inputSample *= constallpass; + alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;} + inputSample += (aN[alpN]); + //allpass filter N + + dN[2] = dN[1]; + dN[1] = inputSample; + inputSample = (dN[1] + dN[2])/2.0; + + allpasstemp = alpO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= aO[allpasstemp]*constallpass; + aO[alpO] = inputSample; + inputSample *= constallpass; + alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;} + inputSample += (aO[alpO]); + //allpass filter O + + dO[2] = dO[1]; + dO[1] = inputSample; + inputSample = (dO[1] + dO[2])/2.0; + + allpasstemp = alpP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= aP[allpasstemp]*constallpass; + aP[alpP] = inputSample; + inputSample *= constallpass; + alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;} + inputSample += (aP[alpP]); + //allpass filter P + + dP[2] = dP[1]; + dP[1] = inputSample; + inputSample = (dP[1] + dP[2])/2.0; + + allpasstemp = alpQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= aQ[allpasstemp]*constallpass; + aQ[alpQ] = inputSample; + inputSample *= constallpass; + alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;} + inputSample += (aQ[alpQ]); + //allpass filter Q + + dQ[2] = dQ[1]; + dQ[1] = inputSample; + inputSample = (dA[1] + dQ[2])/2.0; + + allpasstemp = alpR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= aR[allpasstemp]*constallpass; + aR[alpR] = inputSample; + inputSample *= constallpass; + alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;} + inputSample += (aR[alpR]); + //allpass filter R + + dR[2] = dR[1]; + dR[1] = inputSample; + inputSample = (dR[1] + dR[2])/2.0; + + allpasstemp = alpS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= aS[allpasstemp]*constallpass; + aS[alpS] = inputSample; + inputSample *= constallpass; + alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;} + inputSample += (aS[alpS]); + //allpass filter S + + dS[2] = dS[1]; + dS[1] = inputSample; + inputSample = (dA[1] + dS[2])/2.0; + + allpasstemp = alpT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= aT[allpasstemp]*constallpass; + aT[alpT] = inputSample; + inputSample *= constallpass; + alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;} + inputSample += (aT[alpT]); + //allpass filter T + + dT[2] = dT[1]; + dT[1] = inputSample; + inputSample = (dT[1] + dT[2])/2.0; + + allpasstemp = alpU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= aU[allpasstemp]*constallpass; + aU[alpU] = inputSample; + inputSample *= constallpass; + alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;} + inputSample += (aU[alpU]); + //allpass filter U + + dU[2] = dU[1]; + dU[1] = inputSample; + inputSample = (dU[1] + dU[2])/2.0; + + allpasstemp = alpV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= aV[allpasstemp]*constallpass; + aV[alpV] = inputSample; + inputSample *= constallpass; + alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;} + inputSample += (aV[alpV]); + //allpass filter V + + dV[2] = dV[1]; + dV[1] = inputSample; + inputSample = (dV[1] + dV[2])/2.0; + + allpasstemp = alpW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= aW[allpasstemp]*constallpass; + aW[alpW] = inputSample; + inputSample *= constallpass; + alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;} + inputSample += (aW[alpW]); + //allpass filter W + + dW[2] = dW[1]; + dW[1] = inputSample; + inputSample = (dA[1] + dW[2])/2.0; + + allpasstemp = alpX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= aX[allpasstemp]*constallpass; + aX[alpX] = inputSample; + inputSample *= constallpass; + alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;} + inputSample += (aX[alpX]); + //allpass filter X + + dX[2] = dX[1]; + dX[1] = inputSample; + inputSample = (dX[1] + dX[2])/2.0; + + allpasstemp = alpY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= aY[allpasstemp]*constallpass; + aY[alpY] = inputSample; + inputSample *= constallpass; + alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;} + inputSample += (aY[alpY]); + //allpass filter Y + + dY[2] = dY[1]; + dY[1] = inputSample; + inputSample = (dY[1] + dY[2])/2.0; + + allpasstemp = alpZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= aZ[allpasstemp]*constallpass; + aZ[alpZ] = inputSample; + inputSample *= constallpass; + alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;} + inputSample += (aZ[alpZ]); + //allpass filter Z + + dZ[2] = dZ[1]; + dZ[1] = inputSample; + inputSample = (dZ[1] + dZ[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= oA[allpasstemp]*constallpass; + oA[outA] = inputSample; + inputSample *= constallpass; + outA--; if (outA < 0 || outA > delayA) {outA = delayA;} + inputSample += (oA[outA]); + //allpass filter A + + dA[5] = dA[4]; + dA[4] = inputSample; + inputSample = (dA[4] + dA[5])/2.0; + + allpasstemp = outB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= oB[allpasstemp]*constallpass; + oB[outB] = inputSample; + inputSample *= constallpass; + outB--; if (outB < 0 || outB > delayB) {outB = delayB;} + inputSample += (oB[outB]); + //allpass filter B + + dB[5] = dB[4]; + dB[4] = inputSample; + inputSample = (dB[4] + dB[5])/2.0; + + allpasstemp = outC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= oC[allpasstemp]*constallpass; + oC[outC] = inputSample; + inputSample *= constallpass; + outC--; if (outC < 0 || outC > delayC) {outC = delayC;} + inputSample += (oC[outC]); + //allpass filter C + + dC[5] = dC[4]; + dC[4] = inputSample; + inputSample = (dA[1] + dC[5])/2.0; + + allpasstemp = outD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= oD[allpasstemp]*constallpass; + oD[outD] = inputSample; + inputSample *= constallpass; + outD--; if (outD < 0 || outD > delayD) {outD = delayD;} + inputSample += (oD[outD]); + //allpass filter D + + dD[5] = dD[4]; + dD[4] = inputSample; + inputSample = (dD[4] + dD[5])/2.0; + + allpasstemp = outE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= oE[allpasstemp]*constallpass; + oE[outE] = inputSample; + inputSample *= constallpass; + outE--; if (outE < 0 || outE > delayE) {outE = delayE;} + inputSample += (oE[outE]); + //allpass filter E + + dE[5] = dE[4]; + dE[4] = inputSample; + inputSample = (dA[1] + dE[5])/2.0; + + allpasstemp = outF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= oF[allpasstemp]*constallpass; + oF[outF] = inputSample; + inputSample *= constallpass; + outF--; if (outF < 0 || outF > delayF) {outF = delayF;} + inputSample += (oF[outF]); + //allpass filter F + + dF[5] = dF[4]; + dF[4] = inputSample; + inputSample = (dF[4] + dF[5])/2.0; + + allpasstemp = outG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= oG[allpasstemp]*constallpass; + oG[outG] = inputSample; + inputSample *= constallpass; + outG--; if (outG < 0 || outG > delayG) {outG = delayG;} + inputSample += (oG[outG]); + //allpass filter G + + dG[5] = dG[4]; + dG[4] = inputSample; + inputSample = (dG[4] + dG[5])/2.0; + + allpasstemp = outH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= oH[allpasstemp]*constallpass; + oH[outH] = inputSample; + inputSample *= constallpass; + outH--; if (outH < 0 || outH > delayH) {outH = delayH;} + inputSample += (oH[outH]); + //allpass filter H + + dH[5] = dH[4]; + dH[4] = inputSample; + inputSample = (dH[4] + dH[5])/2.0; + + allpasstemp = outI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= oI[allpasstemp]*constallpass; + oI[outI] = inputSample; + inputSample *= constallpass; + outI--; if (outI < 0 || outI > delayI) {outI = delayI;} + inputSample += (oI[outI]); + //allpass filter I + + dI[5] = dI[4]; + dI[4] = inputSample; + inputSample = (dI[4] + dI[5])/2.0; + + allpasstemp = outJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= oJ[allpasstemp]*constallpass; + oJ[outJ] = inputSample; + inputSample *= constallpass; + outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;} + inputSample += (oJ[outJ]); + //allpass filter J + + dJ[5] = dJ[4]; + dJ[4] = inputSample; + inputSample = (dJ[4] + dJ[5])/2.0; + + allpasstemp = outK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= oK[allpasstemp]*constallpass; + oK[outK] = inputSample; + inputSample *= constallpass; + outK--; if (outK < 0 || outK > delayK) {outK = delayK;} + inputSample += (oK[outK]); + //allpass filter K + + dK[5] = dK[4]; + dK[4] = inputSample; + inputSample = (dA[1] + dK[5])/2.0; + + allpasstemp = outL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= oL[allpasstemp]*constallpass; + oL[outL] = inputSample; + inputSample *= constallpass; + outL--; if (outL < 0 || outL > delayL) {outL = delayL;} + inputSample += (oL[outL]); + //allpass filter L + + dL[5] = dL[4]; + dL[4] = inputSample; + inputSample = (dL[4] + dL[5])/2.0; + + allpasstemp = outM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= oM[allpasstemp]*constallpass; + oM[outM] = inputSample; + inputSample *= constallpass; + outM--; if (outM < 0 || outM > delayM) {outM = delayM;} + inputSample += (oM[outM]); + //allpass filter M + + dM[5] = dM[4]; + dM[4] = inputSample; + inputSample = (dM[4] + dM[5])/2.0; + + allpasstemp = outN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= oN[allpasstemp]*constallpass; + oN[outN] = inputSample; + inputSample *= constallpass; + outN--; if (outN < 0 || outN > delayN) {outN = delayN;} + inputSample += (oN[outN]); + //allpass filter N + + dN[5] = dN[4]; + dN[4] = inputSample; + inputSample = (dN[4] + dN[5])/2.0; + + allpasstemp = outO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= oO[allpasstemp]*constallpass; + oO[outO] = inputSample; + inputSample *= constallpass; + outO--; if (outO < 0 || outO > delayO) {outO = delayO;} + inputSample += (oO[outO]); + //allpass filter O + + dO[5] = dO[4]; + dO[4] = inputSample; + inputSample = (dA[1] + dO[5])/2.0; + + allpasstemp = outP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= oP[allpasstemp]*constallpass; + oP[outP] = inputSample; + inputSample *= constallpass; + outP--; if (outP < 0 || outP > delayP) {outP = delayP;} + inputSample += (oP[outP]); + //allpass filter P + + dP[5] = dP[4]; + dP[4] = inputSample; + inputSample = (dP[4] + dP[5])/2.0; + + allpasstemp = outQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= oQ[allpasstemp]*constallpass; + oQ[outQ] = inputSample; + inputSample *= constallpass; + outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;} + inputSample += (oQ[outQ]); + //allpass filter Q + + dQ[5] = dQ[4]; + dQ[4] = inputSample; + inputSample = (dA[1] + dQ[5])/2.0; + + allpasstemp = outR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= oR[allpasstemp]*constallpass; + oR[outR] = inputSample; + inputSample *= constallpass; + outR--; if (outR < 0 || outR > delayR) {outR = delayR;} + inputSample += (oR[outR]); + //allpass filter R + + dR[5] = dR[4]; + dR[4] = inputSample; + inputSample = (dR[4] + dR[5])/2.0; + + allpasstemp = outS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= oS[allpasstemp]*constallpass; + oS[outS] = inputSample; + inputSample *= constallpass; + outS--; if (outS < 0 || outS > delayS) {outS = delayS;} + inputSample += (oS[outS]); + //allpass filter S + + dS[5] = dS[4]; + dS[4] = inputSample; + inputSample = (dS[4] + dS[5])/2.0; + + allpasstemp = outT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= oT[allpasstemp]*constallpass; + oT[outT] = inputSample; + inputSample *= constallpass; + outT--; if (outT < 0 || outT > delayT) {outT = delayT;} + inputSample += (oT[outT]); + //allpass filter T + + dT[5] = dT[4]; + dT[4] = inputSample; + inputSample = (dT[4] + dT[5])/2.0; + + allpasstemp = outU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= oU[allpasstemp]*constallpass; + oU[outU] = inputSample; + inputSample *= constallpass; + outU--; if (outU < 0 || outU > delayU) {outU = delayU;} + inputSample += (oU[outU]); + //allpass filter U + + dU[5] = dU[4]; + dU[4] = inputSample; + inputSample = (dA[1] + dU[5])/2.0; + + allpasstemp = outV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= oV[allpasstemp]*constallpass; + oV[outV] = inputSample; + inputSample *= constallpass; + outV--; if (outV < 0 || outV > delayV) {outV = delayV;} + inputSample += (oV[outV]); + //allpass filter V + + dV[5] = dV[4]; + dV[4] = inputSample; + inputSample = (dV[4] + dV[5])/2.0; + + allpasstemp = outW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= oW[allpasstemp]*constallpass; + oW[outW] = inputSample; + inputSample *= constallpass; + outW--; if (outW < 0 || outW > delayW) {outW = delayW;} + inputSample += (oW[outW]); + //allpass filter W + + dW[5] = dW[4]; + dW[4] = inputSample; + inputSample = (dW[4] + dW[5])/2.0; + + allpasstemp = outX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= oX[allpasstemp]*constallpass; + oX[outX] = inputSample; + inputSample *= constallpass; + outX--; if (outX < 0 || outX > delayX) {outX = delayX;} + inputSample += (oX[outX]); + //allpass filter X + + dX[5] = dX[4]; + dX[4] = inputSample; + inputSample = (dX[4] + dX[5])/2.0; + + allpasstemp = outY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= oY[allpasstemp]*constallpass; + oY[outY] = inputSample; + inputSample *= constallpass; + outY--; if (outY < 0 || outY > delayY) {outY = delayY;} + inputSample += (oY[outY]); + //allpass filter Y + + dY[5] = dY[4]; + dY[4] = inputSample; + inputSample = (dY[4] + dY[5])/2.0; + + allpasstemp = outZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= oZ[allpasstemp]*constallpass; + oZ[outZ] = inputSample; + inputSample *= constallpass; + outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;} + inputSample += (oZ[outZ]); + //allpass filter Z + + dZ[5] = dZ[4]; + dZ[4] = inputSample; + inputSample = (dZ[4] + dZ[5]); + //output Tiled + break; + + +case 4://Room + allpasstemp = alpA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= aA[allpasstemp]*constallpass; + aA[alpA] = inputSample; + inputSample *= constallpass; + alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;} + inputSample += (aA[alpA]); + //allpass filter A + + dA[2] = dA[1]; + dA[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= aB[allpasstemp]*constallpass; + aB[alpB] = inputSample; + inputSample *= constallpass; + alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;} + inputSample += (aB[alpB]); + //allpass filter B + + dB[2] = dB[1]; + dB[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= aC[allpasstemp]*constallpass; + aC[alpC] = inputSample; + inputSample *= constallpass; + alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;} + inputSample += (aC[alpC]); + //allpass filter C + + dC[2] = dC[1]; + dC[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= aD[allpasstemp]*constallpass; + aD[alpD] = inputSample; + inputSample *= constallpass; + alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;} + inputSample += (aD[alpD]); + //allpass filter D + + dD[2] = dD[1]; + dD[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= aE[allpasstemp]*constallpass; + aE[alpE] = inputSample; + inputSample *= constallpass; + alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;} + inputSample += (aE[alpE]); + //allpass filter E + + dE[2] = dE[1]; + dE[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= aF[allpasstemp]*constallpass; + aF[alpF] = inputSample; + inputSample *= constallpass; + alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;} + inputSample += (aF[alpF]); + //allpass filter F + + dF[2] = dF[1]; + dF[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= aG[allpasstemp]*constallpass; + aG[alpG] = inputSample; + inputSample *= constallpass; + alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;} + inputSample += (aG[alpG]); + //allpass filter G + + dG[2] = dG[1]; + dG[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= aH[allpasstemp]*constallpass; + aH[alpH] = inputSample; + inputSample *= constallpass; + alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;} + inputSample += (aH[alpH]); + //allpass filter H + + dH[2] = dH[1]; + dH[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= aI[allpasstemp]*constallpass; + aI[alpI] = inputSample; + inputSample *= constallpass; + alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;} + inputSample += (aI[alpI]); + //allpass filter I + + dI[2] = dI[1]; + dI[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= aJ[allpasstemp]*constallpass; + aJ[alpJ] = inputSample; + inputSample *= constallpass; + alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;} + inputSample += (aJ[alpJ]); + //allpass filter J + + dJ[2] = dJ[1]; + dJ[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= aK[allpasstemp]*constallpass; + aK[alpK] = inputSample; + inputSample *= constallpass; + alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;} + inputSample += (aK[alpK]); + //allpass filter K + + dK[2] = dK[1]; + dK[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= aL[allpasstemp]*constallpass; + aL[alpL] = inputSample; + inputSample *= constallpass; + alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;} + inputSample += (aL[alpL]); + //allpass filter L + + dL[2] = dL[1]; + dL[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= aM[allpasstemp]*constallpass; + aM[alpM] = inputSample; + inputSample *= constallpass; + alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;} + inputSample += (aM[alpM]); + //allpass filter M + + dM[2] = dM[1]; + dM[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= aN[allpasstemp]*constallpass; + aN[alpN] = inputSample; + inputSample *= constallpass; + alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;} + inputSample += (aN[alpN]); + //allpass filter N + + dN[2] = dN[1]; + dN[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= aO[allpasstemp]*constallpass; + aO[alpO] = inputSample; + inputSample *= constallpass; + alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;} + inputSample += (aO[alpO]); + //allpass filter O + + dO[2] = dO[1]; + dO[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= aP[allpasstemp]*constallpass; + aP[alpP] = inputSample; + inputSample *= constallpass; + alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;} + inputSample += (aP[alpP]); + //allpass filter P + + dP[2] = dP[1]; + dP[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= aQ[allpasstemp]*constallpass; + aQ[alpQ] = inputSample; + inputSample *= constallpass; + alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;} + inputSample += (aQ[alpQ]); + //allpass filter Q + + dQ[2] = dQ[1]; + dQ[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= aR[allpasstemp]*constallpass; + aR[alpR] = inputSample; + inputSample *= constallpass; + alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;} + inputSample += (aR[alpR]); + //allpass filter R + + dR[2] = dR[1]; + dR[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= aS[allpasstemp]*constallpass; + aS[alpS] = inputSample; + inputSample *= constallpass; + alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;} + inputSample += (aS[alpS]); + //allpass filter S + + dS[2] = dS[1]; + dS[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= aT[allpasstemp]*constallpass; + aT[alpT] = inputSample; + inputSample *= constallpass; + alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;} + inputSample += (aT[alpT]); + //allpass filter T + + dT[2] = dT[1]; + dT[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= aU[allpasstemp]*constallpass; + aU[alpU] = inputSample; + inputSample *= constallpass; + alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;} + inputSample += (aU[alpU]); + //allpass filter U + + dU[2] = dU[1]; + dU[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= aV[allpasstemp]*constallpass; + aV[alpV] = inputSample; + inputSample *= constallpass; + alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;} + inputSample += (aV[alpV]); + //allpass filter V + + dV[2] = dV[1]; + dV[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= aW[allpasstemp]*constallpass; + aW[alpW] = inputSample; + inputSample *= constallpass; + alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;} + inputSample += (aW[alpW]); + //allpass filter W + + dW[2] = dW[1]; + dW[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= aX[allpasstemp]*constallpass; + aX[alpX] = inputSample; + inputSample *= constallpass; + alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;} + inputSample += (aX[alpX]); + //allpass filter X + + dX[2] = dX[1]; + dX[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= aY[allpasstemp]*constallpass; + aY[alpY] = inputSample; + inputSample *= constallpass; + alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;} + inputSample += (aY[alpY]); + //allpass filter Y + + dY[2] = dY[1]; + dY[1] = inputSample; + inputSample = drySample; + + allpasstemp = alpZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= aZ[allpasstemp]*constallpass; + aZ[alpZ] = inputSample; + inputSample *= constallpass; + alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;} + inputSample += (aZ[alpZ]); + //allpass filter Z + + dZ[2] = dZ[1]; + dZ[1] = inputSample; + inputSample = drySample; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= oA[allpasstemp]*constallpass; + oA[outA] = inputSample; + inputSample *= constallpass; + outA--; if (outA < 0 || outA > delayA) {outA = delayA;} + inputSample += (oA[outA]); + //allpass filter A + + dA[5] = dA[4]; + dA[4] = inputSample; + inputSample = (dA[1]+dA[2])/2.0; + + allpasstemp = outB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= oB[allpasstemp]*constallpass; + oB[outB] = inputSample; + inputSample *= constallpass; + outB--; if (outB < 0 || outB > delayB) {outB = delayB;} + inputSample += (oB[outB]); + //allpass filter B + + dB[5] = dB[4]; + dB[4] = inputSample; + inputSample = (dB[1]+dB[2])/2.0; + + allpasstemp = outC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= oC[allpasstemp]*constallpass; + oC[outC] = inputSample; + inputSample *= constallpass; + outC--; if (outC < 0 || outC > delayC) {outC = delayC;} + inputSample += (oC[outC]); + //allpass filter C + + dC[5] = dC[4]; + dC[4] = inputSample; + inputSample = (dC[1]+dC[2])/2.0; + + allpasstemp = outD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= oD[allpasstemp]*constallpass; + oD[outD] = inputSample; + inputSample *= constallpass; + outD--; if (outD < 0 || outD > delayD) {outD = delayD;} + inputSample += (oD[outD]); + //allpass filter D + + dD[5] = dD[4]; + dD[4] = inputSample; + inputSample = (dD[1]+dD[2])/2.0; + + allpasstemp = outE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= oE[allpasstemp]*constallpass; + oE[outE] = inputSample; + inputSample *= constallpass; + outE--; if (outE < 0 || outE > delayE) {outE = delayE;} + inputSample += (oE[outE]); + //allpass filter E + + dE[5] = dE[4]; + dE[4] = inputSample; + inputSample = (dE[1]+dE[2])/2.0; + + allpasstemp = outF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= oF[allpasstemp]*constallpass; + oF[outF] = inputSample; + inputSample *= constallpass; + outF--; if (outF < 0 || outF > delayF) {outF = delayF;} + inputSample += (oF[outF]); + //allpass filter F + + dF[5] = dF[4]; + dF[4] = inputSample; + inputSample = (dF[1]+dF[2])/2.0; + + allpasstemp = outG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= oG[allpasstemp]*constallpass; + oG[outG] = inputSample; + inputSample *= constallpass; + outG--; if (outG < 0 || outG > delayG) {outG = delayG;} + inputSample += (oG[outG]); + //allpass filter G + + dG[5] = dG[4]; + dG[4] = inputSample; + inputSample = (dG[1]+dG[2])/2.0; + + allpasstemp = outH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= oH[allpasstemp]*constallpass; + oH[outH] = inputSample; + inputSample *= constallpass; + outH--; if (outH < 0 || outH > delayH) {outH = delayH;} + inputSample += (oH[outH]); + //allpass filter H + + dH[5] = dH[4]; + dH[4] = inputSample; + inputSample = (dH[1]+dH[2])/2.0; + + allpasstemp = outI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= oI[allpasstemp]*constallpass; + oI[outI] = inputSample; + inputSample *= constallpass; + outI--; if (outI < 0 || outI > delayI) {outI = delayI;} + inputSample += (oI[outI]); + //allpass filter I + + dI[5] = dI[4]; + dI[4] = inputSample; + inputSample = (dI[1]+dI[2])/2.0; + + allpasstemp = outJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= oJ[allpasstemp]*constallpass; + oJ[outJ] = inputSample; + inputSample *= constallpass; + outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;} + inputSample += (oJ[outJ]); + //allpass filter J + + dJ[5] = dJ[4]; + dJ[4] = inputSample; + inputSample = (dJ[1]+dJ[2])/2.0; + + allpasstemp = outK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= oK[allpasstemp]*constallpass; + oK[outK] = inputSample; + inputSample *= constallpass; + outK--; if (outK < 0 || outK > delayK) {outK = delayK;} + inputSample += (oK[outK]); + //allpass filter K + + dK[5] = dK[4]; + dK[4] = inputSample; + inputSample = (dK[1]+dK[2])/2.0; + + allpasstemp = outL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= oL[allpasstemp]*constallpass; + oL[outL] = inputSample; + inputSample *= constallpass; + outL--; if (outL < 0 || outL > delayL) {outL = delayL;} + inputSample += (oL[outL]); + //allpass filter L + + dL[5] = dL[4]; + dL[4] = inputSample; + inputSample = (dL[1]+dL[2])/2.0; + + allpasstemp = outM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= oM[allpasstemp]*constallpass; + oM[outM] = inputSample; + inputSample *= constallpass; + outM--; if (outM < 0 || outM > delayM) {outM = delayM;} + inputSample += (oM[outM]); + //allpass filter M + + dM[5] = dM[4]; + dM[4] = inputSample; + inputSample = (dM[1]+dM[2])/2.0; + + allpasstemp = outN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= oN[allpasstemp]*constallpass; + oN[outN] = inputSample; + inputSample *= constallpass; + outN--; if (outN < 0 || outN > delayN) {outN = delayN;} + inputSample += (oN[outN]); + //allpass filter N + + dN[5] = dN[4]; + dN[4] = inputSample; + inputSample = (dN[1]+dN[2])/2.0; + + allpasstemp = outO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= oO[allpasstemp]*constallpass; + oO[outO] = inputSample; + inputSample *= constallpass; + outO--; if (outO < 0 || outO > delayO) {outO = delayO;} + inputSample += (oO[outO]); + //allpass filter O + + dO[5] = dO[4]; + dO[4] = inputSample; + inputSample = (dO[1]+dO[2])/2.0; + + allpasstemp = outP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= oP[allpasstemp]*constallpass; + oP[outP] = inputSample; + inputSample *= constallpass; + outP--; if (outP < 0 || outP > delayP) {outP = delayP;} + inputSample += (oP[outP]); + //allpass filter P + + dP[5] = dP[4]; + dP[4] = inputSample; + inputSample = (dP[1]+dP[2])/2.0; + + allpasstemp = outQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= oQ[allpasstemp]*constallpass; + oQ[outQ] = inputSample; + inputSample *= constallpass; + outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;} + inputSample += (oQ[outQ]); + //allpass filter Q + + dQ[5] = dQ[4]; + dQ[4] = inputSample; + inputSample = (dQ[1]+dQ[2])/2.0; + + allpasstemp = outR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= oR[allpasstemp]*constallpass; + oR[outR] = inputSample; + inputSample *= constallpass; + outR--; if (outR < 0 || outR > delayR) {outR = delayR;} + inputSample += (oR[outR]); + //allpass filter R + + dR[5] = dR[4]; + dR[4] = inputSample; + inputSample = (dR[1]+dR[2])/2.0; + + allpasstemp = outS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= oS[allpasstemp]*constallpass; + oS[outS] = inputSample; + inputSample *= constallpass; + outS--; if (outS < 0 || outS > delayS) {outS = delayS;} + inputSample += (oS[outS]); + //allpass filter S + + dS[5] = dS[4]; + dS[4] = inputSample; + inputSample = (dS[1]+dS[2])/2.0; + + allpasstemp = outT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= oT[allpasstemp]*constallpass; + oT[outT] = inputSample; + inputSample *= constallpass; + outT--; if (outT < 0 || outT > delayT) {outT = delayT;} + inputSample += (oT[outT]); + //allpass filter T + + dT[5] = dT[4]; + dT[4] = inputSample; + inputSample = (dT[1]+dT[2])/2.0; + + allpasstemp = outU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= oU[allpasstemp]*constallpass; + oU[outU] = inputSample; + inputSample *= constallpass; + outU--; if (outU < 0 || outU > delayU) {outU = delayU;} + inputSample += (oU[outU]); + //allpass filter U + + dU[5] = dU[4]; + dU[4] = inputSample; + inputSample = (dU[1]+dU[2])/2.0; + + allpasstemp = outV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= oV[allpasstemp]*constallpass; + oV[outV] = inputSample; + inputSample *= constallpass; + outV--; if (outV < 0 || outV > delayV) {outV = delayV;} + inputSample += (oV[outV]); + //allpass filter V + + dV[5] = dV[4]; + dV[4] = inputSample; + inputSample = (dV[1]+dV[2])/2.0; + + allpasstemp = outW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= oW[allpasstemp]*constallpass; + oW[outW] = inputSample; + inputSample *= constallpass; + outW--; if (outW < 0 || outW > delayW) {outW = delayW;} + inputSample += (oW[outW]); + //allpass filter W + + dW[5] = dW[4]; + dW[4] = inputSample; + inputSample = (dW[1]+dW[2])/2.0; + + allpasstemp = outX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= oX[allpasstemp]*constallpass; + oX[outX] = inputSample; + inputSample *= constallpass; + outX--; if (outX < 0 || outX > delayX) {outX = delayX;} + inputSample += (oX[outX]); + //allpass filter X + + dX[5] = dX[4]; + dX[4] = inputSample; + inputSample = (dX[1]+dX[2])/2.0; + + allpasstemp = outY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= oY[allpasstemp]*constallpass; + oY[outY] = inputSample; + inputSample *= constallpass; + outY--; if (outY < 0 || outY > delayY) {outY = delayY;} + inputSample += (oY[outY]); + //allpass filter Y + + dY[5] = dY[4]; + dY[4] = inputSample; + inputSample = (dY[1]+dY[2])/2.0; + + allpasstemp = outZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= oZ[allpasstemp]*constallpass; + oZ[outZ] = inputSample; + inputSample *= constallpass; + outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;} + inputSample += (oZ[outZ]); + //allpass filter Z + + dZ[5] = dZ[4]; + dZ[4] = inputSample; + inputSample = (dB[4] * dryness); + inputSample += (dC[4] * dryness); + inputSample += dD[4]; + inputSample += dE[4]; + inputSample += dF[4]; + inputSample += dG[4]; + inputSample += dH[4]; + inputSample += dI[4]; + inputSample += dJ[4]; + inputSample += dK[4]; + inputSample += dL[4]; + inputSample += dM[4]; + inputSample += dN[4]; + inputSample += dO[4]; + inputSample += dP[4]; + inputSample += dQ[4]; + inputSample += dR[4]; + inputSample += dS[4]; + inputSample += dT[4]; + inputSample += dU[4]; + inputSample += dV[4]; + inputSample += dW[4]; + inputSample += dX[4]; + inputSample += dY[4]; + inputSample += (dZ[4] * wetness); + + inputSample += (dB[5] * dryness); + inputSample += (dC[5] * dryness); + inputSample += dD[5]; + inputSample += dE[5]; + inputSample += dF[5]; + inputSample += dG[5]; + inputSample += dH[5]; + inputSample += dI[5]; + inputSample += dJ[5]; + inputSample += dK[5]; + inputSample += dL[5]; + inputSample += dM[5]; + inputSample += dN[5]; + inputSample += dO[5]; + inputSample += dP[5]; + inputSample += dQ[5]; + inputSample += dR[5]; + inputSample += dS[5]; + inputSample += dT[5]; + inputSample += dU[5]; + inputSample += dV[5]; + inputSample += dW[5]; + inputSample += dX[5]; + inputSample += dY[5]; + inputSample += (dZ[5] * wetness); + + inputSample /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + +case 5: //Stretch + allpasstemp = alpA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= aA[allpasstemp]*constallpass; + aA[alpA] = inputSample; + inputSample *= constallpass; + alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;} + inputSample += (aA[alpA]); + //allpass filter A + + dA[2] = dA[1]; + dA[1] = inputSample; + inputSample = (dA[1] + dA[2])/2.0; + + allpasstemp = alpB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= aB[allpasstemp]*constallpass; + aB[alpB] = inputSample; + inputSample *= constallpass; + alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;} + inputSample += (aB[alpB]); + //allpass filter B + + dB[2] = dB[1]; + dB[1] = inputSample; + inputSample = (dB[1] + dB[2])/2.0; + + allpasstemp = alpC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= aC[allpasstemp]*constallpass; + aC[alpC] = inputSample; + inputSample *= constallpass; + alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;} + inputSample += (aC[alpC]); + //allpass filter C + + dC[2] = dC[1]; + dC[1] = inputSample; + inputSample = (dC[1] + dC[2])/2.0; + + allpasstemp = alpD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= aD[allpasstemp]*constallpass; + aD[alpD] = inputSample; + inputSample *= constallpass; + alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;} + inputSample += (aD[alpD]); + //allpass filter D + + dD[2] = dD[1]; + dD[1] = inputSample; + inputSample = (dD[1] + dD[2])/2.0; + + allpasstemp = alpE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= aE[allpasstemp]*constallpass; + aE[alpE] = inputSample; + inputSample *= constallpass; + alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;} + inputSample += (aE[alpE]); + //allpass filter E + + dE[2] = dE[1]; + dE[1] = inputSample; + inputSample = (dE[1] + dE[2])/2.0; + + allpasstemp = alpF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= aF[allpasstemp]*constallpass; + aF[alpF] = inputSample; + inputSample *= constallpass; + alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;} + inputSample += (aF[alpF]); + //allpass filter F + + dF[2] = dF[1]; + dF[1] = inputSample; + inputSample = (dF[1] + dF[2])/2.0; + + allpasstemp = alpG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= aG[allpasstemp]*constallpass; + aG[alpG] = inputSample; + inputSample *= constallpass; + alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;} + inputSample += (aG[alpG]); + //allpass filter G + + dG[2] = dG[1]; + dG[1] = inputSample; + inputSample = (dG[1] + dG[2])/2.0; + + allpasstemp = alpH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= aH[allpasstemp]*constallpass; + aH[alpH] = inputSample; + inputSample *= constallpass; + alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;} + inputSample += (aH[alpH]); + //allpass filter H + + dH[2] = dH[1]; + dH[1] = inputSample; + inputSample = (dH[1] + dH[2])/2.0; + + allpasstemp = alpI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= aI[allpasstemp]*constallpass; + aI[alpI] = inputSample; + inputSample *= constallpass; + alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;} + inputSample += (aI[alpI]); + //allpass filter I + + dI[2] = dI[1]; + dI[1] = inputSample; + inputSample = (dI[1] + dI[2])/2.0; + + allpasstemp = alpJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= aJ[allpasstemp]*constallpass; + aJ[alpJ] = inputSample; + inputSample *= constallpass; + alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;} + inputSample += (aJ[alpJ]); + //allpass filter J + + dJ[2] = dJ[1]; + dJ[1] = inputSample; + inputSample = (dJ[1] + dJ[2])/2.0; + + allpasstemp = alpK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= aK[allpasstemp]*constallpass; + aK[alpK] = inputSample; + inputSample *= constallpass; + alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;} + inputSample += (aK[alpK]); + //allpass filter K + + dK[2] = dK[1]; + dK[1] = inputSample; + inputSample = (dK[1] + dK[2])/2.0; + + allpasstemp = alpL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= aL[allpasstemp]*constallpass; + aL[alpL] = inputSample; + inputSample *= constallpass; + alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;} + inputSample += (aL[alpL]); + //allpass filter L + + dL[2] = dL[1]; + dL[1] = inputSample; + inputSample = (dL[1] + dL[2])/2.0; + + allpasstemp = alpM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= aM[allpasstemp]*constallpass; + aM[alpM] = inputSample; + inputSample *= constallpass; + alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;} + inputSample += (aM[alpM]); + //allpass filter M + + dM[2] = dM[1]; + dM[1] = inputSample; + inputSample = (dM[1] + dM[2])/2.0; + + allpasstemp = alpN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= aN[allpasstemp]*constallpass; + aN[alpN] = inputSample; + inputSample *= constallpass; + alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;} + inputSample += (aN[alpN]); + //allpass filter N + + dN[2] = dN[1]; + dN[1] = inputSample; + inputSample = (dN[1] + dN[2])/2.0; + + allpasstemp = alpO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= aO[allpasstemp]*constallpass; + aO[alpO] = inputSample; + inputSample *= constallpass; + alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;} + inputSample += (aO[alpO]); + //allpass filter O + + dO[2] = dO[1]; + dO[1] = inputSample; + inputSample = (dO[1] + dO[2])/2.0; + + allpasstemp = alpP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= aP[allpasstemp]*constallpass; + aP[alpP] = inputSample; + inputSample *= constallpass; + alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;} + inputSample += (aP[alpP]); + //allpass filter P + + dP[2] = dP[1]; + dP[1] = inputSample; + inputSample = (dP[1] + dP[2])/2.0; + + allpasstemp = alpQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= aQ[allpasstemp]*constallpass; + aQ[alpQ] = inputSample; + inputSample *= constallpass; + alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;} + inputSample += (aQ[alpQ]); + //allpass filter Q + + dQ[2] = dQ[1]; + dQ[1] = inputSample; + inputSample = (dQ[1] + dQ[2])/2.0; + + allpasstemp = alpR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= aR[allpasstemp]*constallpass; + aR[alpR] = inputSample; + inputSample *= constallpass; + alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;} + inputSample += (aR[alpR]); + //allpass filter R + + dR[2] = dR[1]; + dR[1] = inputSample; + inputSample = (dR[1] + dR[2])/2.0; + + allpasstemp = alpS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= aS[allpasstemp]*constallpass; + aS[alpS] = inputSample; + inputSample *= constallpass; + alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;} + inputSample += (aS[alpS]); + //allpass filter S + + dS[2] = dS[1]; + dS[1] = inputSample; + inputSample = (dS[1] + dS[2])/2.0; + + allpasstemp = alpT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= aT[allpasstemp]*constallpass; + aT[alpT] = inputSample; + inputSample *= constallpass; + alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;} + inputSample += (aT[alpT]); + //allpass filter T + + dT[2] = dT[1]; + dT[1] = inputSample; + inputSample = (dT[1] + dT[2])/2.0; + + allpasstemp = alpU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= aU[allpasstemp]*constallpass; + aU[alpU] = inputSample; + inputSample *= constallpass; + alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;} + inputSample += (aU[alpU]); + //allpass filter U + + dU[2] = dU[1]; + dU[1] = inputSample; + inputSample = (dU[1] + dU[2])/2.0; + + allpasstemp = alpV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= aV[allpasstemp]*constallpass; + aV[alpV] = inputSample; + inputSample *= constallpass; + alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;} + inputSample += (aV[alpV]); + //allpass filter V + + dV[2] = dV[1]; + dV[1] = inputSample; + inputSample = (dV[1] + dV[2])/2.0; + + allpasstemp = alpW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= aW[allpasstemp]*constallpass; + aW[alpW] = inputSample; + inputSample *= constallpass; + alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;} + inputSample += (aW[alpW]); + //allpass filter W + + dW[2] = dW[1]; + dW[1] = inputSample; + inputSample = (dW[1] + dW[2])/2.0; + + allpasstemp = alpX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= aX[allpasstemp]*constallpass; + aX[alpX] = inputSample; + inputSample *= constallpass; + alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;} + inputSample += (aX[alpX]); + //allpass filter X + + dX[2] = dX[1]; + dX[1] = inputSample; + inputSample = (dX[1] + dX[2])/2.0; + + allpasstemp = alpY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= aY[allpasstemp]*constallpass; + aY[alpY] = inputSample; + inputSample *= constallpass; + alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;} + inputSample += (aY[alpY]); + //allpass filter Y + + dY[2] = dY[1]; + dY[1] = inputSample; + inputSample = (dY[1] + dY[2])/2.0; + + allpasstemp = alpZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= aZ[allpasstemp]*constallpass; + aZ[alpZ] = inputSample; + inputSample *= constallpass; + alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;} + inputSample += (aZ[alpZ]); + //allpass filter Z + + dZ[2] = dZ[1]; + dZ[1] = inputSample; + inputSample = (dZ[1] + dZ[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= oA[allpasstemp]*constallpass; + oA[outA] = inputSample; + inputSample *= constallpass; + outA--; if (outA < 0 || outA > delayA) {outA = delayA;} + inputSample += (oA[outA]); + //allpass filter A + + dA[5] = dA[4]; + dA[4] = inputSample; + inputSample = (dA[4] + dA[5])/2.0; + + allpasstemp = outB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= oB[allpasstemp]*constallpass; + oB[outB] = inputSample; + inputSample *= constallpass; + outB--; if (outB < 0 || outB > delayB) {outB = delayB;} + inputSample += (oB[outB]); + //allpass filter B + + dB[5] = dB[4]; + dB[4] = inputSample; + inputSample = (dB[4] + dB[5])/2.0; + + allpasstemp = outC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= oC[allpasstemp]*constallpass; + oC[outC] = inputSample; + inputSample *= constallpass; + outC--; if (outC < 0 || outC > delayC) {outC = delayC;} + inputSample += (oC[outC]); + //allpass filter C + + dC[5] = dC[4]; + dC[4] = inputSample; + inputSample = (dC[4] + dC[5])/2.0; + + allpasstemp = outD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= oD[allpasstemp]*constallpass; + oD[outD] = inputSample; + inputSample *= constallpass; + outD--; if (outD < 0 || outD > delayD) {outD = delayD;} + inputSample += (oD[outD]); + //allpass filter D + + dD[5] = dD[4]; + dD[4] = inputSample; + inputSample = (dD[4] + dD[5])/2.0; + + allpasstemp = outE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= oE[allpasstemp]*constallpass; + oE[outE] = inputSample; + inputSample *= constallpass; + outE--; if (outE < 0 || outE > delayE) {outE = delayE;} + inputSample += (oE[outE]); + //allpass filter E + + dE[5] = dE[4]; + dE[4] = inputSample; + inputSample = (dE[4] + dE[5])/2.0; + + allpasstemp = outF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= oF[allpasstemp]*constallpass; + oF[outF] = inputSample; + inputSample *= constallpass; + outF--; if (outF < 0 || outF > delayF) {outF = delayF;} + inputSample += (oF[outF]); + //allpass filter F + + dF[5] = dF[4]; + dF[4] = inputSample; + inputSample = (dF[4] + dF[5])/2.0; + + allpasstemp = outG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= oG[allpasstemp]*constallpass; + oG[outG] = inputSample; + inputSample *= constallpass; + outG--; if (outG < 0 || outG > delayG) {outG = delayG;} + inputSample += (oG[outG]); + //allpass filter G + + dG[5] = dG[4]; + dG[4] = inputSample; + inputSample = (dG[4] + dG[5])/2.0; + + allpasstemp = outH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= oH[allpasstemp]*constallpass; + oH[outH] = inputSample; + inputSample *= constallpass; + outH--; if (outH < 0 || outH > delayH) {outH = delayH;} + inputSample += (oH[outH]); + //allpass filter H + + dH[5] = dH[4]; + dH[4] = inputSample; + inputSample = (dH[4] + dH[5])/2.0; + + allpasstemp = outI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= oI[allpasstemp]*constallpass; + oI[outI] = inputSample; + inputSample *= constallpass; + outI--; if (outI < 0 || outI > delayI) {outI = delayI;} + inputSample += (oI[outI]); + //allpass filter I + + dI[5] = dI[4]; + dI[4] = inputSample; + inputSample = (dI[4] + dI[5])/2.0; + + allpasstemp = outJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= oJ[allpasstemp]*constallpass; + oJ[outJ] = inputSample; + inputSample *= constallpass; + outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;} + inputSample += (oJ[outJ]); + //allpass filter J + + dJ[5] = dJ[4]; + dJ[4] = inputSample; + inputSample = (dJ[4] + dJ[5])/2.0; + + allpasstemp = outK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= oK[allpasstemp]*constallpass; + oK[outK] = inputSample; + inputSample *= constallpass; + outK--; if (outK < 0 || outK > delayK) {outK = delayK;} + inputSample += (oK[outK]); + //allpass filter K + + dK[5] = dK[4]; + dK[4] = inputSample; + inputSample = (dK[4] + dK[5])/2.0; + + allpasstemp = outL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= oL[allpasstemp]*constallpass; + oL[outL] = inputSample; + inputSample *= constallpass; + outL--; if (outL < 0 || outL > delayL) {outL = delayL;} + inputSample += (oL[outL]); + //allpass filter L + + dL[5] = dL[4]; + dL[4] = inputSample; + inputSample = (dL[4] + dL[5])/2.0; + + allpasstemp = outM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= oM[allpasstemp]*constallpass; + oM[outM] = inputSample; + inputSample *= constallpass; + outM--; if (outM < 0 || outM > delayM) {outM = delayM;} + inputSample += (oM[outM]); + //allpass filter M + + dM[5] = dM[4]; + dM[4] = inputSample; + inputSample = (dM[4] + dM[5])/2.0; + + allpasstemp = outN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= oN[allpasstemp]*constallpass; + oN[outN] = inputSample; + inputSample *= constallpass; + outN--; if (outN < 0 || outN > delayN) {outN = delayN;} + inputSample += (oN[outN]); + //allpass filter N + + dN[5] = dN[4]; + dN[4] = inputSample; + inputSample = (dN[4] + dN[5])/2.0; + + allpasstemp = outO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= oO[allpasstemp]*constallpass; + oO[outO] = inputSample; + inputSample *= constallpass; + outO--; if (outO < 0 || outO > delayO) {outO = delayO;} + inputSample += (oO[outO]); + //allpass filter O + + dO[5] = dO[4]; + dO[4] = inputSample; + inputSample = (dO[4] + dO[5])/2.0; + + allpasstemp = outP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= oP[allpasstemp]*constallpass; + oP[outP] = inputSample; + inputSample *= constallpass; + outP--; if (outP < 0 || outP > delayP) {outP = delayP;} + inputSample += (oP[outP]); + //allpass filter P + + dP[5] = dP[4]; + dP[4] = inputSample; + inputSample = (dP[4] + dP[5])/2.0; + + allpasstemp = outQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= oQ[allpasstemp]*constallpass; + oQ[outQ] = inputSample; + inputSample *= constallpass; + outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;} + inputSample += (oQ[outQ]); + //allpass filter Q + + dQ[5] = dQ[4]; + dQ[4] = inputSample; + inputSample = (dQ[4] + dQ[5])/2.0; + + allpasstemp = outR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= oR[allpasstemp]*constallpass; + oR[outR] = inputSample; + inputSample *= constallpass; + outR--; if (outR < 0 || outR > delayR) {outR = delayR;} + inputSample += (oR[outR]); + //allpass filter R + + dR[5] = dR[4]; + dR[4] = inputSample; + inputSample = (dR[4] + dR[5])/2.0; + + allpasstemp = outS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= oS[allpasstemp]*constallpass; + oS[outS] = inputSample; + inputSample *= constallpass; + outS--; if (outS < 0 || outS > delayS) {outS = delayS;} + inputSample += (oS[outS]); + //allpass filter S + + dS[5] = dS[4]; + dS[4] = inputSample; + inputSample = (dS[4] + dS[5])/2.0; + + allpasstemp = outT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= oT[allpasstemp]*constallpass; + oT[outT] = inputSample; + inputSample *= constallpass; + outT--; if (outT < 0 || outT > delayT) {outT = delayT;} + inputSample += (oT[outT]); + //allpass filter T + + dT[5] = dT[4]; + dT[4] = inputSample; + inputSample = (dT[4] + dT[5])/2.0; + + allpasstemp = outU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= oU[allpasstemp]*constallpass; + oU[outU] = inputSample; + inputSample *= constallpass; + outU--; if (outU < 0 || outU > delayU) {outU = delayU;} + inputSample += (oU[outU]); + //allpass filter U + + dU[5] = dU[4]; + dU[4] = inputSample; + inputSample = (dU[4] + dU[5])/2.0; + + allpasstemp = outV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= oV[allpasstemp]*constallpass; + oV[outV] = inputSample; + inputSample *= constallpass; + outV--; if (outV < 0 || outV > delayV) {outV = delayV;} + inputSample += (oV[outV]); + //allpass filter V + + dV[5] = dV[4]; + dV[4] = inputSample; + inputSample = (dV[4] + dV[5])/2.0; + + allpasstemp = outW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= oW[allpasstemp]*constallpass; + oW[outW] = inputSample; + inputSample *= constallpass; + outW--; if (outW < 0 || outW > delayW) {outW = delayW;} + inputSample += (oW[outW]); + //allpass filter W + + dW[5] = dW[4]; + dW[4] = inputSample; + inputSample = (dW[4] + dW[5])/2.0; + + allpasstemp = outX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= oX[allpasstemp]*constallpass; + oX[outX] = inputSample; + inputSample *= constallpass; + outX--; if (outX < 0 || outX > delayX) {outX = delayX;} + inputSample += (oX[outX]); + //allpass filter X + + dX[5] = dX[4]; + dX[4] = inputSample; + inputSample = (dX[4] + dX[5])/2.0; + + allpasstemp = outY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= oY[allpasstemp]*constallpass; + oY[outY] = inputSample; + inputSample *= constallpass; + outY--; if (outY < 0 || outY > delayY) {outY = delayY;} + inputSample += (oY[outY]); + //allpass filter Y + + dY[5] = dY[4]; + dY[4] = inputSample; + inputSample = (dY[4] + dY[5])/2.0; + + allpasstemp = outZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= oZ[allpasstemp]*constallpass; + oZ[outZ] = inputSample; + inputSample *= constallpass; + outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;} + inputSample += (oZ[outZ]); + //allpass filter Z + + dZ[5] = dZ[4]; + dZ[4] = inputSample; + inputSample = (dZ[4] + dZ[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + +case 6: //Zarathustra + allpasstemp = alpA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= aA[allpasstemp]*constallpass; + aA[alpA] = inputSample; + inputSample *= constallpass; + alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;} + inputSample += (aA[alpA]); + //allpass filter A + + dA[3] = dA[2]; + dA[2] = dA[1]; + dA[1] = inputSample; + inputSample = (dA[1] + dA[2] + dZ[3])/3.0; //add feedback + + allpasstemp = alpB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= aB[allpasstemp]*constallpass; + aB[alpB] = inputSample; + inputSample *= constallpass; + alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;} + inputSample += (aB[alpB]); + //allpass filter B + + dB[3] = dB[2]; + dB[2] = dB[1]; + dB[1] = inputSample; + inputSample = (dB[1] + dB[2] + dB[3])/3.0; + + allpasstemp = alpC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= aC[allpasstemp]*constallpass; + aC[alpC] = inputSample; + inputSample *= constallpass; + alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;} + inputSample += (aC[alpC]); + //allpass filter C + + dC[3] = dC[2]; + dC[2] = dC[1]; + dC[1] = inputSample; + inputSample = (dC[1] + dC[2] + dC[3])/3.0; + + allpasstemp = alpD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= aD[allpasstemp]*constallpass; + aD[alpD] = inputSample; + inputSample *= constallpass; + alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;} + inputSample += (aD[alpD]); + //allpass filter D + + dD[3] = dD[2]; + dD[2] = dD[1]; + dD[1] = inputSample; + inputSample = (dD[1] + dD[2] + dD[3])/3.0; + + allpasstemp = alpE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= aE[allpasstemp]*constallpass; + aE[alpE] = inputSample; + inputSample *= constallpass; + alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;} + inputSample += (aE[alpE]); + //allpass filter E + + dE[3] = dE[2]; + dE[2] = dE[1]; + dE[1] = inputSample; + inputSample = (dE[1] + dE[2] + dE[3])/3.0; + + allpasstemp = alpF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= aF[allpasstemp]*constallpass; + aF[alpF] = inputSample; + inputSample *= constallpass; + alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;} + inputSample += (aF[alpF]); + //allpass filter F + + dF[3] = dF[2]; + dF[2] = dF[1]; + dF[1] = inputSample; + inputSample = (dF[1] + dF[2] + dF[3])/3.0; + + allpasstemp = alpG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= aG[allpasstemp]*constallpass; + aG[alpG] = inputSample; + inputSample *= constallpass; + alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;} + inputSample += (aG[alpG]); + //allpass filter G + + dG[3] = dG[2]; + dG[2] = dG[1]; + dG[1] = inputSample; + inputSample = (dG[1] + dG[2] + dG[3])/3.0; + + allpasstemp = alpH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= aH[allpasstemp]*constallpass; + aH[alpH] = inputSample; + inputSample *= constallpass; + alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;} + inputSample += (aH[alpH]); + //allpass filter H + + dH[3] = dH[2]; + dH[2] = dH[1]; + dH[1] = inputSample; + inputSample = (dH[1] + dH[2] + dH[3])/3.0; + + allpasstemp = alpI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= aI[allpasstemp]*constallpass; + aI[alpI] = inputSample; + inputSample *= constallpass; + alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;} + inputSample += (aI[alpI]); + //allpass filter I + + dI[3] = dI[2]; + dI[2] = dI[1]; + dI[1] = inputSample; + inputSample = (dI[1] + dI[2] + dI[3])/3.0; + + allpasstemp = alpJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= aJ[allpasstemp]*constallpass; + aJ[alpJ] = inputSample; + inputSample *= constallpass; + alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;} + inputSample += (aJ[alpJ]); + //allpass filter J + + dJ[3] = dJ[2]; + dJ[2] = dJ[1]; + dJ[1] = inputSample; + inputSample = (dJ[1] + dJ[2] + dJ[3])/3.0; + + allpasstemp = alpK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= aK[allpasstemp]*constallpass; + aK[alpK] = inputSample; + inputSample *= constallpass; + alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;} + inputSample += (aK[alpK]); + //allpass filter K + + dK[3] = dK[2]; + dK[2] = dK[1]; + dK[1] = inputSample; + inputSample = (dK[1] + dK[2] + dK[3])/3.0; + + allpasstemp = alpL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= aL[allpasstemp]*constallpass; + aL[alpL] = inputSample; + inputSample *= constallpass; + alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;} + inputSample += (aL[alpL]); + //allpass filter L + + dL[3] = dL[2]; + dL[2] = dL[1]; + dL[1] = inputSample; + inputSample = (dL[1] + dL[2] + dL[3])/3.0; + + allpasstemp = alpM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= aM[allpasstemp]*constallpass; + aM[alpM] = inputSample; + inputSample *= constallpass; + alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;} + inputSample += (aM[alpM]); + //allpass filter M + + dM[3] = dM[2]; + dM[2] = dM[1]; + dM[1] = inputSample; + inputSample = (dM[1] + dM[2] + dM[3])/3.0; + + allpasstemp = alpN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= aN[allpasstemp]*constallpass; + aN[alpN] = inputSample; + inputSample *= constallpass; + alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;} + inputSample += (aN[alpN]); + //allpass filter N + + dN[3] = dN[2]; + dN[2] = dN[1]; + dN[1] = inputSample; + inputSample = (dN[1] + dN[2] + dN[3])/3.0; + + allpasstemp = alpO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= aO[allpasstemp]*constallpass; + aO[alpO] = inputSample; + inputSample *= constallpass; + alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;} + inputSample += (aO[alpO]); + //allpass filter O + + dO[3] = dO[2]; + dO[2] = dO[1]; + dO[1] = inputSample; + inputSample = (dO[1] + dO[2] + dO[3])/3.0; + + allpasstemp = alpP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= aP[allpasstemp]*constallpass; + aP[alpP] = inputSample; + inputSample *= constallpass; + alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;} + inputSample += (aP[alpP]); + //allpass filter P + + dP[3] = dP[2]; + dP[2] = dP[1]; + dP[1] = inputSample; + inputSample = (dP[1] + dP[2] + dP[3])/3.0; + + allpasstemp = alpQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= aQ[allpasstemp]*constallpass; + aQ[alpQ] = inputSample; + inputSample *= constallpass; + alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;} + inputSample += (aQ[alpQ]); + //allpass filter Q + + dQ[3] = dQ[2]; + dQ[2] = dQ[1]; + dQ[1] = inputSample; + inputSample = (dQ[1] + dQ[2] + dQ[3])/3.0; + + allpasstemp = alpR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= aR[allpasstemp]*constallpass; + aR[alpR] = inputSample; + inputSample *= constallpass; + alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;} + inputSample += (aR[alpR]); + //allpass filter R + + dR[3] = dR[2]; + dR[2] = dR[1]; + dR[1] = inputSample; + inputSample = (dR[1] + dR[2] + dR[3])/3.0; + + allpasstemp = alpS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= aS[allpasstemp]*constallpass; + aS[alpS] = inputSample; + inputSample *= constallpass; + alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;} + inputSample += (aS[alpS]); + //allpass filter S + + dS[3] = dS[2]; + dS[2] = dS[1]; + dS[1] = inputSample; + inputSample = (dS[1] + dS[2] + dS[3])/3.0; + + allpasstemp = alpT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= aT[allpasstemp]*constallpass; + aT[alpT] = inputSample; + inputSample *= constallpass; + alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;} + inputSample += (aT[alpT]); + //allpass filter T + + dT[3] = dT[2]; + dT[2] = dT[1]; + dT[1] = inputSample; + inputSample = (dT[1] + dT[2] + dT[3])/3.0; + + allpasstemp = alpU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= aU[allpasstemp]*constallpass; + aU[alpU] = inputSample; + inputSample *= constallpass; + alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;} + inputSample += (aU[alpU]); + //allpass filter U + + dU[3] = dU[2]; + dU[2] = dU[1]; + dU[1] = inputSample; + inputSample = (dU[1] + dU[2] + dU[3])/3.0; + + allpasstemp = alpV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= aV[allpasstemp]*constallpass; + aV[alpV] = inputSample; + inputSample *= constallpass; + alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;} + inputSample += (aV[alpV]); + //allpass filter V + + dV[3] = dV[2]; + dV[2] = dV[1]; + dV[1] = inputSample; + inputSample = (dV[1] + dV[2] + dV[3])/3.0; + + allpasstemp = alpW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= aW[allpasstemp]*constallpass; + aW[alpW] = inputSample; + inputSample *= constallpass; + alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;} + inputSample += (aW[alpW]); + //allpass filter W + + dW[3] = dW[2]; + dW[2] = dW[1]; + dW[1] = inputSample; + inputSample = (dW[1] + dW[2] + dW[3])/3.0; + + allpasstemp = alpX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= aX[allpasstemp]*constallpass; + aX[alpX] = inputSample; + inputSample *= constallpass; + alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;} + inputSample += (aX[alpX]); + //allpass filter X + + dX[3] = dX[2]; + dX[2] = dX[1]; + dX[1] = inputSample; + inputSample = (dX[1] + dX[2] + dX[3])/3.0; + + allpasstemp = alpY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= aY[allpasstemp]*constallpass; + aY[alpY] = inputSample; + inputSample *= constallpass; + alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;} + inputSample += (aY[alpY]); + //allpass filter Y + + dY[3] = dY[2]; + dY[2] = dY[1]; + dY[1] = inputSample; + inputSample = (dY[1] + dY[2] + dY[3])/3.0; + + allpasstemp = alpZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= aZ[allpasstemp]*constallpass; + aZ[alpZ] = inputSample; + inputSample *= constallpass; + alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;} + inputSample += (aZ[alpZ]); + //allpass filter Z + + dZ[3] = dZ[2]; + dZ[2] = dZ[1]; + dZ[1] = inputSample; + inputSample = (dZ[1] + dZ[2] + dZ[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outA - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSample -= oA[allpasstemp]*constallpass; + oA[outA] = inputSample; + inputSample *= constallpass; + outA--; if (outA < 0 || outA > delayA) {outA = delayA;} + inputSample += (oA[outA]); + //allpass filter A + + dA[6] = dA[5]; + dA[5] = dA[4]; + dA[4] = inputSample; + inputSample = (dC[1] + dA[5] + dA[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outB - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSample -= oB[allpasstemp]*constallpass; + oB[outB] = inputSample; + inputSample *= constallpass; + outB--; if (outB < 0 || outB > delayB) {outB = delayB;} + inputSample += (oB[outB]); + //allpass filter B + + dB[6] = dB[5]; + dB[5] = dB[4]; + dB[4] = inputSample; + inputSample = (dB[4] + dB[5] + dB[6])/3.0; + + allpasstemp = outC - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSample -= oC[allpasstemp]*constallpass; + oC[outC] = inputSample; + inputSample *= constallpass; + outC--; if (outC < 0 || outC > delayC) {outC = delayC;} + inputSample += (oC[outC]); + //allpass filter C + + dC[6] = dC[5]; + dC[5] = dC[4]; + dC[4] = inputSample; + inputSample = (dC[4] + dC[5] + dC[6])/3.0; + + allpasstemp = outD - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSample -= oD[allpasstemp]*constallpass; + oD[outD] = inputSample; + inputSample *= constallpass; + outD--; if (outD < 0 || outD > delayD) {outD = delayD;} + inputSample += (oD[outD]); + //allpass filter D + + dD[6] = dD[5]; + dD[5] = dD[4]; + dD[4] = inputSample; + inputSample = (dD[4] + dD[5] + dD[6])/3.0; + + allpasstemp = outE - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSample -= oE[allpasstemp]*constallpass; + oE[outE] = inputSample; + inputSample *= constallpass; + outE--; if (outE < 0 || outE > delayE) {outE = delayE;} + inputSample += (oE[outE]); + //allpass filter E + + dE[6] = dE[5]; + dE[5] = dE[4]; + dE[4] = inputSample; + inputSample = (dE[4] + dE[5] + dE[6])/3.0; + + allpasstemp = outF - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSample -= oF[allpasstemp]*constallpass; + oF[outF] = inputSample; + inputSample *= constallpass; + outF--; if (outF < 0 || outF > delayF) {outF = delayF;} + inputSample += (oF[outF]); + //allpass filter F + + dF[6] = dF[5]; + dF[5] = dF[4]; + dF[4] = inputSample; + inputSample = (dF[4] + dF[5] + dF[6])/3.0; + + allpasstemp = outG - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSample -= oG[allpasstemp]*constallpass; + oG[outG] = inputSample; + inputSample *= constallpass; + outG--; if (outG < 0 || outG > delayG) {outG = delayG;} + inputSample += (oG[outG]); + //allpass filter G + + dG[6] = dG[5]; + dG[5] = dG[4]; + dG[4] = inputSample; + inputSample = (dG[4] + dG[5] + dG[6])/3.0; + + allpasstemp = outH - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSample -= oH[allpasstemp]*constallpass; + oH[outH] = inputSample; + inputSample *= constallpass; + outH--; if (outH < 0 || outH > delayH) {outH = delayH;} + inputSample += (oH[outH]); + //allpass filter H + + dH[6] = dH[5]; + dH[5] = dH[4]; + dH[4] = inputSample; + inputSample = (dH[4] + dH[5] + dH[6])/3.0; + + allpasstemp = outI - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSample -= oI[allpasstemp]*constallpass; + oI[outI] = inputSample; + inputSample *= constallpass; + outI--; if (outI < 0 || outI > delayI) {outI = delayI;} + inputSample += (oI[outI]); + //allpass filter I + + dI[6] = dI[5]; + dI[5] = dI[4]; + dI[4] = inputSample; + inputSample = (dI[4] + dI[5] + dI[6])/3.0; + + allpasstemp = outJ - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSample -= oJ[allpasstemp]*constallpass; + oJ[outJ] = inputSample; + inputSample *= constallpass; + outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;} + inputSample += (oJ[outJ]); + //allpass filter J + + dJ[6] = dJ[5]; + dJ[5] = dJ[4]; + dJ[4] = inputSample; + inputSample = (dJ[4] + dJ[5] + dJ[6])/3.0; + + allpasstemp = outK - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSample -= oK[allpasstemp]*constallpass; + oK[outK] = inputSample; + inputSample *= constallpass; + outK--; if (outK < 0 || outK > delayK) {outK = delayK;} + inputSample += (oK[outK]); + //allpass filter K + + dK[6] = dK[5]; + dK[5] = dK[4]; + dK[4] = inputSample; + inputSample = (dK[4] + dK[5] + dK[6])/3.0; + + allpasstemp = outL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSample -= oL[allpasstemp]*constallpass; + oL[outL] = inputSample; + inputSample *= constallpass; + outL--; if (outL < 0 || outL > delayL) {outL = delayL;} + inputSample += (oL[outL]); + //allpass filter L + + dL[6] = dL[5]; + dL[5] = dL[4]; + dL[4] = inputSample; + inputSample = (dL[4] + dL[5] + dL[6])/3.0; + + allpasstemp = outM - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSample -= oM[allpasstemp]*constallpass; + oM[outM] = inputSample; + inputSample *= constallpass; + outM--; if (outM < 0 || outM > delayM) {outM = delayM;} + inputSample += (oM[outM]); + //allpass filter M + + dM[6] = dM[5]; + dM[5] = dM[4]; + dM[4] = inputSample; + inputSample = (dM[4] + dM[5] + dM[6])/3.0; + + allpasstemp = outN - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSample -= oN[allpasstemp]*constallpass; + oN[outN] = inputSample; + inputSample *= constallpass; + outN--; if (outN < 0 || outN > delayN) {outN = delayN;} + inputSample += (oN[outN]); + //allpass filter N + + dN[6] = dN[5]; + dN[5] = dN[4]; + dN[4] = inputSample; + inputSample = (dN[4] + dN[5] + dN[6])/3.0; + + allpasstemp = outO - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSample -= oO[allpasstemp]*constallpass; + oO[outO] = inputSample; + inputSample *= constallpass; + outO--; if (outO < 0 || outO > delayO) {outO = delayO;} + inputSample += (oO[outO]); + //allpass filter O + + dO[6] = dO[5]; + dO[5] = dO[4]; + dO[4] = inputSample; + inputSample = (dO[4] + dO[5] + dO[6])/3.0; + + allpasstemp = outP - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSample -= oP[allpasstemp]*constallpass; + oP[outP] = inputSample; + inputSample *= constallpass; + outP--; if (outP < 0 || outP > delayP) {outP = delayP;} + inputSample += (oP[outP]); + //allpass filter P + + dP[6] = dP[5]; + dP[5] = dP[4]; + dP[4] = inputSample; + inputSample = (dP[4] + dP[5] + dP[6])/3.0; + + allpasstemp = outQ - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSample -= oQ[allpasstemp]*constallpass; + oQ[outQ] = inputSample; + inputSample *= constallpass; + outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;} + inputSample += (oQ[outQ]); + //allpass filter Q + + dQ[6] = dQ[5]; + dQ[5] = dQ[4]; + dQ[4] = inputSample; + inputSample = (dQ[4] + dQ[5] + dQ[6])/3.0; + + allpasstemp = outR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSample -= oR[allpasstemp]*constallpass; + oR[outR] = inputSample; + inputSample *= constallpass; + outR--; if (outR < 0 || outR > delayR) {outR = delayR;} + inputSample += (oR[outR]); + //allpass filter R + + dR[6] = dR[5]; + dR[5] = dR[4]; + dR[4] = inputSample; + inputSample = (dR[4] + dR[5] + dR[6])/3.0; + + allpasstemp = outS - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSample -= oS[allpasstemp]*constallpass; + oS[outS] = inputSample; + inputSample *= constallpass; + outS--; if (outS < 0 || outS > delayS) {outS = delayS;} + inputSample += (oS[outS]); + //allpass filter S + + dS[6] = dS[5]; + dS[5] = dS[4]; + dS[4] = inputSample; + inputSample = (dS[4] + dS[5] + dS[6])/3.0; + + allpasstemp = outT - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSample -= oT[allpasstemp]*constallpass; + oT[outT] = inputSample; + inputSample *= constallpass; + outT--; if (outT < 0 || outT > delayT) {outT = delayT;} + inputSample += (oT[outT]); + //allpass filter T + + dT[6] = dT[5]; + dT[5] = dT[4]; + dT[4] = inputSample; + inputSample = (dT[4] + dT[5] + dT[6])/3.0; + + allpasstemp = outU - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSample -= oU[allpasstemp]*constallpass; + oU[outU] = inputSample; + inputSample *= constallpass; + outU--; if (outU < 0 || outU > delayU) {outU = delayU;} + inputSample += (oU[outU]); + //allpass filter U + + dU[6] = dU[5]; + dU[5] = dU[4]; + dU[4] = inputSample; + inputSample = (dU[4] + dU[5] + dU[6])/3.0; + + allpasstemp = outV - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSample -= oV[allpasstemp]*constallpass; + oV[outV] = inputSample; + inputSample *= constallpass; + outV--; if (outV < 0 || outV > delayV) {outV = delayV;} + inputSample += (oV[outV]); + //allpass filter V + + dV[6] = dV[5]; + dV[5] = dV[4]; + dV[4] = inputSample; + inputSample = (dV[4] + dV[5] + dV[6])/3.0; + + allpasstemp = outW - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSample -= oW[allpasstemp]*constallpass; + oW[outW] = inputSample; + inputSample *= constallpass; + outW--; if (outW < 0 || outW > delayW) {outW = delayW;} + inputSample += (oW[outW]); + //allpass filter W + + dW[6] = dW[5]; + dW[5] = dW[4]; + dW[4] = inputSample; + inputSample = (dW[4] + dW[5] + dW[6])/3.0; + + allpasstemp = outX - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSample -= oX[allpasstemp]*constallpass; + oX[outX] = inputSample; + inputSample *= constallpass; + outX--; if (outX < 0 || outX > delayX) {outX = delayX;} + inputSample += (oX[outX]); + //allpass filter X + + dX[6] = dX[5]; + dX[5] = dX[4]; + dX[4] = inputSample; + inputSample = (dX[4] + dX[5] + dX[6])/3.0; + + allpasstemp = outY - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSample -= oY[allpasstemp]*constallpass; + oY[outY] = inputSample; + inputSample *= constallpass; + outY--; if (outY < 0 || outY > delayY) {outY = delayY;} + inputSample += (oY[outY]); + //allpass filter Y + + dY[6] = dY[5]; + dY[5] = dY[4]; + dY[4] = inputSample; + inputSample = (dY[4] + dY[5] + dY[6])/3.0; + + allpasstemp = outZ - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSample -= oZ[allpasstemp]*constallpass; + oZ[outZ] = inputSample; + inputSample *= constallpass; + outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;} + inputSample += (oZ[outZ]); + //allpass filter Z + + dZ[6] = dZ[5]; + dZ[5] = dZ[4]; + dZ[4] = inputSample; + inputSample = (dZ[4] + dZ[5] + dZ[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + + + bridgerectifier = fabs(inputSample); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSample > 0) inputSample -= bridgerectifier; + else inputSample += bridgerectifier; + inputSample /= gain; + //here we apply the ADT2 'console on steroids' trick + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peak; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySample *= (1.0-wetness); + inputSample *= wetness; + inputSample += drySample; + //here we combine the tanks with the dry signal + + + //begin 32 bit floating point dither + int expon; frexpf((float)inputSample, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSample += static_cast(fpd) * 5.960464655174751e-36L * pow(2,expon+62); + //end 32 bit floating point dither + + *destP = inputSample; + sourceP += inNumChannels; destP += inNumChannels; + } +} + diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.exp b/plugins/MacAU/PocketVerbs/PocketVerbs.exp new file mode 100755 index 0000000..41b0949 --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbs.exp @@ -0,0 +1 @@ +_PocketVerbsEntry diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.h b/plugins/MacAU/PocketVerbs/PocketVerbs.h new file mode 100755 index 0000000..c713f82 --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbs.h @@ -0,0 +1,271 @@ +/* +* File: PocketVerbs.h +* +* Version: 1.0 +* +* Created: 8/19/12 +* +* Copyright: Copyright © 2012 Airwindows, All Rights Reserved +* +* Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in +* consideration of your agreement to the following terms, and your use, installation, modification +* or redistribution of this Apple software constitutes acceptance of these terms. If you do +* not agree with these terms, please do not use, install, modify or redistribute this Apple +* software. +* +* In consideration of your agreement to abide by the following terms, and subject to these terms, +* Apple grants you a personal, non-exclusive license, under Apple's copyrights in this +* original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the +* Apple Software, with or without modifications, in source and/or binary forms; provided that if you +* redistribute the Apple Software in its entirety and without modifications, you must retain this +* notice and the following text and disclaimers in all such redistributions of the Apple Software. +* Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to +* endorse or promote products derived from the Apple Software without specific prior written +* permission from Apple. Except as expressly stated in this notice, no other rights or +* licenses, express or implied, are granted by Apple herein, including but not limited to any +* patent rights that may be infringed by your derivative works or by other works in which the +* Apple Software may be incorporated. +* +* The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO WARRANTIES, EXPRESS OR +* IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY +* AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE +* OR IN COMBINATION WITH YOUR PRODUCTS. +* +* IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL +* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, +* REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER +* UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN +* IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*/ +#include "AUEffectBase.h" +#include "PocketVerbsVersion.h" + +#if AU_DEBUG_DISPATCHER + #include "AUDebugDispatcher.h" +#endif + + +#ifndef __PocketVerbs_h__ +#define __PocketVerbs_h__ + + +#pragma mark ____PocketVerbs Parameters + +// parameters +static CFStringRef kParameterOneName = CFSTR("Type"); +static const int kChamber = 1; +static const int kSpring = 2; +static const int kTiled = 3; +static const int kRoom = 4; +static const int kStretch = 5; +static const int kZarathustra = 6; +static const int kDefaultValue_ParamOne = kChamber; + +static CFStringRef kMenuItem_Chamber = CFSTR ("Chamber"); +static CFStringRef kMenuItem_Spring = CFSTR ("Spring"); +static CFStringRef kMenuItem_Tiled = CFSTR ("Tiled"); +static CFStringRef kMenuItem_Room = CFSTR ("Room"); +static CFStringRef kMenuItem_Stretch = CFSTR ("Stretch"); +static CFStringRef kMenuItem_Zarathustra = CFSTR ("Zarathustra"); + + +static const float kDefaultValue_ParamTwo = 0.5; +static const float kDefaultValue_ParamThree = 0.0; +static const float kDefaultValue_ParamFour = 0.5; + +static CFStringRef kParameterTwoName = CFSTR("Size"); +static CFStringRef kParameterThreeName = CFSTR("Gating"); +static CFStringRef kParameterFourName = CFSTR("Dry/Wet"); +//Alter the name if desired, but using the plugin name is a start + +enum { + kParam_One =0, + kParam_Two =1, + kParam_Three =2, + kParam_Four =3, + //Add your parameters here... + kNumberOfParameters=4 +}; + +#pragma mark ____PocketVerbs +class PocketVerbs : public AUEffectBase +{ +public: + PocketVerbs(AudioUnit component); +#if AU_DEBUG_DISPATCHER + virtual ~PocketVerbs () { delete mDebugDispatcher; } +#endif + + virtual AUKernelBase * NewKernel() { return new PocketVerbsKernel(this); } + + virtual ComponentResult GetParameterValueStrings(AudioUnitScope inScope, + AudioUnitParameterID inParameterID, + CFArrayRef * outStrings); + + virtual ComponentResult GetParameterInfo(AudioUnitScope inScope, + AudioUnitParameterID inParameterID, + AudioUnitParameterInfo &outParameterInfo); + + virtual ComponentResult GetPropertyInfo(AudioUnitPropertyID inID, + AudioUnitScope inScope, + AudioUnitElement inElement, + UInt32 & outDataSize, + Boolean & outWritable ); + + virtual ComponentResult GetProperty(AudioUnitPropertyID inID, + AudioUnitScope inScope, + AudioUnitElement inElement, + void * outData); + + virtual ComponentResult Initialize(); + virtual bool SupportsTail () { return true; } + virtual Float64 GetTailTime() {return 1.0/GetSampleRate()*220000.0;} //in SECONDS! gsr * a number = in samples + virtual Float64 GetLatency() {return (1.0/GetSampleRate())*0.0;} // in SECONDS! gsr * a number = in samples + + /*! @method Version */ + virtual ComponentResult Version() { return kPocketVerbsVersion; } + + + +protected: + class PocketVerbsKernel : public AUKernelBase // most of the real work happens here + { +public: + PocketVerbsKernel(AUEffectBase *inAudioUnit ) + : AUKernelBase(inAudioUnit) + { + } + + // *Required* overides for the process method for this effect + // processes one channel of interleaved samples + virtual void Process( const Float32 *inSourceP, + Float32 *inDestP, + UInt32 inFramesToProcess, + UInt32 inNumChannels, + bool &ioSilence); + + virtual void Reset(); + + private: + Float64 dA[7]; + Float64 dB[7]; + Float64 dC[7]; + Float64 dD[7]; + Float64 dE[7]; + Float64 dF[7]; + Float64 dG[7]; + Float64 dH[7]; + Float64 dI[7]; + Float64 dJ[7]; + Float64 dK[7]; + Float64 dL[7]; + Float64 dM[7]; + Float64 dN[7]; + Float64 dO[7]; + Float64 dP[7]; + Float64 dQ[7]; + Float64 dR[7]; + Float64 dS[7]; + Float64 dT[7]; + Float64 dU[7]; + Float64 dV[7]; + Float64 dW[7]; + Float64 dX[7]; + Float64 dY[7]; + Float64 dZ[7]; + + Float64 aA[15150]; + Float64 aB[14618]; + Float64 aC[14358]; + Float64 aD[13818]; + Float64 aE[13562]; + Float64 aF[13046]; + Float64 aG[11966]; + Float64 aH[11130]; + Float64 aI[10598]; + Float64 aJ[9810]; + Float64 aK[9522]; + Float64 aL[8982]; + Float64 aM[8786]; + Float64 aN[8462]; + Float64 aO[8310]; + Float64 aP[7982]; + Float64 aQ[7322]; + Float64 aR[6818]; + Float64 aS[6506]; + Float64 aT[6002]; + Float64 aU[5838]; + Float64 aV[5502]; + Float64 aW[5010]; + Float64 aX[4850]; + Float64 aY[4296]; + Float64 aZ[4180]; + + Float64 oA[15150]; + Float64 oB[14618]; + Float64 oC[14358]; + Float64 oD[13818]; + Float64 oE[13562]; + Float64 oF[13046]; + Float64 oG[11966]; + Float64 oH[11130]; + Float64 oI[10598]; + Float64 oJ[9810]; + Float64 oK[9522]; + Float64 oL[8982]; + Float64 oM[8786]; + Float64 oN[8462]; + Float64 oO[8310]; + Float64 oP[7982]; + Float64 oQ[7322]; + Float64 oR[6818]; + Float64 oS[6506]; + Float64 oT[6002]; + Float64 oU[5838]; + Float64 oV[5502]; + Float64 oW[5010]; + Float64 oX[4850]; + Float64 oY[4296]; + Float64 oZ[4180]; + + int outA, alpA, maxdelayA, delayA; + int outB, alpB, maxdelayB, delayB; + int outC, alpC, maxdelayC, delayC; + int outD, alpD, maxdelayD, delayD; + int outE, alpE, maxdelayE, delayE; + int outF, alpF, maxdelayF, delayF; + int outG, alpG, maxdelayG, delayG; + int outH, alpH, maxdelayH, delayH; + int outI, alpI, maxdelayI, delayI; + int outJ, alpJ, maxdelayJ, delayJ; + int outK, alpK, maxdelayK, delayK; + int outL, alpL, maxdelayL, delayL; + int outM, alpM, maxdelayM, delayM; + int outN, alpN, maxdelayN, delayN; + int outO, alpO, maxdelayO, delayO; + int outP, alpP, maxdelayP, delayP; + int outQ, alpQ, maxdelayQ, delayQ; + int outR, alpR, maxdelayR, delayR; + int outS, alpS, maxdelayS, delayS; + int outT, alpT, maxdelayT, delayT; + int outU, alpU, maxdelayU, delayU; + int outV, alpV, maxdelayV, delayV; + int outW, alpW, maxdelayW, delayW; + int outX, alpX, maxdelayX, delayX; + int outY, alpY, maxdelayY, delayY; + int outZ, alpZ, maxdelayZ, delayZ; + + Float64 savedRoomsize; + int countdown; + Float64 peak; + uint32_t fpd; + + }; + }; + + //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + +#endif \ No newline at end of file diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.r b/plugins/MacAU/PocketVerbs/PocketVerbs.r new file mode 100755 index 0000000..07090e6 --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbs.r @@ -0,0 +1,61 @@ +/* +* File: PocketVerbs.r +* +* Version: 1.0 +* +* Created: 8/19/12 +* +* Copyright: Copyright © 2012 Airwindows, All Rights Reserved +* +* Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in +* consideration of your agreement to the following terms, and your use, installation, modification +* or redistribution of this Apple software constitutes acceptance of these terms. If you do +* not agree with these terms, please do not use, install, modify or redistribute this Apple +* software. +* +* In consideration of your agreement to abide by the following terms, and subject to these terms, +* Apple grants you a personal, non-exclusive license, under Apple's copyrights in this +* original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the +* Apple Software, with or without modifications, in source and/or binary forms; provided that if you +* redistribute the Apple Software in its entirety and without modifications, you must retain this +* notice and the following text and disclaimers in all such redistributions of the Apple Software. +* Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to +* endorse or promote products derived from the Apple Software without specific prior written +* permission from Apple. Except as expressly stated in this notice, no other rights or +* licenses, express or implied, are granted by Apple herein, including but not limited to any +* patent rights that may be infringed by your derivative works or by other works in which the +* Apple Software may be incorporated. +* +* The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO WARRANTIES, EXPRESS OR +* IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY +* AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE +* OR IN COMBINATION WITH YOUR PRODUCTS. +* +* IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL +* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, +* REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER +* UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN +* IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*/ +#include + +#include "PocketVerbsVersion.h" + +// Note that resource IDs must be spaced 2 apart for the 'STR ' name and description +#define kAudioUnitResID_PocketVerbs 1000 + +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ PocketVerbs~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +#define RES_ID kAudioUnitResID_PocketVerbs +#define COMP_TYPE kAudioUnitType_Effect +#define COMP_SUBTYPE PocketVerbs_COMP_SUBTYPE +#define COMP_MANUF PocketVerbs_COMP_MANF + +#define VERSION kPocketVerbsVersion +#define NAME "Airwindows: PocketVerbs" +#define DESCRIPTION "PocketVerbs AU" +#define ENTRY_POINT "PocketVerbsEntry" + +#include "AUResources.r" \ No newline at end of file diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.mode1v3 b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.mode1v3 new file mode 100755 index 0000000..4bbeff6 --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.mode1v3 @@ -0,0 +1,1374 @@ + + + + + ActivePerspectiveName + Project + AllowedModules + + + BundleLoadPath + + MaxInstances + n + Module + PBXSmartGroupTreeModule + Name + Groups and Files Outline View + + + BundleLoadPath + + MaxInstances + n + Module + PBXNavigatorGroup + Name + Editor + + + BundleLoadPath + + MaxInstances + n + Module + XCTaskListModule + Name + Task List + + + BundleLoadPath + + MaxInstances + n + Module + XCDetailModule + Name + File and Smart Group Detail Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXBuildResultsModule + Name + Detailed Build Results Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXProjectFindModule + Name + Project Batch Find Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCProjectFormatConflictsModule + Name + Project Format Conflicts List + + + BundleLoadPath + + MaxInstances + n + Module + PBXBookmarksModule + Name + Bookmarks Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXClassBrowserModule + Name + Class Browser + + + BundleLoadPath + + MaxInstances + n + Module + PBXCVSModule + Name + Source Code Control Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXDebugBreakpointsModule + Name + Debug Breakpoints Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCDockableInspector + Name + Inspector + + + BundleLoadPath + + MaxInstances + n + Module + PBXOpenQuicklyModule + Name + Open Quickly Tool + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugSessionModule + Name + Debugger + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugCLIModule + Name + Debug Console + + + BundleLoadPath + + MaxInstances + n + Module + XCSnapshotModule + Name + Snapshots Tool + + + BundlePath + /Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources + Description + DefaultDescriptionKey + DockingSystemVisible + + Extension + mode1v3 + FavBarConfig + + PBXProjectModuleGUID + 8BD3CCBC148831C90062E48C + XCBarModuleItemNames + + XCBarModuleItems + + + FirstTimeWindowDisplayed + + Identifier + com.apple.perspectives.project.mode1v3 + MajorVersion + 33 + MinorVersion + 0 + Name + Default + Notifications + + OpenEditors + + PerspectiveWidths + + -1 + -1 + + Perspectives + + + ChosenToolbarItems + + active-combo-popup + action + build + debugger-enable-breakpoints + get-info + com.apple.pbx.toolbar.searchfield + + ControllerClassBaseName + + IconName + WindowOfProjectWithEditor + Identifier + perspective.project + IsVertical + + Layout + + + BecomeActive + + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 186 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 089C166AFE841209C02AAC07 + 08FB77ADFE841716C02AAC07 + 8BA05A56072072A900365D66 + 1C37FBAC04509CD000000102 + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 4 + 2 + 1 + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {186, 647}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + + XCSharingToken + com.apple.Xcode.GFSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {203, 665}} + GroupTreeTableConfiguration + + MainColumn + 186 + + RubberWindowFrame + 547 163 857 706 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 203pt + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20306471E060097A5F4 + PBXProjectModuleLabel + PocketVerbsVersion.h + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CE0B20406471E060097A5F4 + PBXProjectModuleLabel + PocketVerbsVersion.h + _historyCapacity + 0 + bookmark + 8B4223CF189BDBA000BD9C44 + history + + 8B21D7851745523400E1943E + 8B35583517455FF2009B6944 + 8B9B2A791779C31C0061D2E0 + 8B9B2A7A1779C31C0061D2E0 + 8B9B2A7B1779C31C0061D2E0 + 8B464AE617E3574500CFD7BE + + + SplitCount + 1 + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {649, 267}} + RubberWindowFrame + 547 163 857 706 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 267pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20506471E060097A5F4 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{0, 272}, {649, 393}} + RubberWindowFrame + 547 163 857 706 0 0 1440 878 + + Module + XCDetailModule + Proportion + 393pt + + + Proportion + 649pt + + + Name + Project + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + XCModuleDock + PBXNavigatorGroup + XCDetailModule + + TableOfContents + + 8B4223D0189BDBA000BD9C44 + 1CE0B1FE06471DED0097A5F4 + 8B4223D1189BDBA000BD9C44 + 1CE0B20306471E060097A5F4 + 1CE0B20506471E060097A5F4 + + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarConfiguration + xcode.toolbar.config.defaultV3 + + + ControllerClassBaseName + + IconName + WindowOfProject + Identifier + perspective.morph + IsVertical + 0 + Layout + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C08E77C0454961000C914BD + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + + PBXProjectModuleGUID + 11E0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 186 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 29B97314FDCFA39411CA2CEA + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {186, 337}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 1 + XCSharingToken + com.apple.Xcode.GFSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {203, 355}} + GroupTreeTableConfiguration + + MainColumn + 186 + + RubberWindowFrame + 373 269 690 397 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 100% + + + Name + Morph + PreferredWidth + 300 + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + + TableOfContents + + 11E0B1FE06471DED0097A5F4 + + ToolbarConfiguration + xcode.toolbar.config.default.shortV3 + + + PerspectivesBarVisible + + ShelfIsVisible + + SourceDescription + file at '/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecificationMode1.xcperspec' + StatusbarIsVisible + + TimeStamp + 0.0 + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarDisplayMode + 1 + ToolbarIsVisible + + ToolbarSizeMode + 2 + Type + Perspectives + UpdateMessage + The Default Workspace in this version of Xcode now includes support to hide and show the detail view (what has been referred to as the "Metro-Morph" feature). You must discard your current Default Workspace settings and update to the latest Default Workspace in order to gain this feature. Do you wish to update to the latest Workspace defaults for project '%@'? + WindowJustification + 5 + WindowOrderList + + 8B4223D3189BDBA000BD9C44 + 8BD3CCBD148831C90062E48C + /Users/christopherjohnson/Desktop/Dropbox/AU/PocketVerbs/PocketVerbs.xcodeproj + + WindowString + 547 163 857 706 0 0 1440 878 + WindowToolsV3 + + + FirstTimeWindowDisplayed + + Identifier + windowTool.build + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528F0623707200166675 + PBXProjectModuleLabel + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {500, 218}} + RubberWindowFrame + 668 222 500 500 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 218pt + + + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build Results + XCBuildResultsTrigger_Collapse + 1021 + XCBuildResultsTrigger_Open + 1011 + + GeometryConfiguration + + Frame + {{0, 223}, {500, 236}} + RubberWindowFrame + 668 222 500 500 0 0 1440 878 + + Module + PBXBuildResultsModule + Proportion + 236pt + + + Proportion + 459pt + + + Name + Build Results + ServiceClasses + + PBXBuildResultsModule + + StatusbarIsVisible + + TableOfContents + + 8BD3CCBD148831C90062E48C + 8B4223D2189BDBA000BD9C44 + 1CD0528F0623707200166675 + XCMainBuildResultsModuleGUID + + ToolbarConfiguration + xcode.toolbar.config.buildV3 + WindowContentMinSize + 486 300 + WindowString + 668 222 500 500 0 0 1440 878 + WindowToolGUID + 8BD3CCBD148831C90062E48C + WindowToolIsVisible + + + + Identifier + windowTool.debugger + Layout + + + Dock + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {317, 164}} + {{317, 0}, {377, 164}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {694, 164}} + {{0, 164}, {694, 216}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1C162984064C10D400B95A72 + PBXProjectModuleLabel + Debug - GLUTExamples (Underwater) + + GeometryConfiguration + + DebugConsoleDrawerSize + {100, 120} + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 0}, {694, 380}} + RubberWindowFrame + 321 238 694 422 0 0 1440 878 + + Module + PBXDebugSessionModule + Proportion + 100% + + + Proportion + 100% + + + Name + Debugger + ServiceClasses + + PBXDebugSessionModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CD10A99069EF8BA00B06720 + 1C0AD2AB069F1E9B00FABCE6 + 1C162984064C10D400B95A72 + 1C0AD2AC069F1E9B00FABCE6 + + ToolbarConfiguration + xcode.toolbar.config.debugV3 + WindowString + 321 238 694 422 0 0 1440 878 + WindowToolGUID + 1CD10A99069EF8BA00B06720 + WindowToolIsVisible + 0 + + + Identifier + windowTool.find + Layout + + + Dock + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CDD528C0622207200134675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD0528D0623707200166675 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {781, 167}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 781pt + + + Proportion + 50% + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528E0623707200166675 + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{8, 0}, {773, 254}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXProjectFindModule + Proportion + 50% + + + Proportion + 428pt + + + Name + Project Find + ServiceClasses + + PBXProjectFindModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C530D57069F1CE1000CFCEE + 1C530D58069F1CE1000CFCEE + 1C530D59069F1CE1000CFCEE + 1CDD528C0622207200134675 + 1C530D5A069F1CE1000CFCEE + 1CE0B1FE06471DED0097A5F4 + 1CD0528E0623707200166675 + + WindowString + 62 385 781 470 0 0 1440 878 + WindowToolGUID + 1C530D57069F1CE1000CFCEE + WindowToolIsVisible + 0 + + + Identifier + MENUSEPARATOR + + + Identifier + windowTool.debuggerConsole + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAAC065D492600B07095 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {650, 250}} + RubberWindowFrame + 516 632 650 250 0 0 1680 1027 + + Module + PBXDebugCLIModule + Proportion + 209pt + + + Proportion + 209pt + + + Name + Debugger Console + ServiceClasses + + PBXDebugCLIModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAAD065D492600B07095 + 1C78EAAE065D492600B07095 + 1C78EAAC065D492600B07095 + + ToolbarConfiguration + xcode.toolbar.config.consoleV3 + WindowString + 650 41 650 250 0 0 1280 1002 + WindowToolGUID + 1C78EAAD065D492600B07095 + WindowToolIsVisible + 0 + + + Identifier + windowTool.snapshots + Layout + + + Dock + + + Module + XCSnapshotModule + Proportion + 100% + + + Proportion + 100% + + + Name + Snapshots + ServiceClasses + + XCSnapshotModule + + StatusbarIsVisible + Yes + ToolbarConfiguration + xcode.toolbar.config.snapshots + WindowString + 315 824 300 550 0 0 1440 878 + WindowToolIsVisible + Yes + + + Identifier + windowTool.scm + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAB2065D492600B07095 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1C78EAB3065D492600B07095 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {452, 0}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 0pt + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD052920623707200166675 + PBXProjectModuleLabel + SCM + + GeometryConfiguration + + ConsoleFrame + {{0, 259}, {452, 0}} + Frame + {{0, 7}, {452, 259}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + TableConfiguration + + Status + 30 + FileName + 199 + Path + 197.0950012207031 + + TableFrame + {{0, 0}, {452, 250}} + + Module + PBXCVSModule + Proportion + 262pt + + + Proportion + 266pt + + + Name + SCM + ServiceClasses + + PBXCVSModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAB4065D492600B07095 + 1C78EAB5065D492600B07095 + 1C78EAB2065D492600B07095 + 1CD052920623707200166675 + + ToolbarConfiguration + xcode.toolbar.config.scm + WindowString + 743 379 452 308 0 0 1280 1002 + + + Identifier + windowTool.breakpoints + IsVertical + 0 + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C77FABC04509CD000000102 + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + no + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 168 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 1C77FABC04509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {168, 350}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 0 + + GeometryConfiguration + + Frame + {{0, 0}, {185, 368}} + GroupTreeTableConfiguration + + MainColumn + 168 + + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 185pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA1AED706398EBD00589147 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{190, 0}, {554, 368}} + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + XCDetailModule + Proportion + 554pt + + + Proportion + 368pt + + + MajorVersion + 3 + MinorVersion + 0 + Name + Breakpoints + ServiceClasses + + PBXSmartGroupTreeModule + XCDetailModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CDDB66807F98D9800BB5817 + 1CDDB66907F98D9800BB5817 + 1CE0B1FE06471DED0097A5F4 + 1CA1AED706398EBD00589147 + + ToolbarConfiguration + xcode.toolbar.config.breakpointsV3 + WindowString + 315 424 744 409 0 0 1440 878 + WindowToolGUID + 1CDDB66807F98D9800BB5817 + WindowToolIsVisible + 1 + + + Identifier + windowTool.debugAnimator + Layout + + + Dock + + + Module + PBXNavigatorGroup + Proportion + 100% + + + Proportion + 100% + + + Name + Debug Visualizer + ServiceClasses + + PBXNavigatorGroup + + StatusbarIsVisible + 1 + ToolbarConfiguration + xcode.toolbar.config.debugAnimatorV3 + WindowString + 100 100 700 500 0 0 1280 1002 + + + Identifier + windowTool.bookmarks + Layout + + + Dock + + + Module + PBXBookmarksModule + Proportion + 100% + + + Proportion + 100% + + + Name + Bookmarks + ServiceClasses + + PBXBookmarksModule + + StatusbarIsVisible + 0 + WindowString + 538 42 401 187 0 0 1280 1002 + + + Identifier + windowTool.projectFormatConflicts + Layout + + + Dock + + + Module + XCProjectFormatConflictsModule + Proportion + 100% + + + Proportion + 100% + + + Name + Project Format Conflicts + ServiceClasses + + XCProjectFormatConflictsModule + + StatusbarIsVisible + 0 + WindowContentMinSize + 450 300 + WindowString + 50 850 472 307 0 0 1440 877 + + + Identifier + windowTool.classBrowser + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + OptionsSetName + Hierarchy, all classes + PBXProjectModuleGUID + 1CA6456E063B45B4001379D8 + PBXProjectModuleLabel + Class Browser - NSObject + + GeometryConfiguration + + ClassesFrame + {{0, 0}, {374, 96}} + ClassesTreeTableConfiguration + + PBXClassNameColumnIdentifier + 208 + PBXClassBookColumnIdentifier + 22 + + Frame + {{0, 0}, {630, 331}} + MembersFrame + {{0, 105}, {374, 395}} + MembersTreeTableConfiguration + + PBXMemberTypeIconColumnIdentifier + 22 + PBXMemberNameColumnIdentifier + 216 + PBXMemberTypeColumnIdentifier + 97 + PBXMemberBookColumnIdentifier + 22 + + PBXModuleWindowStatusBarHidden2 + 1 + RubberWindowFrame + 385 179 630 352 0 0 1440 878 + + Module + PBXClassBrowserModule + Proportion + 332pt + + + Proportion + 332pt + + + Name + Class Browser + ServiceClasses + + PBXClassBrowserModule + + StatusbarIsVisible + 0 + TableOfContents + + 1C0AD2AF069F1E9B00FABCE6 + 1C0AD2B0069F1E9B00FABCE6 + 1CA6456E063B45B4001379D8 + + ToolbarConfiguration + xcode.toolbar.config.classbrowser + WindowString + 385 179 630 352 0 0 1440 878 + WindowToolGUID + 1C0AD2AF069F1E9B00FABCE6 + WindowToolIsVisible + 0 + + + Identifier + windowTool.refactoring + IncludeInToolsMenu + 0 + Layout + + + Dock + + + BecomeActive + 1 + GeometryConfiguration + + Frame + {0, 0}, {500, 335} + RubberWindowFrame + {0, 0}, {500, 335} + + Module + XCRefactoringModule + Proportion + 100% + + + Proportion + 100% + + + Name + Refactoring + ServiceClasses + + XCRefactoringModule + + WindowString + 200 200 500 356 0 0 1920 1200 + + + + diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser new file mode 100755 index 0000000..7fbbf18 --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser @@ -0,0 +1,149 @@ +// !$*UTF8*$! +{ + 089C1669FE841209C02AAC07 /* Project object */ = { + activeBuildConfigurationName = Release; + activeTarget = 8D01CCC60486CAD60068D4B7 /* PocketVerbs */; + codeSenseManager = 8BD3CCB9148830B20062E48C /* Code sense */; + perUserDictionary = { + PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 364, + 20, + 48, + 43, + 43, + 20, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + PBXFileDataSource_Target_ColumnID, + ); + }; + PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 301, + 60, + 20, + 48, + 43, + 43, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXTargetDataSource_PrimaryAttribute, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + ); + }; + PBXPerProjectTemplateStateSaveDate = 595625819; + PBXWorkspaceStateSaveDate = 595625819; + }; + perUserProjectItems = { + 8B0639D12380A76700606DBC /* PBXTextBookmark */ = 8B0639D12380A76700606DBC /* PBXTextBookmark */; + 8B0639D22380A76700606DBC /* PBXTextBookmark */ = 8B0639D22380A76700606DBC /* PBXTextBookmark */; + 8B0639D32380A76700606DBC /* PBXTextBookmark */ = 8B0639D32380A76700606DBC /* PBXTextBookmark */; + }; + sourceControlManager = 8BD3CCB8148830B20062E48C /* Source Control */; + userBuildSettings = { + }; + }; + 8B0639D12380A76700606DBC /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 8BA05A690720730100365D66 /* PocketVerbsVersion.h */; + name = "PocketVerbsVersion.h: 48"; + rLen = 0; + rLoc = 2728; + rType = 0; + vrLen = 87; + vrLoc = 2683; + }; + 8B0639D22380A76700606DBC /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 8BA05A660720730100365D66 /* PocketVerbs.cpp */; + name = "PocketVerbs.cpp: 325"; + rLen = 0; + rLoc = 15455; + rType = 0; + vrLen = 87; + vrLoc = 14950; + }; + 8B0639D32380A76700606DBC /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 8BA05A660720730100365D66 /* PocketVerbs.cpp */; + name = "PocketVerbs.cpp: 325"; + rLen = 0; + rLoc = 15455; + rType = 0; + vrLen = 87; + vrLoc = 14950; + }; + 8BA05A660720730100365D66 /* PocketVerbs.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1111, 62803}}"; + sepNavSelRange = "{15455, 0}"; + sepNavVisRange = "{14950, 87}"; + sepNavWindowFrame = "{{518, 57}, {908, 821}}"; + }; + }; + 8BA05A670720730100365D66 /* PocketVerbs.exp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {588, 259}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRange = "{0, 18}"; + }; + }; + 8BA05A680720730100365D66 /* PocketVerbs.r */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {702, 627}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRange = "{0, 1442}"; + }; + }; + 8BA05A690720730100365D66 /* PocketVerbsVersion.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {803, 936}}"; + sepNavSelRange = "{2728, 0}"; + sepNavVisRange = "{2683, 87}"; + sepNavWindowFrame = "{{575, 67}, {834, 801}}"; + }; + }; + 8BC6025B073B072D006C4272 /* PocketVerbs.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1041, 3523}}"; + sepNavSelRange = "{5987, 0}"; + sepNavVisRange = "{3031, 1879}"; + sepNavWindowFrame = "{{546, 57}, {885, 821}}"; + }; + }; + 8BD3CCB8148830B20062E48C /* Source Control */ = { + isa = PBXSourceControlManager; + fallbackIsa = XCSourceControlManager; + isSCMEnabled = 0; + scmConfiguration = { + repositoryNamesForRoots = { + "" = ""; + }; + }; + }; + 8BD3CCB9148830B20062E48C /* Code sense */ = { + isa = PBXCodeSenseManager; + indexTemplatePath = ""; + }; + 8D01CCC60486CAD60068D4B7 /* PocketVerbs */ = { + activeExec = 0; + }; +} diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 new file mode 100755 index 0000000..37ac50e --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 @@ -0,0 +1,1485 @@ + + + + + ActivePerspectiveName + Project + AllowedModules + + + BundleLoadPath + + MaxInstances + n + Module + PBXSmartGroupTreeModule + Name + Groups and Files Outline View + + + BundleLoadPath + + MaxInstances + n + Module + PBXNavigatorGroup + Name + Editor + + + BundleLoadPath + + MaxInstances + n + Module + XCTaskListModule + Name + Task List + + + BundleLoadPath + + MaxInstances + n + Module + XCDetailModule + Name + File and Smart Group Detail Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXBuildResultsModule + Name + Detailed Build Results Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXProjectFindModule + Name + Project Batch Find Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCProjectFormatConflictsModule + Name + Project Format Conflicts List + + + BundleLoadPath + + MaxInstances + n + Module + PBXBookmarksModule + Name + Bookmarks Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXClassBrowserModule + Name + Class Browser + + + BundleLoadPath + + MaxInstances + n + Module + PBXCVSModule + Name + Source Code Control Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXDebugBreakpointsModule + Name + Debug Breakpoints Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCDockableInspector + Name + Inspector + + + BundleLoadPath + + MaxInstances + n + Module + PBXOpenQuicklyModule + Name + Open Quickly Tool + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugSessionModule + Name + Debugger + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugCLIModule + Name + Debug Console + + + BundleLoadPath + + MaxInstances + n + Module + XCSnapshotModule + Name + Snapshots Tool + + + BundlePath + /Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources + Description + AIODescriptionKey + DockingSystemVisible + + Extension + perspectivev3 + FavBarConfig + + PBXProjectModuleGUID + 8BEED1FF1EA54DCA0094708A + XCBarModuleItemNames + + XCBarModuleItems + + + FirstTimeWindowDisplayed + + Identifier + com.apple.perspectives.project.defaultV3 + MajorVersion + 34 + MinorVersion + 0 + Name + All-In-One + Notifications + + + XCObserverAutoDisconnectKey + + XCObserverDefintionKey + + PBXStatusErrorsKey + 0 + + XCObserverFactoryKey + XCPerspectivesSpecificationIdentifier + XCObserverGUIDKey + XCObserverProjectIdentifier + XCObserverNotificationKey + PBXStatusBuildStateMessageNotification + XCObserverTargetKey + XCMainBuildResultsModuleGUID + XCObserverTriggerKey + awakenModuleWithObserver: + XCObserverValidationKey + + PBXStatusErrorsKey + 2 + + + + OpenEditors + + PerspectiveWidths + + -1 + -1 + + Perspectives + + + ChosenToolbarItems + + XCToolbarPerspectiveControl + NSToolbarSeparatorItem + active-combo-popup + action + NSToolbarFlexibleSpaceItem + debugger-enable-breakpoints + build-and-go + com.apple.ide.PBXToolbarStopButton + get-info + NSToolbarFlexibleSpaceItem + com.apple.pbx.toolbar.searchfield + + ControllerClassBaseName + + IconName + WindowOfProject + Identifier + perspective.project + IsVertical + + Layout + + + BecomeActive + + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + 1C77FABC04509CD000000102 + + PBXProjectModuleGUID + 1CA23ED40692098700951B8B + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 185 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 089C166AFE841209C02AAC07 + 08FB77ADFE841716C02AAC07 + 8BA05A56072072A900365D66 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 4 + 2 + 1 + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {185, 428}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + + + GeometryConfiguration + + Frame + {{0, 0}, {202, 446}} + GroupTreeTableConfiguration + + MainColumn + 185 + + RubberWindowFrame + 620 386 810 487 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 202pt + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 8BEED1FA1EA54DCA0094708A + PBXProjectModuleLabel + PocketVerbs.cpp + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 8BEED1FB1EA54DCA0094708A + PBXProjectModuleLabel + PocketVerbs.cpp + _historyCapacity + 0 + bookmark + 8B0639D32380A76700606DBC + history + + 8B0639D12380A76700606DBC + 8B0639D22380A76700606DBC + + + SplitCount + 1 + + StatusBarVisibility + + XCSharingToken + com.apple.Xcode.CommonNavigatorGroupSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {603, 51}} + RubberWindowFrame + 620 386 810 487 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 51pt + + + Proportion + 390pt + Tabs + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA23EDF0692099D00951B8B + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{10, 27}, {603, 363}} + RubberWindowFrame + 620 386 810 487 0 0 1440 878 + + Module + XCDetailModule + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA23EE00692099D00951B8B + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{10, 31}, {603, 297}} + + Module + PBXProjectFindModule + + + ContentConfiguration + + PBXCVSModuleFilterTypeKey + 1032 + PBXProjectModuleGUID + 1CA23EE10692099D00951B8B + PBXProjectModuleLabel + SCM Results + + GeometryConfiguration + + Frame + {{10, 31}, {603, 297}} + + Module + PBXCVSModule + + + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build Results + XCBuildResultsTrigger_Collapse + 1023 + XCBuildResultsTrigger_Open + 1012 + + GeometryConfiguration + + Frame + {{10, 31}, {603, 297}} + + Module + PBXBuildResultsModule + + + + + Proportion + 603pt + + + Name + Project + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + XCModuleDock + PBXNavigatorGroup + XCDockableTabModule + XCDetailModule + PBXProjectFindModule + PBXCVSModule + PBXBuildResultsModule + + TableOfContents + + 8B0639D42380A76700606DBC + 1CA23ED40692098700951B8B + 8B0639D52380A76700606DBC + 8BEED1FA1EA54DCA0094708A + 8B0639D62380A76700606DBC + 1CA23EDF0692099D00951B8B + 1CA23EE00692099D00951B8B + 1CA23EE10692099D00951B8B + XCMainBuildResultsModuleGUID + + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarConfiguration + xcode.toolbar.config.defaultV3 + + + ChosenToolbarItems + + XCToolbarPerspectiveControl + NSToolbarSeparatorItem + active-combo-popup + NSToolbarFlexibleSpaceItem + debugger-enable-breakpoints + build-and-go + com.apple.ide.PBXToolbarStopButton + debugger-restart-executable + debugger-pause + debugger-step-over + debugger-step-into + debugger-step-out + NSToolbarFlexibleSpaceItem + servicesModulebreakpoints + debugger-show-console-window + + ControllerClassBaseName + PBXDebugSessionModule + IconName + DebugTabIcon + Identifier + perspective.debug + IsVertical + 1 + Layout + + + ContentConfiguration + + PBXProjectModuleGUID + 1CCC7628064C1048000F2A68 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {810, 0}} + + Module + PBXDebugCLIModule + Proportion + 0% + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {395, 213}} + {{395, 0}, {415, 213}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {810, 213}} + {{0, 213}, {810, 225}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1CCC7629064C1048000F2A68 + PBXProjectModuleLabel + Debug + + GeometryConfiguration + + DebugConsoleDrawerSize + {100, 120} + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 7}, {810, 438}} + + Module + PBXDebugSessionModule + Proportion + 443pt + + + Name + Debug + ServiceClasses + + XCModuleDock + XCModuleDock + PBXDebugCLIModule + PBXDebugSessionModule + XCConsole + + TableOfContents + + 1CC8E6A5069209BD00BB180A + 1CC8E6A6069209BD00BB180A + 1CCC7628064C1048000F2A68 + 1CCC7629064C1048000F2A68 + 1CC8E6A7069209BD00BB180A + + ToolbarConfiguration + xcode.toolbar.config.debugV3 + + + PerspectivesBarVisible + + ShelfIsVisible + + SourceDescription + file at '/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecification.xcperspec' + StatusbarIsVisible + + TimeStamp + 595634023.18682003 + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarDisplayMode + 1 + ToolbarIsVisible + + ToolbarSizeMode + 2 + Type + Perspectives + UpdateMessage + + WindowJustification + 5 + WindowOrderList + + 8B0639D72380A76700606DBC + /Users/christopherjohnson/Desktop/Plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj + + WindowString + 620 386 810 487 0 0 1440 878 + WindowToolsV3 + + + Identifier + windowTool.debugger + Layout + + + Dock + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {317, 164}} + {{317, 0}, {377, 164}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {694, 164}} + {{0, 164}, {694, 216}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1C162984064C10D400B95A72 + PBXProjectModuleLabel + Debug - GLUTExamples (Underwater) + + GeometryConfiguration + + DebugConsoleDrawerSize + {100, 120} + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 0}, {694, 380}} + RubberWindowFrame + 321 238 694 422 0 0 1440 878 + + Module + PBXDebugSessionModule + Proportion + 100% + + + Proportion + 100% + + + Name + Debugger + ServiceClasses + + PBXDebugSessionModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CD10A99069EF8BA00B06720 + 1C0AD2AB069F1E9B00FABCE6 + 1C162984064C10D400B95A72 + 1C0AD2AC069F1E9B00FABCE6 + + ToolbarConfiguration + xcode.toolbar.config.debugV3 + WindowString + 321 238 694 422 0 0 1440 878 + WindowToolGUID + 1CD10A99069EF8BA00B06720 + WindowToolIsVisible + 0 + + + Identifier + windowTool.build + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528F0623707200166675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD052900623707200166675 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {500, 215}} + RubberWindowFrame + 192 257 500 500 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 218pt + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build Results + + GeometryConfiguration + + Frame + {{0, 222}, {500, 236}} + RubberWindowFrame + 192 257 500 500 0 0 1280 1002 + + Module + PBXBuildResultsModule + Proportion + 236pt + + + Proportion + 458pt + + + Name + Build Results + ServiceClasses + + PBXBuildResultsModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAA5065D492600B07095 + 1C78EAA6065D492600B07095 + 1CD0528F0623707200166675 + XCMainBuildResultsModuleGUID + + ToolbarConfiguration + xcode.toolbar.config.buildV3 + WindowString + 192 257 500 500 0 0 1280 1002 + + + Identifier + windowTool.find + Layout + + + Dock + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CDD528C0622207200134675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD0528D0623707200166675 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {781, 167}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 781pt + + + Proportion + 50% + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528E0623707200166675 + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{8, 0}, {773, 254}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXProjectFindModule + Proportion + 50% + + + Proportion + 428pt + + + Name + Project Find + ServiceClasses + + PBXProjectFindModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C530D57069F1CE1000CFCEE + 1C530D58069F1CE1000CFCEE + 1C530D59069F1CE1000CFCEE + 1CDD528C0622207200134675 + 1C530D5A069F1CE1000CFCEE + 1CE0B1FE06471DED0097A5F4 + 1CD0528E0623707200166675 + + WindowString + 62 385 781 470 0 0 1440 878 + WindowToolGUID + 1C530D57069F1CE1000CFCEE + WindowToolIsVisible + 0 + + + Identifier + windowTool.snapshots + Layout + + + Dock + + + Module + XCSnapshotModule + Proportion + 100% + + + Proportion + 100% + + + Name + Snapshots + ServiceClasses + + XCSnapshotModule + + StatusbarIsVisible + Yes + ToolbarConfiguration + xcode.toolbar.config.snapshots + WindowString + 315 824 300 550 0 0 1440 878 + WindowToolIsVisible + Yes + + + Identifier + windowTool.debuggerConsole + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAAC065D492600B07095 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {700, 358}} + RubberWindowFrame + 149 87 700 400 0 0 1440 878 + + Module + PBXDebugCLIModule + Proportion + 358pt + + + Proportion + 358pt + + + Name + Debugger Console + ServiceClasses + + PBXDebugCLIModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C530D5B069F1CE1000CFCEE + 1C530D5C069F1CE1000CFCEE + 1C78EAAC065D492600B07095 + + ToolbarConfiguration + xcode.toolbar.config.consoleV3 + WindowString + 149 87 440 400 0 0 1440 878 + WindowToolGUID + 1C530D5B069F1CE1000CFCEE + WindowToolIsVisible + 0 + + + Identifier + windowTool.scm + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAB2065D492600B07095 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1C78EAB3065D492600B07095 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {452, 0}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 0pt + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD052920623707200166675 + PBXProjectModuleLabel + SCM + + GeometryConfiguration + + ConsoleFrame + {{0, 259}, {452, 0}} + Frame + {{0, 7}, {452, 259}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + TableConfiguration + + Status + 30 + FileName + 199 + Path + 197.09500122070312 + + TableFrame + {{0, 0}, {452, 250}} + + Module + PBXCVSModule + Proportion + 262pt + + + Proportion + 266pt + + + Name + SCM + ServiceClasses + + PBXCVSModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAB4065D492600B07095 + 1C78EAB5065D492600B07095 + 1C78EAB2065D492600B07095 + 1CD052920623707200166675 + + ToolbarConfiguration + xcode.toolbar.config.scmV3 + WindowString + 743 379 452 308 0 0 1280 1002 + + + Identifier + windowTool.breakpoints + IsVertical + 0 + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C77FABC04509CD000000102 + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + no + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 168 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 1C77FABC04509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {168, 350}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 0 + + GeometryConfiguration + + Frame + {{0, 0}, {185, 368}} + GroupTreeTableConfiguration + + MainColumn + 168 + + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 185pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA1AED706398EBD00589147 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{190, 0}, {554, 368}} + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + XCDetailModule + Proportion + 554pt + + + Proportion + 368pt + + + MajorVersion + 3 + MinorVersion + 0 + Name + Breakpoints + ServiceClasses + + PBXSmartGroupTreeModule + XCDetailModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CDDB66807F98D9800BB5817 + 1CDDB66907F98D9800BB5817 + 1CE0B1FE06471DED0097A5F4 + 1CA1AED706398EBD00589147 + + ToolbarConfiguration + xcode.toolbar.config.breakpointsV3 + WindowString + 315 424 744 409 0 0 1440 878 + WindowToolGUID + 1CDDB66807F98D9800BB5817 + WindowToolIsVisible + 1 + + + Identifier + windowTool.debugAnimator + Layout + + + Dock + + + Module + PBXNavigatorGroup + Proportion + 100% + + + Proportion + 100% + + + Name + Debug Visualizer + ServiceClasses + + PBXNavigatorGroup + + StatusbarIsVisible + 1 + ToolbarConfiguration + xcode.toolbar.config.debugAnimatorV3 + WindowString + 100 100 700 500 0 0 1280 1002 + + + Identifier + windowTool.bookmarks + Layout + + + Dock + + + Module + PBXBookmarksModule + Proportion + 166pt + + + Proportion + 166pt + + + Name + Bookmarks + ServiceClasses + + PBXBookmarksModule + + StatusbarIsVisible + 0 + WindowString + 538 42 401 187 0 0 1280 1002 + + + Identifier + windowTool.projectFormatConflicts + Layout + + + Dock + + + Module + XCProjectFormatConflictsModule + Proportion + 100% + + + Proportion + 100% + + + Name + Project Format Conflicts + ServiceClasses + + XCProjectFormatConflictsModule + + StatusbarIsVisible + 0 + WindowContentMinSize + 450 300 + WindowString + 50 850 472 307 0 0 1440 877 + + + Identifier + windowTool.classBrowser + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + OptionsSetName + Hierarchy, all classes + PBXProjectModuleGUID + 1CA6456E063B45B4001379D8 + PBXProjectModuleLabel + Class Browser - NSObject + + GeometryConfiguration + + ClassesFrame + {{0, 0}, {369, 96}} + ClassesTreeTableConfiguration + + PBXClassNameColumnIdentifier + 208 + PBXClassBookColumnIdentifier + 22 + + Frame + {{0, 0}, {616, 353}} + MembersFrame + {{0, 105}, {369, 395}} + MembersTreeTableConfiguration + + PBXMemberTypeIconColumnIdentifier + 22 + PBXMemberNameColumnIdentifier + 216 + PBXMemberTypeColumnIdentifier + 94 + PBXMemberBookColumnIdentifier + 22 + + PBXModuleWindowStatusBarHidden2 + 1 + RubberWindowFrame + 597 125 616 374 0 0 1280 1002 + + Module + PBXClassBrowserModule + Proportion + 354pt + + + Proportion + 354pt + + + Name + Class Browser + ServiceClasses + + PBXClassBrowserModule + + StatusbarIsVisible + 0 + TableOfContents + + 1C78EABA065D492600B07095 + 1C78EABB065D492600B07095 + 1CA6456E063B45B4001379D8 + + ToolbarConfiguration + xcode.toolbar.config.classbrowser + WindowString + 597 125 616 374 0 0 1280 1002 + + + Identifier + windowTool.refactoring + IncludeInToolsMenu + 0 + Layout + + + Dock + + + BecomeActive + 1 + GeometryConfiguration + + Frame + {0, 0}, {500, 335} + RubberWindowFrame + {0, 0}, {500, 335} + + Module + XCRefactoringModule + Proportion + 100% + + + Proportion + 100% + + + Name + Refactoring + ServiceClasses + + XCRefactoringModule + + WindowString + 200 200 500 356 0 0 1920 1200 + + + + diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj new file mode 100755 index 0000000..b874a8f --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj @@ -0,0 +1,490 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 45; + objects = { + +/* Begin PBXBuildFile section */ + 3EEA126E089847F5002C6BFC /* CAVectorUnit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3EEA126B089847F5002C6BFC /* CAVectorUnit.cpp */; }; + 3EEA126F089847F5002C6BFC /* CAVectorUnit.h in Headers */ = {isa = PBXBuildFile; fileRef = 3EEA126C089847F5002C6BFC /* CAVectorUnit.h */; }; + 3EEA1270089847F5002C6BFC /* CAVectorUnitTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 3EEA126D089847F5002C6BFC /* CAVectorUnitTypes.h */; }; + 8B4119B70749654200361ABE /* PocketVerbs.r in Rez */ = {isa = PBXBuildFile; fileRef = 8BA05A680720730100365D66 /* PocketVerbs.r */; }; + 8BA05A6B0720730100365D66 /* PocketVerbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A660720730100365D66 /* PocketVerbs.cpp */; }; + 8BA05A6E0720730100365D66 /* PocketVerbsVersion.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A690720730100365D66 /* PocketVerbsVersion.h */; }; + 8BA05AAE072073D300365D66 /* AUBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A7F072073D200365D66 /* AUBase.cpp */; }; + 8BA05AAF072073D300365D66 /* AUBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A80072073D200365D66 /* AUBase.h */; }; + 8BA05AB0072073D300365D66 /* AUDispatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A81072073D200365D66 /* AUDispatch.cpp */; }; + 8BA05AB1072073D300365D66 /* AUDispatch.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A82072073D200365D66 /* AUDispatch.h */; }; + 8BA05AB2072073D300365D66 /* AUInputElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A83072073D200365D66 /* AUInputElement.cpp */; }; + 8BA05AB3072073D300365D66 /* AUInputElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A84072073D200365D66 /* AUInputElement.h */; }; + 8BA05AB4072073D300365D66 /* AUOutputElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A85072073D200365D66 /* AUOutputElement.cpp */; }; + 8BA05AB5072073D300365D66 /* AUOutputElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A86072073D200365D66 /* AUOutputElement.h */; }; + 8BA05AB7072073D300365D66 /* AUScopeElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A88072073D200365D66 /* AUScopeElement.cpp */; }; + 8BA05AB8072073D300365D66 /* AUScopeElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A89072073D200365D66 /* AUScopeElement.h */; }; + 8BA05AB9072073D300365D66 /* ComponentBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A8A072073D200365D66 /* ComponentBase.cpp */; }; + 8BA05ABA072073D300365D66 /* ComponentBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A8B072073D200365D66 /* ComponentBase.h */; }; + 8BA05AC6072073D300365D66 /* AUEffectBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A9A072073D200365D66 /* AUEffectBase.cpp */; }; + 8BA05AC7072073D300365D66 /* AUEffectBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A9B072073D200365D66 /* AUEffectBase.h */; }; + 8BA05AD2072073D300365D66 /* AUBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05AA7072073D200365D66 /* AUBuffer.cpp */; }; + 8BA05AD3072073D300365D66 /* AUBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AA8072073D200365D66 /* AUBuffer.h */; }; + 8BA05AD4072073D300365D66 /* AUDebugDispatcher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05AA9072073D200365D66 /* AUDebugDispatcher.cpp */; }; + 8BA05AD5072073D300365D66 /* AUDebugDispatcher.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AAA072073D200365D66 /* AUDebugDispatcher.h */; }; + 8BA05AD6072073D300365D66 /* AUInputFormatConverter.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AAB072073D200365D66 /* AUInputFormatConverter.h */; }; + 8BA05AD7072073D300365D66 /* AUSilentTimeout.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AAC072073D200365D66 /* AUSilentTimeout.h */; }; + 8BA05AD8072073D300365D66 /* AUTimestampGenerator.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AAD072073D200365D66 /* AUTimestampGenerator.h */; }; + 8BA05AE50720742100365D66 /* CAAudioChannelLayout.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05ADF0720742100365D66 /* CAAudioChannelLayout.cpp */; }; + 8BA05AE60720742100365D66 /* CAAudioChannelLayout.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AE00720742100365D66 /* CAAudioChannelLayout.h */; }; + 8BA05AE70720742100365D66 /* CAMutex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05AE10720742100365D66 /* CAMutex.cpp */; }; + 8BA05AE80720742100365D66 /* CAMutex.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AE20720742100365D66 /* CAMutex.h */; }; + 8BA05AE90720742100365D66 /* CAStreamBasicDescription.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05AE30720742100365D66 /* CAStreamBasicDescription.cpp */; }; + 8BA05AEA0720742100365D66 /* CAStreamBasicDescription.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AE40720742100365D66 /* CAStreamBasicDescription.h */; }; + 8BA05AFC072074E100365D66 /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8BA05AF9072074E100365D66 /* AudioToolbox.framework */; }; + 8BA05AFD072074E100365D66 /* AudioUnit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8BA05AFA072074E100365D66 /* AudioUnit.framework */; }; + 8BA05B02072074F900365D66 /* CoreServices.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8BA05B01072074F900365D66 /* CoreServices.framework */; }; + 8BA05B070720754400365D66 /* CAAUParameter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05B050720754400365D66 /* CAAUParameter.cpp */; }; + 8BA05B080720754400365D66 /* CAAUParameter.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05B060720754400365D66 /* CAAUParameter.h */; }; + 8BC6025C073B072D006C4272 /* PocketVerbs.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BC6025B073B072D006C4272 /* PocketVerbs.h */; }; + 8D01CCCA0486CAD60068D4B7 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C167DFE841241C02AAC07 /* InfoPlist.strings */; }; + F7C347F00ECE5AF8008ADFB6 /* AUBaseHelper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F7C347EE0ECE5AF8008ADFB6 /* AUBaseHelper.cpp */; }; + F7C347F10ECE5AF8008ADFB6 /* AUBaseHelper.h in Headers */ = {isa = PBXBuildFile; fileRef = F7C347EF0ECE5AF8008ADFB6 /* AUBaseHelper.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 089C167EFE841241C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = ""; }; + 3EEA126B089847F5002C6BFC /* CAVectorUnit.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAVectorUnit.cpp; sourceTree = ""; }; + 3EEA126C089847F5002C6BFC /* CAVectorUnit.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAVectorUnit.h; sourceTree = ""; }; + 3EEA126D089847F5002C6BFC /* CAVectorUnitTypes.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAVectorUnitTypes.h; sourceTree = ""; }; + 8B5C7FBF076FB2C200A15F61 /* CoreAudio.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreAudio.framework; path = /System/Library/Frameworks/CoreAudio.framework; sourceTree = ""; }; + 8BA05A660720730100365D66 /* PocketVerbs.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = PocketVerbs.cpp; sourceTree = ""; }; + 8BA05A670720730100365D66 /* PocketVerbs.exp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.exports; path = PocketVerbs.exp; sourceTree = ""; }; + 8BA05A680720730100365D66 /* PocketVerbs.r */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.rez; path = PocketVerbs.r; sourceTree = ""; }; + 8BA05A690720730100365D66 /* PocketVerbsVersion.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = PocketVerbsVersion.h; sourceTree = ""; }; + 8BA05A7F072073D200365D66 /* AUBase.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUBase.cpp; sourceTree = ""; }; + 8BA05A80072073D200365D66 /* AUBase.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUBase.h; sourceTree = ""; }; + 8BA05A81072073D200365D66 /* AUDispatch.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUDispatch.cpp; sourceTree = ""; }; + 8BA05A82072073D200365D66 /* AUDispatch.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUDispatch.h; sourceTree = ""; }; + 8BA05A83072073D200365D66 /* AUInputElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUInputElement.cpp; sourceTree = ""; }; + 8BA05A84072073D200365D66 /* AUInputElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUInputElement.h; sourceTree = ""; }; + 8BA05A85072073D200365D66 /* AUOutputElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUOutputElement.cpp; sourceTree = ""; }; + 8BA05A86072073D200365D66 /* AUOutputElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUOutputElement.h; sourceTree = ""; }; + 8BA05A87072073D200365D66 /* AUResources.r */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.rez; path = AUResources.r; sourceTree = ""; }; + 8BA05A88072073D200365D66 /* AUScopeElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUScopeElement.cpp; sourceTree = ""; }; + 8BA05A89072073D200365D66 /* AUScopeElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUScopeElement.h; sourceTree = ""; }; + 8BA05A8A072073D200365D66 /* ComponentBase.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ComponentBase.cpp; sourceTree = ""; }; + 8BA05A8B072073D200365D66 /* ComponentBase.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ComponentBase.h; sourceTree = ""; }; + 8BA05A9A072073D200365D66 /* AUEffectBase.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUEffectBase.cpp; sourceTree = ""; }; + 8BA05A9B072073D200365D66 /* AUEffectBase.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUEffectBase.h; sourceTree = ""; }; + 8BA05AA7072073D200365D66 /* AUBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUBuffer.cpp; sourceTree = ""; }; + 8BA05AA8072073D200365D66 /* AUBuffer.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUBuffer.h; sourceTree = ""; }; + 8BA05AA9072073D200365D66 /* AUDebugDispatcher.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUDebugDispatcher.cpp; sourceTree = ""; }; + 8BA05AAA072073D200365D66 /* AUDebugDispatcher.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUDebugDispatcher.h; sourceTree = ""; }; + 8BA05AAB072073D200365D66 /* AUInputFormatConverter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUInputFormatConverter.h; sourceTree = ""; }; + 8BA05AAC072073D200365D66 /* AUSilentTimeout.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUSilentTimeout.h; sourceTree = ""; }; + 8BA05AAD072073D200365D66 /* AUTimestampGenerator.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUTimestampGenerator.h; sourceTree = ""; }; + 8BA05ADF0720742100365D66 /* CAAudioChannelLayout.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAAudioChannelLayout.cpp; sourceTree = ""; }; + 8BA05AE00720742100365D66 /* CAAudioChannelLayout.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAAudioChannelLayout.h; sourceTree = ""; }; + 8BA05AE10720742100365D66 /* CAMutex.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAMutex.cpp; sourceTree = ""; }; + 8BA05AE20720742100365D66 /* CAMutex.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAMutex.h; sourceTree = ""; }; + 8BA05AE30720742100365D66 /* CAStreamBasicDescription.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAStreamBasicDescription.cpp; sourceTree = ""; }; + 8BA05AE40720742100365D66 /* CAStreamBasicDescription.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAStreamBasicDescription.h; sourceTree = ""; }; + 8BA05AF9072074E100365D66 /* AudioToolbox.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AudioToolbox.framework; path = /System/Library/Frameworks/AudioToolbox.framework; sourceTree = ""; }; + 8BA05AFA072074E100365D66 /* AudioUnit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AudioUnit.framework; path = /System/Library/Frameworks/AudioUnit.framework; sourceTree = ""; }; + 8BA05B01072074F900365D66 /* CoreServices.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreServices.framework; path = /System/Library/Frameworks/CoreServices.framework; sourceTree = ""; }; + 8BA05B050720754400365D66 /* CAAUParameter.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAAUParameter.cpp; sourceTree = ""; }; + 8BA05B060720754400365D66 /* CAAUParameter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAAUParameter.h; sourceTree = ""; }; + 8BC6025B073B072D006C4272 /* PocketVerbs.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = PocketVerbs.h; sourceTree = ""; }; + 8D01CCD10486CAD60068D4B7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = ""; }; + 8D01CCD20486CAD60068D4B7 /* PocketVerbs.component */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = PocketVerbs.component; sourceTree = BUILT_PRODUCTS_DIR; }; + F7C347EE0ECE5AF8008ADFB6 /* AUBaseHelper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AUBaseHelper.cpp; path = Extras/CoreAudio/AudioUnits/AUPublic/Utility/AUBaseHelper.cpp; sourceTree = SYSTEM_DEVELOPER_DIR; }; + F7C347EF0ECE5AF8008ADFB6 /* AUBaseHelper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AUBaseHelper.h; path = Extras/CoreAudio/AudioUnits/AUPublic/Utility/AUBaseHelper.h; sourceTree = SYSTEM_DEVELOPER_DIR; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 8D01CCCD0486CAD60068D4B7 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 8BA05AFC072074E100365D66 /* AudioToolbox.framework in Frameworks */, + 8BA05AFD072074E100365D66 /* AudioUnit.framework in Frameworks */, + 8BA05B02072074F900365D66 /* CoreServices.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 089C166AFE841209C02AAC07 /* PocketVerbs */ = { + isa = PBXGroup; + children = ( + 08FB77ADFE841716C02AAC07 /* Source */, + 089C167CFE841241C02AAC07 /* Resources */, + 089C1671FE841209C02AAC07 /* External Frameworks and Libraries */, + 19C28FB4FE9D528D11CA2CBB /* Products */, + ); + name = PocketVerbs; + sourceTree = ""; + }; + 089C1671FE841209C02AAC07 /* External Frameworks and Libraries */ = { + isa = PBXGroup; + children = ( + 8B5C7FBF076FB2C200A15F61 /* CoreAudio.framework */, + 8BA05B01072074F900365D66 /* CoreServices.framework */, + 8BA05AF9072074E100365D66 /* AudioToolbox.framework */, + 8BA05AFA072074E100365D66 /* AudioUnit.framework */, + ); + name = "External Frameworks and Libraries"; + sourceTree = ""; + }; + 089C167CFE841241C02AAC07 /* Resources */ = { + isa = PBXGroup; + children = ( + 8D01CCD10486CAD60068D4B7 /* Info.plist */, + 089C167DFE841241C02AAC07 /* InfoPlist.strings */, + ); + name = Resources; + sourceTree = ""; + }; + 08FB77ADFE841716C02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 8BA05A56072072A900365D66 /* AU Source */, + 8BA05AEB0720742700365D66 /* PublicUtility */, + 8BA05A7D072073D200365D66 /* AUPublic */, + ); + name = Source; + sourceTree = ""; + }; + 19C28FB4FE9D528D11CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + 8D01CCD20486CAD60068D4B7 /* PocketVerbs.component */, + ); + name = Products; + sourceTree = ""; + }; + 8BA05A56072072A900365D66 /* AU Source */ = { + isa = PBXGroup; + children = ( + 8BC6025B073B072D006C4272 /* PocketVerbs.h */, + 8BA05A660720730100365D66 /* PocketVerbs.cpp */, + 8BA05A670720730100365D66 /* PocketVerbs.exp */, + 8BA05A680720730100365D66 /* PocketVerbs.r */, + 8BA05A690720730100365D66 /* PocketVerbsVersion.h */, + ); + name = "AU Source"; + sourceTree = ""; + }; + 8BA05A7D072073D200365D66 /* AUPublic */ = { + isa = PBXGroup; + children = ( + 8BA05A7E072073D200365D66 /* AUBase */, + 8BA05A99072073D200365D66 /* OtherBases */, + 8BA05AA6072073D200365D66 /* Utility */, + ); + name = AUPublic; + path = Extras/CoreAudio/AudioUnits/AUPublic; + sourceTree = SYSTEM_DEVELOPER_DIR; + }; + 8BA05A7E072073D200365D66 /* AUBase */ = { + isa = PBXGroup; + children = ( + 8BA05A7F072073D200365D66 /* AUBase.cpp */, + 8BA05A80072073D200365D66 /* AUBase.h */, + 8BA05A81072073D200365D66 /* AUDispatch.cpp */, + 8BA05A82072073D200365D66 /* AUDispatch.h */, + 8BA05A83072073D200365D66 /* AUInputElement.cpp */, + 8BA05A84072073D200365D66 /* AUInputElement.h */, + 8BA05A85072073D200365D66 /* AUOutputElement.cpp */, + 8BA05A86072073D200365D66 /* AUOutputElement.h */, + 8BA05A87072073D200365D66 /* AUResources.r */, + 8BA05A88072073D200365D66 /* AUScopeElement.cpp */, + 8BA05A89072073D200365D66 /* AUScopeElement.h */, + 8BA05A8A072073D200365D66 /* ComponentBase.cpp */, + 8BA05A8B072073D200365D66 /* ComponentBase.h */, + ); + path = AUBase; + sourceTree = ""; + }; + 8BA05A99072073D200365D66 /* OtherBases */ = { + isa = PBXGroup; + children = ( + 8BA05A9A072073D200365D66 /* AUEffectBase.cpp */, + 8BA05A9B072073D200365D66 /* AUEffectBase.h */, + ); + path = OtherBases; + sourceTree = ""; + }; + 8BA05AA6072073D200365D66 /* Utility */ = { + isa = PBXGroup; + children = ( + F7C347EE0ECE5AF8008ADFB6 /* AUBaseHelper.cpp */, + F7C347EF0ECE5AF8008ADFB6 /* AUBaseHelper.h */, + 8BA05AA7072073D200365D66 /* AUBuffer.cpp */, + 8BA05AA8072073D200365D66 /* AUBuffer.h */, + 8BA05AA9072073D200365D66 /* AUDebugDispatcher.cpp */, + 8BA05AAA072073D200365D66 /* AUDebugDispatcher.h */, + 8BA05AAB072073D200365D66 /* AUInputFormatConverter.h */, + 8BA05AAC072073D200365D66 /* AUSilentTimeout.h */, + 8BA05AAD072073D200365D66 /* AUTimestampGenerator.h */, + ); + path = Utility; + sourceTree = ""; + }; + 8BA05AEB0720742700365D66 /* PublicUtility */ = { + isa = PBXGroup; + children = ( + 8BA05B050720754400365D66 /* CAAUParameter.cpp */, + 8BA05B060720754400365D66 /* CAAUParameter.h */, + 8BA05ADF0720742100365D66 /* CAAudioChannelLayout.cpp */, + 8BA05AE00720742100365D66 /* CAAudioChannelLayout.h */, + 8BA05AE10720742100365D66 /* CAMutex.cpp */, + 8BA05AE20720742100365D66 /* CAMutex.h */, + 8BA05AE30720742100365D66 /* CAStreamBasicDescription.cpp */, + 8BA05AE40720742100365D66 /* CAStreamBasicDescription.h */, + 3EEA126D089847F5002C6BFC /* CAVectorUnitTypes.h */, + 3EEA126B089847F5002C6BFC /* CAVectorUnit.cpp */, + 3EEA126C089847F5002C6BFC /* CAVectorUnit.h */, + ); + name = PublicUtility; + path = Extras/CoreAudio/PublicUtility; + sourceTree = SYSTEM_DEVELOPER_DIR; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + 8D01CCC70486CAD60068D4B7 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 8BA05A6E0720730100365D66 /* PocketVerbsVersion.h in Headers */, + 8BA05AAF072073D300365D66 /* AUBase.h in Headers */, + 8BA05AB1072073D300365D66 /* AUDispatch.h in Headers */, + 8BA05AB3072073D300365D66 /* AUInputElement.h in Headers */, + 8BA05AB5072073D300365D66 /* AUOutputElement.h in Headers */, + 8BA05AB8072073D300365D66 /* AUScopeElement.h in Headers */, + 8BA05ABA072073D300365D66 /* ComponentBase.h in Headers */, + 8BA05AC7072073D300365D66 /* AUEffectBase.h in Headers */, + 8BA05AD3072073D300365D66 /* AUBuffer.h in Headers */, + 8BA05AD5072073D300365D66 /* AUDebugDispatcher.h in Headers */, + 8BA05AD6072073D300365D66 /* AUInputFormatConverter.h in Headers */, + 8BA05AD7072073D300365D66 /* AUSilentTimeout.h in Headers */, + 8BA05AD8072073D300365D66 /* AUTimestampGenerator.h in Headers */, + 8BA05AE60720742100365D66 /* CAAudioChannelLayout.h in Headers */, + 8BA05AE80720742100365D66 /* CAMutex.h in Headers */, + 8BA05AEA0720742100365D66 /* CAStreamBasicDescription.h in Headers */, + 8BA05B080720754400365D66 /* CAAUParameter.h in Headers */, + 8BC6025C073B072D006C4272 /* PocketVerbs.h in Headers */, + 3EEA126F089847F5002C6BFC /* CAVectorUnit.h in Headers */, + 3EEA1270089847F5002C6BFC /* CAVectorUnitTypes.h in Headers */, + F7C347F10ECE5AF8008ADFB6 /* AUBaseHelper.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + 8D01CCC60486CAD60068D4B7 /* PocketVerbs */ = { + isa = PBXNativeTarget; + buildConfigurationList = 3E4BA243089833B7007656EC /* Build configuration list for PBXNativeTarget "PocketVerbs" */; + buildPhases = ( + 8D01CCC70486CAD60068D4B7 /* Headers */, + 8D01CCC90486CAD60068D4B7 /* Resources */, + 8D01CCCB0486CAD60068D4B7 /* Sources */, + 8D01CCCD0486CAD60068D4B7 /* Frameworks */, + 8D01CCCF0486CAD60068D4B7 /* Rez */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = PocketVerbs; + productInstallPath = "$(HOME)/Library/Bundles"; + productName = PocketVerbs; + productReference = 8D01CCD20486CAD60068D4B7 /* PocketVerbs.component */; + productType = "com.apple.product-type.bundle"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 089C1669FE841209C02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 3E4BA247089833B7007656EC /* Build configuration list for PBXProject "PocketVerbs" */; + compatibilityVersion = "Xcode 3.1"; + developmentRegion = English; + hasScannedForEncodings = 1; + knownRegions = ( + English, + Japanese, + French, + German, + ); + mainGroup = 089C166AFE841209C02AAC07 /* PocketVerbs */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 8D01CCC60486CAD60068D4B7 /* PocketVerbs */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 8D01CCC90486CAD60068D4B7 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8D01CCCA0486CAD60068D4B7 /* InfoPlist.strings in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXRezBuildPhase section */ + 8D01CCCF0486CAD60068D4B7 /* Rez */ = { + isa = PBXRezBuildPhase; + buildActionMask = 2147483647; + files = ( + 8B4119B70749654200361ABE /* PocketVerbs.r in Rez */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXRezBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 8D01CCCB0486CAD60068D4B7 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 8BA05A6B0720730100365D66 /* PocketVerbs.cpp in Sources */, + 8BA05AAE072073D300365D66 /* AUBase.cpp in Sources */, + 8BA05AB0072073D300365D66 /* AUDispatch.cpp in Sources */, + 8BA05AB2072073D300365D66 /* AUInputElement.cpp in Sources */, + 8BA05AB4072073D300365D66 /* AUOutputElement.cpp in Sources */, + 8BA05AB7072073D300365D66 /* AUScopeElement.cpp in Sources */, + 8BA05AB9072073D300365D66 /* ComponentBase.cpp in Sources */, + 8BA05AC6072073D300365D66 /* AUEffectBase.cpp in Sources */, + 8BA05AD2072073D300365D66 /* AUBuffer.cpp in Sources */, + 8BA05AD4072073D300365D66 /* AUDebugDispatcher.cpp in Sources */, + 8BA05AE50720742100365D66 /* CAAudioChannelLayout.cpp in Sources */, + 8BA05AE70720742100365D66 /* CAMutex.cpp in Sources */, + 8BA05AE90720742100365D66 /* CAStreamBasicDescription.cpp in Sources */, + 8BA05B070720754400365D66 /* CAAUParameter.cpp in Sources */, + 3EEA126E089847F5002C6BFC /* CAVectorUnit.cpp in Sources */, + F7C347F00ECE5AF8008ADFB6 /* AUBaseHelper.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXVariantGroup section */ + 089C167DFE841241C02AAC07 /* InfoPlist.strings */ = { + isa = PBXVariantGroup; + children = ( + 089C167EFE841241C02AAC07 /* English */, + ); + name = InfoPlist.strings; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 3E4BA244089833B7007656EC /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + EXPORTED_SYMBOLS_FILE = PocketVerbs.exp; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GENERATE_PKGINFO_FILE = YES; + INFOPLIST_FILE = Info.plist; + INSTALL_PATH = "$(HOME)/Library/Audio/Plug-Ins/Components/"; + LIBRARY_STYLE = Bundle; + OTHER_LDFLAGS = "-bundle"; + OTHER_REZFLAGS = "-d ppc_$ppc -d i386_$i386 -d ppc64_$ppc64 -d x86_64_$x86_64 -I /System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework/Versions/A/Headers -I \"$(DEVELOPER_DIR)/Examples/CoreAudio/AudioUnits/AUPublic/AUBase\""; + PRODUCT_NAME = PocketVerbs; + WRAPPER_EXTENSION = component; + }; + name = Debug; + }; + 3E4BA245089833B7007656EC /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + x86_64, + ); + EXPORTED_SYMBOLS_FILE = PocketVerbs.exp; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GENERATE_PKGINFO_FILE = YES; + INFOPLIST_FILE = Info.plist; + INSTALL_PATH = "$(HOME)/Library/Audio/Plug-Ins/Components/"; + LIBRARY_STYLE = Bundle; + MACOSX_DEPLOYMENT_TARGET = 10.4; + OTHER_LDFLAGS = "-bundle"; + OTHER_REZFLAGS = "-d ppc_$ppc -d i386_$i386 -d x86_64_$x86_64 -I /System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework/Versions/A/Headers -I \"$(DEVELOPER_DIR)/Examples/CoreAudio/AudioUnits/AUPublic/AUBase\""; + PRODUCT_NAME = PocketVerbs; + SDKROOT = macosx10.5; + STRIP_INSTALLED_PRODUCT = YES; + STRIP_STYLE = all; + WRAPPER_EXTENSION = component; + }; + name = Release; + }; + 3E4BA248089833B7007656EC /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_64_BIT)"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_C_LANGUAGE_STANDARD = c99; + SDKROOT = macosx10.6; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + }; + name = Debug; + }; + 3E4BA249089833B7007656EC /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_64_BIT)"; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_C_LANGUAGE_STANDARD = c99; + SDKROOT = macosx10.6; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 3E4BA243089833B7007656EC /* Build configuration list for PBXNativeTarget "PocketVerbs" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 3E4BA244089833B7007656EC /* Debug */, + 3E4BA245089833B7007656EC /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + 3E4BA247089833B7007656EC /* Build configuration list for PBXProject "PocketVerbs" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 3E4BA248089833B7007656EC /* Debug */, + 3E4BA249089833B7007656EC /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = 089C1669FE841209C02AAC07 /* Project object */; +} diff --git a/plugins/MacAU/PocketVerbs/PocketVerbsVersion.h b/plugins/MacAU/PocketVerbs/PocketVerbsVersion.h new file mode 100755 index 0000000..b05ac2d --- /dev/null +++ b/plugins/MacAU/PocketVerbs/PocketVerbsVersion.h @@ -0,0 +1,58 @@ +/* +* File: PocketVerbsVersion.h +* +* Version: 1.0 +* +* Created: 8/19/12 +* +* Copyright: Copyright © 2012 Airwindows, All Rights Reserved +* +* Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in +* consideration of your agreement to the following terms, and your use, installation, modification +* or redistribution of this Apple software constitutes acceptance of these terms. If you do +* not agree with these terms, please do not use, install, modify or redistribute this Apple +* software. +* +* In consideration of your agreement to abide by the following terms, and subject to these terms, +* Apple grants you a personal, non-exclusive license, under Apple's copyrights in this +* original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the +* Apple Software, with or without modifications, in source and/or binary forms; provided that if you +* redistribute the Apple Software in its entirety and without modifications, you must retain this +* notice and the following text and disclaimers in all such redistributions of the Apple Software. +* Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to +* endorse or promote products derived from the Apple Software without specific prior written +* permission from Apple. Except as expressly stated in this notice, no other rights or +* licenses, express or implied, are granted by Apple herein, including but not limited to any +* patent rights that may be infringed by your derivative works or by other works in which the +* Apple Software may be incorporated. +* +* The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO WARRANTIES, EXPRESS OR +* IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY +* AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE +* OR IN COMBINATION WITH YOUR PRODUCTS. +* +* IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL +* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, +* REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER +* UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN +* IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +* +*/ +#ifndef __PocketVerbsVersion_h__ +#define __PocketVerbsVersion_h__ + + +#ifdef DEBUG + #define kPocketVerbsVersion 0xFFFFFFFF +#else + #define kPocketVerbsVersion 0x00010000 +#endif + +//~~~~~~~~~~~~~~ Change!!! ~~~~~~~~~~~~~~~~~~~~~// +#define PocketVerbs_COMP_MANF 'Dthr' +#define PocketVerbs_COMP_SUBTYPE 'pkvb' +//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~// + +#endif + diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/categories.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/categories.pbxbtree new file mode 100755 index 0000000..d3f6bb3 Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/categories.pbxbtree differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/cdecls.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/cdecls.pbxbtree new file mode 100755 index 0000000..4821b57 Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/cdecls.pbxbtree differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/decls.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/decls.pbxbtree new file mode 100755 index 0000000..4a40b5d Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/decls.pbxbtree differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/files.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/files.pbxbtree new file mode 100755 index 0000000..f9bccaa Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/files.pbxbtree differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/imports.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/imports.pbxbtree new file mode 100755 index 0000000..9d9ec0a Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/imports.pbxbtree differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/pbxindex.header b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/pbxindex.header new file mode 100755 index 0000000..6131daa Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/pbxindex.header differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/protocols.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/protocols.pbxbtree new file mode 100755 index 0000000..d3f6bb3 Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/protocols.pbxbtree differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/refs.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/refs.pbxbtree new file mode 100755 index 0000000..aca451d Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/refs.pbxbtree differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/control b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/control new file mode 100755 index 0000000..d0d3ded Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/control differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/strings b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/strings new file mode 100755 index 0000000..8c8a0b1 Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/strings differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/subclasses.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/subclasses.pbxbtree new file mode 100755 index 0000000..712f37a Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/subclasses.pbxbtree differ diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/symbols0.pbxsymbols b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/symbols0.pbxsymbols new file mode 100755 index 0000000..46e93f5 Binary files /dev/null and b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/symbols0.pbxsymbols differ diff --git a/plugins/MacAU/PocketVerbs/version.plist b/plugins/MacAU/PocketVerbs/version.plist new file mode 100755 index 0000000..11edf8a --- /dev/null +++ b/plugins/MacAU/PocketVerbs/version.plist @@ -0,0 +1,16 @@ + + + + + BuildVersion + 3 + CFBundleShortVersionString + 1.0 + CFBundleVersion + 1.0 + ProjectName + ${EXECUTABLE_NAME} + SourceVersion + 590000 + + diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser new file mode 100755 index 0000000..e737620 --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser @@ -0,0 +1,132 @@ +// !$*UTF8*$! +{ + 089C1669FE841209C02AAC07 /* Project object */ = { + activeBuildConfigurationName = Release; + activeTarget = 8D01CCC60486CAD60068D4B7 /* PocketVerbs */; + codeSenseManager = 8B02375F1D42B1C400E1E8C8 /* Code sense */; + perUserDictionary = { + PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 364, + 20, + 48, + 43, + 43, + 20, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + PBXFileDataSource_Target_ColumnID, + ); + }; + PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 324, + 60, + 20, + 48, + 43, + 43, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXTargetDataSource_PrimaryAttribute, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + ); + }; + PBXPerProjectTemplateStateSaveDate = 595640489; + PBXWorkspaceStateSaveDate = 595640489; + }; + perUserProjectItems = { + 8B063A4B2380C14D00606DBC /* PBXTextBookmark */ = 8B063A4B2380C14D00606DBC /* PBXTextBookmark */; + 8B063A4C2380C14D00606DBC /* PBXTextBookmark */ = 8B063A4C2380C14D00606DBC /* PBXTextBookmark */; + }; + sourceControlManager = 8B02375E1D42B1C400E1E8C8 /* Source Control */; + userBuildSettings = { + }; + }; + 2407DEB6089929BA00EB68BF /* PocketVerbs.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {740, 5148}}"; + sepNavSelRange = "{504, 0}"; + sepNavVisRange = "{12728, 2478}"; + sepNavWindowFrame = "{{53, 63}, {784, 815}}"; + }; + }; + 245463B80991757100464AD3 /* PocketVerbs.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {848, 3926}}"; + sepNavSelRange = "{5331, 0}"; + sepNavVisRange = "{3913, 931}"; + sepNavWindowFrame = "{{8, 57}, {895, 821}}"; + }; + }; + 24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {859, 20267}}"; + sepNavSelRange = "{10616, 0}"; + sepNavVisRange = "{9653, 2414}"; + sepNavWindowFrame = "{{15, 42}, {895, 831}}"; + }; + }; + 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {600, 239694}}"; + sepNavSelRange = "{626758, 0}"; + sepNavVisRange = "{553439, 143}"; + sepNavWindowFrame = "{{496, 57}, {895, 821}}"; + }; + }; + 8B02375E1D42B1C400E1E8C8 /* Source Control */ = { + isa = PBXSourceControlManager; + fallbackIsa = XCSourceControlManager; + isSCMEnabled = 0; + scmConfiguration = { + repositoryNamesForRoots = { + "" = ""; + }; + }; + }; + 8B02375F1D42B1C400E1E8C8 /* Code sense */ = { + isa = PBXCodeSenseManager; + indexTemplatePath = ""; + }; + 8B063A4B2380C14D00606DBC /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */; + name = "PocketVerbsProc.cpp: 18359"; + rLen = 0; + rLoc = 626758; + rType = 0; + vrLen = 143; + vrLoc = 553435; + }; + 8B063A4C2380C14D00606DBC /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */; + name = "PocketVerbsProc.cpp: 18359"; + rLen = 0; + rLoc = 626758; + rType = 0; + vrLen = 143; + vrLoc = 553439; + }; + 8D01CCC60486CAD60068D4B7 /* PocketVerbs */ = { + activeExec = 0; + }; +} diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 new file mode 100755 index 0000000..3c65e1f --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 @@ -0,0 +1,1528 @@ + + + + + ActivePerspectiveName + Project + AllowedModules + + + BundleLoadPath + + MaxInstances + n + Module + PBXSmartGroupTreeModule + Name + Groups and Files Outline View + + + BundleLoadPath + + MaxInstances + n + Module + PBXNavigatorGroup + Name + Editor + + + BundleLoadPath + + MaxInstances + n + Module + XCTaskListModule + Name + Task List + + + BundleLoadPath + + MaxInstances + n + Module + XCDetailModule + Name + File and Smart Group Detail Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXBuildResultsModule + Name + Detailed Build Results Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXProjectFindModule + Name + Project Batch Find Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCProjectFormatConflictsModule + Name + Project Format Conflicts List + + + BundleLoadPath + + MaxInstances + n + Module + PBXBookmarksModule + Name + Bookmarks Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXClassBrowserModule + Name + Class Browser + + + BundleLoadPath + + MaxInstances + n + Module + PBXCVSModule + Name + Source Code Control Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXDebugBreakpointsModule + Name + Debug Breakpoints Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCDockableInspector + Name + Inspector + + + BundleLoadPath + + MaxInstances + n + Module + PBXOpenQuicklyModule + Name + Open Quickly Tool + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugSessionModule + Name + Debugger + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugCLIModule + Name + Debug Console + + + BundleLoadPath + + MaxInstances + n + Module + XCSnapshotModule + Name + Snapshots Tool + + + BundlePath + /Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources + Description + AIODescriptionKey + DockingSystemVisible + + Extension + perspectivev3 + FavBarConfig + + PBXProjectModuleGUID + 8B02375D1D42B1C400E1E8C8 + XCBarModuleItemNames + + XCBarModuleItems + + + FirstTimeWindowDisplayed + + Identifier + com.apple.perspectives.project.defaultV3 + MajorVersion + 34 + MinorVersion + 0 + Name + All-In-One + Notifications + + + XCObserverAutoDisconnectKey + + XCObserverDefintionKey + + PBXStatusErrorsKey + 0 + + XCObserverFactoryKey + XCPerspectivesSpecificationIdentifier + XCObserverGUIDKey + XCObserverProjectIdentifier + XCObserverNotificationKey + PBXStatusBuildStateMessageNotification + XCObserverTargetKey + XCMainBuildResultsModuleGUID + XCObserverTriggerKey + awakenModuleWithObserver: + XCObserverValidationKey + + PBXStatusErrorsKey + 2 + + + + OpenEditors + + PerspectiveWidths + + 810 + 810 + + Perspectives + + + ChosenToolbarItems + + XCToolbarPerspectiveControl + NSToolbarSeparatorItem + active-combo-popup + action + NSToolbarFlexibleSpaceItem + debugger-enable-breakpoints + build-and-go + com.apple.ide.PBXToolbarStopButton + get-info + NSToolbarFlexibleSpaceItem + com.apple.pbx.toolbar.searchfield + + ControllerClassBaseName + + IconName + WindowOfProject + Identifier + perspective.project + IsVertical + + Layout + + + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + 1C77FABC04509CD000000102 + + PBXProjectModuleGUID + 1CA23ED40692098700951B8B + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 185 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 089C166AFE841209C02AAC07 + 08FB77ADFE841716C02AAC07 + 1C37FBAC04509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 6 + 4 + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {185, 428}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + + + GeometryConfiguration + + Frame + {{0, 0}, {202, 446}} + GroupTreeTableConfiguration + + MainColumn + 185 + + RubberWindowFrame + 31 381 810 487 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 202pt + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 8B0237581D42B1C400E1E8C8 + PBXProjectModuleLabel + PocketVerbsProc.cpp + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 8B0237591D42B1C400E1E8C8 + PBXProjectModuleLabel + PocketVerbsProc.cpp + _historyCapacity + 0 + bookmark + 8B063A4C2380C14D00606DBC + history + + 8B063A4B2380C14D00606DBC + + + SplitCount + 1 + + StatusBarVisibility + + XCSharingToken + com.apple.Xcode.CommonNavigatorGroupSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {603, 117}} + RubberWindowFrame + 31 381 810 487 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 117pt + + + Proportion + 324pt + Tabs + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA23EDF0692099D00951B8B + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{10, 27}, {603, 297}} + + Module + XCDetailModule + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA23EE00692099D00951B8B + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{10, 31}, {603, 297}} + + Module + PBXProjectFindModule + + + ContentConfiguration + + PBXCVSModuleFilterTypeKey + 1032 + PBXProjectModuleGUID + 1CA23EE10692099D00951B8B + PBXProjectModuleLabel + SCM Results + + GeometryConfiguration + + Frame + {{10, 31}, {603, 297}} + + Module + PBXCVSModule + + + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build Results + XCBuildResultsTrigger_Collapse + 1023 + XCBuildResultsTrigger_Open + 1012 + + GeometryConfiguration + + Frame + {{10, 27}, {603, 297}} + RubberWindowFrame + 31 381 810 487 0 0 1440 878 + + Module + PBXBuildResultsModule + + + + + Proportion + 603pt + + + Name + Project + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + XCModuleDock + PBXNavigatorGroup + XCDockableTabModule + XCDetailModule + PBXProjectFindModule + PBXCVSModule + PBXBuildResultsModule + + TableOfContents + + 8B063A4D2380C14D00606DBC + 1CA23ED40692098700951B8B + 8B063A4E2380C14D00606DBC + 8B0237581D42B1C400E1E8C8 + 8B063A4F2380C14D00606DBC + 1CA23EDF0692099D00951B8B + 1CA23EE00692099D00951B8B + 1CA23EE10692099D00951B8B + XCMainBuildResultsModuleGUID + + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarConfiguration + xcode.toolbar.config.defaultV3 + + + ChosenToolbarItems + + XCToolbarPerspectiveControl + NSToolbarSeparatorItem + active-combo-popup + NSToolbarFlexibleSpaceItem + debugger-enable-breakpoints + build-and-go + com.apple.ide.PBXToolbarStopButton + debugger-restart-executable + debugger-pause + debugger-step-over + debugger-step-into + debugger-step-out + NSToolbarFlexibleSpaceItem + servicesModulebreakpoints + debugger-show-console-window + + ControllerClassBaseName + PBXDebugSessionModule + IconName + DebugTabIcon + Identifier + perspective.debug + IsVertical + + Layout + + + ContentConfiguration + + PBXProjectModuleGUID + 1CCC7628064C1048000F2A68 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {424, 270}} + + Module + PBXDebugCLIModule + Proportion + 270pt + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {395, 213}} + {{395, 0}, {415, 213}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {810, 213}} + {{0, 213}, {810, 225}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1CCC7629064C1048000F2A68 + PBXProjectModuleLabel + Debug + + GeometryConfiguration + + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 7}, {810, 438}} + PBXDebugSessionStackFrameViewKey + + DebugVariablesTableConfiguration + + Name + 120 + Value + 85 + Summary + 185 + + Frame + {{395, 0}, {415, 213}} + + + Module + PBXDebugSessionModule + Proportion + 438pt + + + Name + Debug + ServiceClasses + + XCModuleDock + PBXDebugCLIModule + PBXDebugSessionModule + PBXDebugProcessAndThreadModule + PBXDebugProcessViewModule + PBXDebugThreadViewModule + PBXDebugStackFrameViewModule + PBXNavigatorGroup + + TableOfContents + + 8B063A272380BEA500606DBC + 1CCC7628064C1048000F2A68 + 1CCC7629064C1048000F2A68 + 8B063A282380BEA500606DBC + 8B063A292380BEA500606DBC + 8B063A2A2380BEA500606DBC + 8B063A2B2380BEA500606DBC + 8B063A2C2380BEA500606DBC + + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarConfiguration + xcode.toolbar.config.debugV3 + + + PerspectivesBarVisible + + ShelfIsVisible + + SourceDescription + file at '/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecification.xcperspec' + StatusbarIsVisible + + TimeStamp + 595640653.28914702 + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarDisplayMode + 1 + ToolbarIsVisible + + ToolbarSizeMode + 2 + Type + Perspectives + UpdateMessage + + WindowJustification + 5 + WindowOrderList + + /Users/christopherjohnson/Desktop/Plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj + + WindowString + 31 381 810 487 0 0 1440 878 + WindowToolsV3 + + + Identifier + windowTool.debugger + Layout + + + Dock + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {317, 164}} + {{317, 0}, {377, 164}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {694, 164}} + {{0, 164}, {694, 216}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1C162984064C10D400B95A72 + PBXProjectModuleLabel + Debug - GLUTExamples (Underwater) + + GeometryConfiguration + + DebugConsoleDrawerSize + {100, 120} + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 0}, {694, 380}} + RubberWindowFrame + 321 238 694 422 0 0 1440 878 + + Module + PBXDebugSessionModule + Proportion + 100% + + + Proportion + 100% + + + Name + Debugger + ServiceClasses + + PBXDebugSessionModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CD10A99069EF8BA00B06720 + 1C0AD2AB069F1E9B00FABCE6 + 1C162984064C10D400B95A72 + 1C0AD2AC069F1E9B00FABCE6 + + ToolbarConfiguration + xcode.toolbar.config.debugV3 + WindowString + 321 238 694 422 0 0 1440 878 + WindowToolGUID + 1CD10A99069EF8BA00B06720 + WindowToolIsVisible + 0 + + + Identifier + windowTool.build + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528F0623707200166675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD052900623707200166675 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {500, 215}} + RubberWindowFrame + 192 257 500 500 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 218pt + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build Results + + GeometryConfiguration + + Frame + {{0, 222}, {500, 236}} + RubberWindowFrame + 192 257 500 500 0 0 1280 1002 + + Module + PBXBuildResultsModule + Proportion + 236pt + + + Proportion + 458pt + + + Name + Build Results + ServiceClasses + + PBXBuildResultsModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAA5065D492600B07095 + 1C78EAA6065D492600B07095 + 1CD0528F0623707200166675 + XCMainBuildResultsModuleGUID + + ToolbarConfiguration + xcode.toolbar.config.buildV3 + WindowString + 192 257 500 500 0 0 1280 1002 + + + Identifier + windowTool.find + Layout + + + Dock + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CDD528C0622207200134675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD0528D0623707200166675 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {781, 167}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 781pt + + + Proportion + 50% + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528E0623707200166675 + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{8, 0}, {773, 254}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXProjectFindModule + Proportion + 50% + + + Proportion + 428pt + + + Name + Project Find + ServiceClasses + + PBXProjectFindModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C530D57069F1CE1000CFCEE + 1C530D58069F1CE1000CFCEE + 1C530D59069F1CE1000CFCEE + 1CDD528C0622207200134675 + 1C530D5A069F1CE1000CFCEE + 1CE0B1FE06471DED0097A5F4 + 1CD0528E0623707200166675 + + WindowString + 62 385 781 470 0 0 1440 878 + WindowToolGUID + 1C530D57069F1CE1000CFCEE + WindowToolIsVisible + 0 + + + Identifier + windowTool.snapshots + Layout + + + Dock + + + Module + XCSnapshotModule + Proportion + 100% + + + Proportion + 100% + + + Name + Snapshots + ServiceClasses + + XCSnapshotModule + + StatusbarIsVisible + Yes + ToolbarConfiguration + xcode.toolbar.config.snapshots + WindowString + 315 824 300 550 0 0 1440 878 + WindowToolIsVisible + Yes + + + Identifier + windowTool.debuggerConsole + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAAC065D492600B07095 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {700, 358}} + RubberWindowFrame + 149 87 700 400 0 0 1440 878 + + Module + PBXDebugCLIModule + Proportion + 358pt + + + Proportion + 358pt + + + Name + Debugger Console + ServiceClasses + + PBXDebugCLIModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C530D5B069F1CE1000CFCEE + 1C530D5C069F1CE1000CFCEE + 1C78EAAC065D492600B07095 + + ToolbarConfiguration + xcode.toolbar.config.consoleV3 + WindowString + 149 87 440 400 0 0 1440 878 + WindowToolGUID + 1C530D5B069F1CE1000CFCEE + WindowToolIsVisible + 0 + + + Identifier + windowTool.scm + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAB2065D492600B07095 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1C78EAB3065D492600B07095 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {452, 0}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 0pt + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD052920623707200166675 + PBXProjectModuleLabel + SCM + + GeometryConfiguration + + ConsoleFrame + {{0, 259}, {452, 0}} + Frame + {{0, 7}, {452, 259}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + TableConfiguration + + Status + 30 + FileName + 199 + Path + 197.09500122070312 + + TableFrame + {{0, 0}, {452, 250}} + + Module + PBXCVSModule + Proportion + 262pt + + + Proportion + 266pt + + + Name + SCM + ServiceClasses + + PBXCVSModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAB4065D492600B07095 + 1C78EAB5065D492600B07095 + 1C78EAB2065D492600B07095 + 1CD052920623707200166675 + + ToolbarConfiguration + xcode.toolbar.config.scmV3 + WindowString + 743 379 452 308 0 0 1280 1002 + + + Identifier + windowTool.breakpoints + IsVertical + 0 + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C77FABC04509CD000000102 + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + no + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 168 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 1C77FABC04509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {168, 350}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 0 + + GeometryConfiguration + + Frame + {{0, 0}, {185, 368}} + GroupTreeTableConfiguration + + MainColumn + 168 + + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 185pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA1AED706398EBD00589147 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{190, 0}, {554, 368}} + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + XCDetailModule + Proportion + 554pt + + + Proportion + 368pt + + + MajorVersion + 3 + MinorVersion + 0 + Name + Breakpoints + ServiceClasses + + PBXSmartGroupTreeModule + XCDetailModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CDDB66807F98D9800BB5817 + 1CDDB66907F98D9800BB5817 + 1CE0B1FE06471DED0097A5F4 + 1CA1AED706398EBD00589147 + + ToolbarConfiguration + xcode.toolbar.config.breakpointsV3 + WindowString + 315 424 744 409 0 0 1440 878 + WindowToolGUID + 1CDDB66807F98D9800BB5817 + WindowToolIsVisible + 1 + + + Identifier + windowTool.debugAnimator + Layout + + + Dock + + + Module + PBXNavigatorGroup + Proportion + 100% + + + Proportion + 100% + + + Name + Debug Visualizer + ServiceClasses + + PBXNavigatorGroup + + StatusbarIsVisible + 1 + ToolbarConfiguration + xcode.toolbar.config.debugAnimatorV3 + WindowString + 100 100 700 500 0 0 1280 1002 + + + Identifier + windowTool.bookmarks + Layout + + + Dock + + + Module + PBXBookmarksModule + Proportion + 166pt + + + Proportion + 166pt + + + Name + Bookmarks + ServiceClasses + + PBXBookmarksModule + + StatusbarIsVisible + 0 + WindowString + 538 42 401 187 0 0 1280 1002 + + + FirstTimeWindowDisplayed + + Identifier + windowTool.projectFormatConflicts + IsVertical + + Layout + + + Dock + + + BecomeActive + + ContentConfiguration + + PBXProjectModuleGUID + 8BCAE52E1D49920D0047D4BD + + GeometryConfiguration + + Frame + {{0, 0}, {472, 302}} + RubberWindowFrame + 569 378 472 322 0 0 1440 878 + + Module + XCProjectFormatConflictsModule + Proportion + 302pt + + + Proportion + 302pt + + + Name + Project Format Conflicts + ServiceClasses + + XCProjectFormatConflictsModule + + StatusbarIsVisible + + TableOfContents + + 8BCAE52F1D49920D0047D4BD + 8BCAE5301D49920D0047D4BD + 8BCAE52E1D49920D0047D4BD + + WindowContentMinSize + 450 300 + WindowString + 569 378 472 322 0 0 1440 878 + WindowToolGUID + 8BCAE52F1D49920D0047D4BD + WindowToolIsVisible + + + + Identifier + windowTool.classBrowser + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + OptionsSetName + Hierarchy, all classes + PBXProjectModuleGUID + 1CA6456E063B45B4001379D8 + PBXProjectModuleLabel + Class Browser - NSObject + + GeometryConfiguration + + ClassesFrame + {{0, 0}, {369, 96}} + ClassesTreeTableConfiguration + + PBXClassNameColumnIdentifier + 208 + PBXClassBookColumnIdentifier + 22 + + Frame + {{0, 0}, {616, 353}} + MembersFrame + {{0, 105}, {369, 395}} + MembersTreeTableConfiguration + + PBXMemberTypeIconColumnIdentifier + 22 + PBXMemberNameColumnIdentifier + 216 + PBXMemberTypeColumnIdentifier + 94 + PBXMemberBookColumnIdentifier + 22 + + PBXModuleWindowStatusBarHidden2 + 1 + RubberWindowFrame + 597 125 616 374 0 0 1280 1002 + + Module + PBXClassBrowserModule + Proportion + 354pt + + + Proportion + 354pt + + + Name + Class Browser + ServiceClasses + + PBXClassBrowserModule + + StatusbarIsVisible + 0 + TableOfContents + + 1C78EABA065D492600B07095 + 1C78EABB065D492600B07095 + 1CA6456E063B45B4001379D8 + + ToolbarConfiguration + xcode.toolbar.config.classbrowser + WindowString + 597 125 616 374 0 0 1280 1002 + + + Identifier + windowTool.refactoring + IncludeInToolsMenu + 0 + Layout + + + Dock + + + BecomeActive + 1 + GeometryConfiguration + + Frame + {0, 0}, {500, 335} + RubberWindowFrame + {0, 0}, {500, 335} + + Module + XCRefactoringModule + Proportion + 100% + + + Proportion + 100% + + + Name + Refactoring + ServiceClasses + + XCRefactoringModule + + WindowString + 200 200 500 356 0 0 1920 1200 + + + + diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj new file mode 100755 index 0000000..b989f10 --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj @@ -0,0 +1,2201 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 42; + objects = { + +/* Begin PBXBuildFile section */ + 2407DEB9089929BA00EB68BF /* PocketVerbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2407DEB6089929BA00EB68BF /* PocketVerbs.cpp */; }; + 245463B90991757100464AD3 /* PocketVerbs.h in Headers */ = {isa = PBXBuildFile; fileRef = 245463B80991757100464AD3 /* PocketVerbs.h */; }; + 24A202190F90D1DE003BB5A7 /* aeffect.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FF910F90D1DD003BB5A7 /* aeffect.h */; }; + 24A2021A0F90D1DE003BB5A7 /* aeffectx.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FF920F90D1DD003BB5A7 /* aeffectx.h */; }; + 24A2021B0F90D1DE003BB5A7 /* vstfxstore.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FF930F90D1DD003BB5A7 /* vstfxstore.h */; }; + 24A2021D0F90D1DE003BB5A7 /* adelay.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FF990F90D1DD003BB5A7 /* adelay.h */; }; + 24A202240F90D1DE003BB5A7 /* sdeditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFA20F90D1DD003BB5A7 /* sdeditor.h */; }; + 24A202260F90D1DE003BB5A7 /* surrounddelay.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFA40F90D1DD003BB5A7 /* surrounddelay.h */; }; + 24A2022A0F90D1DE003BB5A7 /* again.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFAB0F90D1DD003BB5A7 /* again.h */; }; + 24A202330F90D1DE003BB5A7 /* gmnames.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFBF0F90D1DD003BB5A7 /* gmnames.h */; }; + 24A202350F90D1DE003BB5A7 /* vstxsynth.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFC10F90D1DD003BB5A7 /* vstxsynth.h */; }; + 24A202460F90D1DE003BB5A7 /* aeffeditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFD80F90D1DD003BB5A7 /* aeffeditor.h */; }; + 24A202480F90D1DE003BB5A7 /* audioeffect.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFDA0F90D1DD003BB5A7 /* audioeffect.h */; }; + 24A2024A0F90D1DE003BB5A7 /* audioeffectx.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFDC0F90D1DD003BB5A7 /* audioeffectx.h */; }; + 24A2024D0F90D1DE003BB5A7 /* cw_vst_prefix.pch++ in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFE20F90D1DD003BB5A7 /* cw_vst_prefix.pch++ */; }; + 24A202510F90D1DE003BB5A7 /* xcode_au_prefix.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFEC0F90D1DD003BB5A7 /* xcode_au_prefix.h */; }; + 24A202520F90D1DE003BB5A7 /* xcode_vst_prefix.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFED0F90D1DD003BB5A7 /* xcode_vst_prefix.h */; }; + 24A202680F90D1DE003BB5A7 /* controlsgui.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A200050F90D1DD003BB5A7 /* controlsgui.h */; }; + 24A2026A0F90D1DE003BB5A7 /* pdrawtesteditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A200070F90D1DD003BB5A7 /* pdrawtesteditor.h */; }; + 24A2026C0F90D1DE003BB5A7 /* pdrawtesteffect.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A200090F90D1DD003BB5A7 /* pdrawtesteffect.h */; }; + 24A2026F0F90D1DE003BB5A7 /* pdrawtestview.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2000C0F90D1DD003BB5A7 /* pdrawtestview.h */; }; + 24A202710F90D1DE003BB5A7 /* pprimitivesviews.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2000E0F90D1DD003BB5A7 /* pprimitivesviews.h */; }; + 24A202780F90D1DE003BB5A7 /* aeffguieditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A200180F90D1DD003BB5A7 /* aeffguieditor.h */; }; + 24A2027A0F90D1DE003BB5A7 /* cfileselector.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2001A0F90D1DD003BB5A7 /* cfileselector.h */; }; + 24A2027D0F90D1DE003BB5A7 /* cscrollview.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2001D0F90D1DD003BB5A7 /* cscrollview.h */; }; + 24A2027F0F90D1DE003BB5A7 /* ctabview.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2001F0F90D1DD003BB5A7 /* ctabview.h */; }; + 24A203A50F90D1DE003BB5A7 /* plugguieditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A201470F90D1DE003BB5A7 /* plugguieditor.h */; }; + 24A203A70F90D1DE003BB5A7 /* vstcontrols.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A201490F90D1DE003BB5A7 /* vstcontrols.h */; }; + 24A203A90F90D1DE003BB5A7 /* vstgui.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014B0F90D1DE003BB5A7 /* vstgui.h */; }; + 24A203AA0F90D1DE003BB5A7 /* vstkeycode.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014C0F90D1DE003BB5A7 /* vstkeycode.h */; }; + 24A203AB0F90D1DE003BB5A7 /* vstplugscarbon.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014D0F90D1DE003BB5A7 /* vstplugscarbon.h */; }; + 24A203AC0F90D1DE003BB5A7 /* vstplugsmac.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014E0F90D1DE003BB5A7 /* vstplugsmac.h */; }; + 24A203AD0F90D1DE003BB5A7 /* vstplugsmacho.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014F0F90D1DE003BB5A7 /* vstplugsmacho.h */; }; + 24A203AE0F90D1DE003BB5A7 /* vstplugsquartz.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A201500F90D1DE003BB5A7 /* vstplugsquartz.h */; }; + 24A203CB0F90D251003BB5A7 /* audioeffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 24A2FFD90F90D1DD003BB5A7 /* audioeffect.cpp */; }; + 24A203CC0F90D251003BB5A7 /* audioeffectx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */; }; + 24A203CD0F90D251003BB5A7 /* vstplugmain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 24A2FFDD0F90D1DD003BB5A7 /* vstplugmain.cpp */; }; + 24CFB70407E7A0220081BD57 /* PkgInfo in Resources */ = {isa = PBXBuildFile; fileRef = 24CFB70307E7A0220081BD57 /* PkgInfo */; }; + 24D8287009A914000093AEF8 /* PocketVerbsProc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */; }; + 24D8287F09A9164A0093AEF8 /* xcode_vst_prefix.h in Headers */ = {isa = PBXBuildFile; fileRef = 24D8287E09A9164A0093AEF8 /* xcode_vst_prefix.h */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 24A203D60F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 8D01CCD20486CAD60068D4B7; + remoteInfo = again; + }; + 24A203D80F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = F4476974093DAE42008998C4; + remoteInfo = adelay; + }; + 24A203DA0F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = F4FF52220929FBF500DDED7A; + remoteInfo = vstxsynth; + }; + 24A203DC0F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = F4476A10093DCAF9008998C4; + remoteInfo = surrounddelay; + }; + 24A203DE0F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = F4FF52F3092A312800DDED7A; + remoteInfo = minihost; + }; + 24A203E40F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */; + proxyType = 2; + remoteGlobalIDString = 8D01CCD20486CAD60068D4B7; + remoteInfo = AudioUnit; + }; + 24A203E60F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */; + proxyType = 2; + remoteGlobalIDString = F4C9F1D407B2320800010DAD; + remoteInfo = VST; + }; + 24A203EC0F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = 8D01CCD20486CAD60068D4B7; + remoteInfo = AudioUnit; + }; + 24A203EE0F90D272003BB5A7 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */; + proxyType = 2; + remoteGlobalIDString = F4C9F1D407B2320800010DAD; + remoteInfo = VST; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXFileReference section */ + 08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = ""; }; + 2407DE920899296600EB68BF /* PocketVerbs.vst */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = PocketVerbs.vst; sourceTree = BUILT_PRODUCTS_DIR; }; + 2407DEB6089929BA00EB68BF /* PocketVerbs.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = PocketVerbs.cpp; path = source/PocketVerbs.cpp; sourceTree = ""; }; + 2434720A098313350063BBF1 /* QuickTime.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = QuickTime.framework; path = /System/Library/Frameworks/QuickTime.framework; sourceTree = ""; }; + 245463B80991757100464AD3 /* PocketVerbs.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = PocketVerbs.h; path = source/PocketVerbs.h; sourceTree = ""; }; + 24A200000F90D1DD003BB5A7 /* bmp10014.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10014.bmp; sourceTree = ""; }; + 24A200010F90D1DD003BB5A7 /* bmp10015.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10015.bmp; sourceTree = ""; }; + 24A200020F90D1DD003BB5A7 /* bmp10016.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10016.bmp; sourceTree = ""; }; + 24A200040F90D1DD003BB5A7 /* controlsgui.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = controlsgui.cpp; sourceTree = ""; }; + 24A200050F90D1DD003BB5A7 /* controlsgui.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = controlsgui.h; sourceTree = ""; }; + 24A200060F90D1DD003BB5A7 /* pdrawtesteditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pdrawtesteditor.cpp; sourceTree = ""; }; + 24A200070F90D1DD003BB5A7 /* pdrawtesteditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pdrawtesteditor.h; sourceTree = ""; }; + 24A200080F90D1DD003BB5A7 /* pdrawtesteffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pdrawtesteffect.cpp; sourceTree = ""; }; + 24A200090F90D1DD003BB5A7 /* pdrawtesteffect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pdrawtesteffect.h; sourceTree = ""; }; + 24A2000A0F90D1DD003BB5A7 /* pdrawtestmain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pdrawtestmain.cpp; sourceTree = ""; }; + 24A2000B0F90D1DD003BB5A7 /* pdrawtestview.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pdrawtestview.cpp; sourceTree = ""; }; + 24A2000C0F90D1DD003BB5A7 /* pdrawtestview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pdrawtestview.h; sourceTree = ""; }; + 24A2000D0F90D1DD003BB5A7 /* pprimitivesviews.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pprimitivesviews.cpp; sourceTree = ""; }; + 24A2000E0F90D1DD003BB5A7 /* pprimitivesviews.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pprimitivesviews.h; sourceTree = ""; }; + 24A200100F90D1DD003BB5A7 /* drawtest.def */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.def; sourceTree = ""; }; + 24A200110F90D1DD003BB5A7 /* drawtest.rc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.rc; sourceTree = ""; }; + 24A200120F90D1DD003BB5A7 /* drawtest.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = drawtest.vcproj; sourceTree = ""; }; + 24A200140F90D1DD003BB5A7 /* drawtest.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.dsp; sourceTree = ""; }; + 24A200150F90D1DD003BB5A7 /* drawtest.dsw */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.dsw; sourceTree = ""; }; + 24A200170F90D1DD003BB5A7 /* aeffguieditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = aeffguieditor.cpp; sourceTree = ""; }; + 24A200180F90D1DD003BB5A7 /* aeffguieditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aeffguieditor.h; sourceTree = ""; }; + 24A200190F90D1DD003BB5A7 /* cfileselector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cfileselector.cpp; sourceTree = ""; }; + 24A2001A0F90D1DD003BB5A7 /* cfileselector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cfileselector.h; sourceTree = ""; }; + 24A2001B0F90D1DD003BB5A7 /* Changelog */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Changelog; sourceTree = ""; }; + 24A2001C0F90D1DD003BB5A7 /* cscrollview.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cscrollview.cpp; sourceTree = ""; }; + 24A2001D0F90D1DD003BB5A7 /* cscrollview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cscrollview.h; sourceTree = ""; }; + 24A2001E0F90D1DD003BB5A7 /* ctabview.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ctabview.cpp; sourceTree = ""; }; + 24A2001F0F90D1DD003BB5A7 /* ctabview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ctabview.h; sourceTree = ""; }; + 24A200220F90D1DD003BB5A7 /* aeffguieditor_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = aeffguieditor_8cpp.html; sourceTree = ""; }; + 24A200230F90D1DD003BB5A7 /* aeffguieditor_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = aeffguieditor_8h.html; sourceTree = ""; }; + 24A200240F90D1DD003BB5A7 /* annotated.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = annotated.html; sourceTree = ""; }; + 24A200250F90D1DD003BB5A7 /* cfileselector_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = cfileselector_8cpp.html; sourceTree = ""; }; + 24A200260F90D1DD003BB5A7 /* cfileselector_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = cfileselector_8h.html; sourceTree = ""; }; + 24A200270F90D1DD003BB5A7 /* class_a_eff_g_u_i_editor-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_a_eff_g_u_i_editor-members.html"; sourceTree = ""; }; + 24A200280F90D1DD003BB5A7 /* class_a_eff_g_u_i_editor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_a_eff_g_u_i_editor.html; sourceTree = ""; }; + 24A200290F90D1DD003BB5A7 /* class_c_anim_knob-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_anim_knob-members.html"; sourceTree = ""; }; + 24A2002A0F90D1DD003BB5A7 /* class_c_anim_knob.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_anim_knob.html; sourceTree = ""; }; + 24A2002B0F90D1DD003BB5A7 /* class_c_anim_knob.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_anim_knob.png; sourceTree = ""; }; + 24A2002C0F90D1DD003BB5A7 /* class_c_attribute_list_entry-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_attribute_list_entry-members.html"; sourceTree = ""; }; + 24A2002D0F90D1DD003BB5A7 /* class_c_attribute_list_entry.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_attribute_list_entry.html; sourceTree = ""; }; + 24A2002E0F90D1DD003BB5A7 /* class_c_auto_animation-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_auto_animation-members.html"; sourceTree = ""; }; + 24A2002F0F90D1DD003BB5A7 /* class_c_auto_animation.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_auto_animation.html; sourceTree = ""; }; + 24A200300F90D1DD003BB5A7 /* class_c_auto_animation.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_auto_animation.png; sourceTree = ""; }; + 24A200310F90D1DD003BB5A7 /* class_c_bitmap-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_bitmap-members.html"; sourceTree = ""; }; + 24A200320F90D1DD003BB5A7 /* class_c_bitmap.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_bitmap.html; sourceTree = ""; }; + 24A200330F90D1DD003BB5A7 /* class_c_bitmap.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_bitmap.png; sourceTree = ""; }; + 24A200340F90D1DD003BB5A7 /* class_c_c_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_c_view-members.html"; sourceTree = ""; }; + 24A200350F90D1DD003BB5A7 /* class_c_c_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_c_view.html; sourceTree = ""; }; + 24A200360F90D1DD003BB5A7 /* class_c_control-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_control-members.html"; sourceTree = ""; }; + 24A200370F90D1DD003BB5A7 /* class_c_control.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_control.html; sourceTree = ""; }; + 24A200380F90D1DD003BB5A7 /* class_c_control.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_control.png; sourceTree = ""; }; + 24A200390F90D1DD003BB5A7 /* class_c_control_listener-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_control_listener-members.html"; sourceTree = ""; }; + 24A2003A0F90D1DD003BB5A7 /* class_c_control_listener.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_control_listener.html; sourceTree = ""; }; + 24A2003B0F90D1DD003BB5A7 /* class_c_control_listener.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_control_listener.png; sourceTree = ""; }; + 24A2003C0F90D1DD003BB5A7 /* class_c_drag_container-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_drag_container-members.html"; sourceTree = ""; }; + 24A2003D0F90D1DD003BB5A7 /* class_c_drag_container.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_drag_container.html; sourceTree = ""; }; + 24A2003E0F90D1DD003BB5A7 /* class_c_drag_container.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_drag_container.png; sourceTree = ""; }; + 24A2003F0F90D1DD003BB5A7 /* class_c_draw_context-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_draw_context-members.html"; sourceTree = ""; }; + 24A200400F90D1DD003BB5A7 /* class_c_draw_context.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_draw_context.html; sourceTree = ""; }; + 24A200410F90D1DD003BB5A7 /* class_c_draw_context.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_draw_context.png; sourceTree = ""; }; + 24A200420F90D1DD003BB5A7 /* class_c_file_selector-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_file_selector-members.html"; sourceTree = ""; }; + 24A200430F90D1DD003BB5A7 /* class_c_file_selector.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_file_selector.html; sourceTree = ""; }; + 24A200440F90D1DD003BB5A7 /* class_c_frame-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_frame-members.html"; sourceTree = ""; }; + 24A200450F90D1DD003BB5A7 /* class_c_frame.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_frame.html; sourceTree = ""; }; + 24A200460F90D1DD003BB5A7 /* class_c_frame.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_frame.png; sourceTree = ""; }; + 24A200470F90D1DD003BB5A7 /* class_c_horizontal_slider-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_horizontal_slider-members.html"; sourceTree = ""; }; + 24A200480F90D1DD003BB5A7 /* class_c_horizontal_slider.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_horizontal_slider.html; sourceTree = ""; }; + 24A200490F90D1DD003BB5A7 /* class_c_horizontal_slider.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_horizontal_slider.png; sourceTree = ""; }; + 24A2004A0F90D1DD003BB5A7 /* class_c_horizontal_switch-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_horizontal_switch-members.html"; sourceTree = ""; }; + 24A2004B0F90D1DD003BB5A7 /* class_c_horizontal_switch.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_horizontal_switch.html; sourceTree = ""; }; + 24A2004C0F90D1DD003BB5A7 /* class_c_horizontal_switch.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_horizontal_switch.png; sourceTree = ""; }; + 24A2004D0F90D1DD003BB5A7 /* class_c_kick_button-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_kick_button-members.html"; sourceTree = ""; }; + 24A2004E0F90D1DD003BB5A7 /* class_c_kick_button.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_kick_button.html; sourceTree = ""; }; + 24A2004F0F90D1DD003BB5A7 /* class_c_kick_button.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_kick_button.png; sourceTree = ""; }; + 24A200500F90D1DD003BB5A7 /* class_c_knob-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_knob-members.html"; sourceTree = ""; }; + 24A200510F90D1DD003BB5A7 /* class_c_knob.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_knob.html; sourceTree = ""; }; + 24A200520F90D1DD003BB5A7 /* class_c_knob.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_knob.png; sourceTree = ""; }; + 24A200530F90D1DD003BB5A7 /* class_c_movie_bitmap-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_movie_bitmap-members.html"; sourceTree = ""; }; + 24A200540F90D1DD003BB5A7 /* class_c_movie_bitmap.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_movie_bitmap.html; sourceTree = ""; }; + 24A200550F90D1DD003BB5A7 /* class_c_movie_bitmap.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_movie_bitmap.png; sourceTree = ""; }; + 24A200560F90D1DD003BB5A7 /* class_c_movie_button-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_movie_button-members.html"; sourceTree = ""; }; + 24A200570F90D1DD003BB5A7 /* class_c_movie_button.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_movie_button.html; sourceTree = ""; }; + 24A200580F90D1DD003BB5A7 /* class_c_movie_button.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_movie_button.png; sourceTree = ""; }; + 24A200590F90D1DD003BB5A7 /* class_c_offscreen_context-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_offscreen_context-members.html"; sourceTree = ""; }; + 24A2005A0F90D1DD003BB5A7 /* class_c_offscreen_context.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_offscreen_context.html; sourceTree = ""; }; + 24A2005B0F90D1DD003BB5A7 /* class_c_offscreen_context.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_offscreen_context.png; sourceTree = ""; }; + 24A2005C0F90D1DD003BB5A7 /* class_c_on_off_button-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_on_off_button-members.html"; sourceTree = ""; }; + 24A2005D0F90D1DD003BB5A7 /* class_c_on_off_button.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_on_off_button.html; sourceTree = ""; }; + 24A2005E0F90D1DD003BB5A7 /* class_c_on_off_button.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_on_off_button.png; sourceTree = ""; }; + 24A2005F0F90D1DD003BB5A7 /* class_c_option_menu-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_option_menu-members.html"; sourceTree = ""; }; + 24A200600F90D1DD003BB5A7 /* class_c_option_menu.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_option_menu.html; sourceTree = ""; }; + 24A200610F90D1DD003BB5A7 /* class_c_option_menu.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_option_menu.png; sourceTree = ""; }; + 24A200620F90D1DD003BB5A7 /* class_c_option_menu_scheme-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_option_menu_scheme-members.html"; sourceTree = ""; }; + 24A200630F90D1DD003BB5A7 /* class_c_option_menu_scheme.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_option_menu_scheme.html; sourceTree = ""; }; + 24A200640F90D1DD003BB5A7 /* class_c_option_menu_scheme.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_option_menu_scheme.png; sourceTree = ""; }; + 24A200650F90D1DD003BB5A7 /* class_c_param_display-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_param_display-members.html"; sourceTree = ""; }; + 24A200660F90D1DD003BB5A7 /* class_c_param_display.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_param_display.html; sourceTree = ""; }; + 24A200670F90D1DD003BB5A7 /* class_c_param_display.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_param_display.png; sourceTree = ""; }; + 24A200680F90D1DD003BB5A7 /* class_c_reference_counter-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_reference_counter-members.html"; sourceTree = ""; }; + 24A200690F90D1DD003BB5A7 /* class_c_reference_counter.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_reference_counter.html; sourceTree = ""; }; + 24A2006A0F90D1DD003BB5A7 /* class_c_reference_counter.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_reference_counter.png; sourceTree = ""; }; + 24A2006B0F90D1DD003BB5A7 /* class_c_rocker_switch-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_rocker_switch-members.html"; sourceTree = ""; }; + 24A2006C0F90D1DD003BB5A7 /* class_c_rocker_switch.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_rocker_switch.html; sourceTree = ""; }; + 24A2006D0F90D1DD003BB5A7 /* class_c_rocker_switch.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_rocker_switch.png; sourceTree = ""; }; + 24A2006E0F90D1DD003BB5A7 /* class_c_scroll_container-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_scroll_container-members.html"; sourceTree = ""; }; + 24A2006F0F90D1DD003BB5A7 /* class_c_scroll_container.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_scroll_container.html; sourceTree = ""; }; + 24A200700F90D1DD003BB5A7 /* class_c_scroll_container.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_scroll_container.png; sourceTree = ""; }; + 24A200710F90D1DD003BB5A7 /* class_c_scroll_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_scroll_view-members.html"; sourceTree = ""; }; + 24A200720F90D1DD003BB5A7 /* class_c_scroll_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_scroll_view.html; sourceTree = ""; }; + 24A200730F90D1DD003BB5A7 /* class_c_scroll_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_scroll_view.png; sourceTree = ""; }; + 24A200740F90D1DD003BB5A7 /* class_c_scrollbar-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_scrollbar-members.html"; sourceTree = ""; }; + 24A200750F90D1DD003BB5A7 /* class_c_scrollbar.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_scrollbar.html; sourceTree = ""; }; + 24A200760F90D1DD003BB5A7 /* class_c_scrollbar.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_scrollbar.png; sourceTree = ""; }; + 24A200770F90D1DD003BB5A7 /* class_c_slider-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_slider-members.html"; sourceTree = ""; }; + 24A200780F90D1DD003BB5A7 /* class_c_slider.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_slider.html; sourceTree = ""; }; + 24A200790F90D1DD003BB5A7 /* class_c_slider.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_slider.png; sourceTree = ""; }; + 24A2007A0F90D1DD003BB5A7 /* class_c_special_digit-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_special_digit-members.html"; sourceTree = ""; }; + 24A2007B0F90D1DD003BB5A7 /* class_c_special_digit.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_special_digit.html; sourceTree = ""; }; + 24A2007C0F90D1DD003BB5A7 /* class_c_special_digit.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_special_digit.png; sourceTree = ""; }; + 24A2007D0F90D1DD003BB5A7 /* class_c_splash_screen-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_splash_screen-members.html"; sourceTree = ""; }; + 24A2007E0F90D1DD003BB5A7 /* class_c_splash_screen.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_splash_screen.html; sourceTree = ""; }; + 24A2007F0F90D1DD003BB5A7 /* class_c_splash_screen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_splash_screen.png; sourceTree = ""; }; + 24A200800F90D1DD003BB5A7 /* class_c_splash_screen_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_splash_screen_view-members.html"; sourceTree = ""; }; + 24A200810F90D1DD003BB5A7 /* class_c_splash_screen_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_splash_screen_view.html; sourceTree = ""; }; + 24A200820F90D1DD003BB5A7 /* class_c_splash_screen_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_splash_screen_view.png; sourceTree = ""; }; + 24A200830F90D1DD003BB5A7 /* class_c_tab_button-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_tab_button-members.html"; sourceTree = ""; }; + 24A200840F90D1DD003BB5A7 /* class_c_tab_button.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_tab_button.html; sourceTree = ""; }; + 24A200850F90D1DD003BB5A7 /* class_c_tab_button.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_tab_button.png; sourceTree = ""; }; + 24A200860F90D1DD003BB5A7 /* class_c_tab_child_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_tab_child_view-members.html"; sourceTree = ""; }; + 24A200870F90D1DD003BB5A7 /* class_c_tab_child_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_tab_child_view.html; sourceTree = ""; }; + 24A200880F90D1DD003BB5A7 /* class_c_tab_child_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_tab_child_view.png; sourceTree = ""; }; + 24A200890F90D1DD003BB5A7 /* class_c_tab_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_tab_view-members.html"; sourceTree = ""; }; + 24A2008A0F90D1DD003BB5A7 /* class_c_tab_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_tab_view.html; sourceTree = ""; }; + 24A2008B0F90D1DD003BB5A7 /* class_c_tab_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_tab_view.png; sourceTree = ""; }; + 24A2008C0F90D1DD003BB5A7 /* class_c_text_edit-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_text_edit-members.html"; sourceTree = ""; }; + 24A2008D0F90D1DD003BB5A7 /* class_c_text_edit.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_text_edit.html; sourceTree = ""; }; + 24A2008E0F90D1DD003BB5A7 /* class_c_text_edit.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_text_edit.png; sourceTree = ""; }; + 24A2008F0F90D1DD003BB5A7 /* class_c_text_label-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_text_label-members.html"; sourceTree = ""; }; + 24A200900F90D1DD003BB5A7 /* class_c_text_label.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_text_label.html; sourceTree = ""; }; + 24A200910F90D1DD003BB5A7 /* class_c_text_label.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_text_label.png; sourceTree = ""; }; + 24A200920F90D1DD003BB5A7 /* class_c_vertical_slider-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_vertical_slider-members.html"; sourceTree = ""; }; + 24A200930F90D1DD003BB5A7 /* class_c_vertical_slider.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_vertical_slider.html; sourceTree = ""; }; + 24A200940F90D1DD003BB5A7 /* class_c_vertical_slider.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_vertical_slider.png; sourceTree = ""; }; + 24A200950F90D1DD003BB5A7 /* class_c_vertical_switch-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_vertical_switch-members.html"; sourceTree = ""; }; + 24A200960F90D1DD003BB5A7 /* class_c_vertical_switch.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_vertical_switch.html; sourceTree = ""; }; + 24A200970F90D1DD003BB5A7 /* class_c_vertical_switch.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_vertical_switch.png; sourceTree = ""; }; + 24A200980F90D1DD003BB5A7 /* class_c_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_view-members.html"; sourceTree = ""; }; + 24A200990F90D1DD003BB5A7 /* class_c_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_view.html; sourceTree = ""; }; + 24A2009A0F90D1DD003BB5A7 /* class_c_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_view.png; sourceTree = ""; }; + 24A2009B0F90D1DD003BB5A7 /* class_c_view_container-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_view_container-members.html"; sourceTree = ""; }; + 24A2009C0F90D1DD003BB5A7 /* class_c_view_container.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_view_container.html; sourceTree = ""; }; + 24A2009D0F90D1DD003BB5A7 /* class_c_view_container.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_view_container.png; sourceTree = ""; }; + 24A2009E0F90D1DD003BB5A7 /* class_c_vu_meter-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_vu_meter-members.html"; sourceTree = ""; }; + 24A2009F0F90D1DD003BB5A7 /* class_c_vu_meter.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_vu_meter.html; sourceTree = ""; }; + 24A200A00F90D1DD003BB5A7 /* class_c_vu_meter.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_vu_meter.png; sourceTree = ""; }; + 24A200A10F90D1DD003BB5A7 /* class_i_scrollbar_drawer-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_i_scrollbar_drawer-members.html"; sourceTree = ""; }; + 24A200A20F90D1DD003BB5A7 /* class_i_scrollbar_drawer.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_i_scrollbar_drawer.html; sourceTree = ""; }; + 24A200A30F90D1DD003BB5A7 /* class_plugin_g_u_i_editor-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_plugin_g_u_i_editor-members.html"; sourceTree = ""; }; + 24A200A40F90D1DD003BB5A7 /* class_plugin_g_u_i_editor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_plugin_g_u_i_editor.html; sourceTree = ""; }; + 24A200A50F90D1DD003BB5A7 /* cscrollview_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = cscrollview_8cpp.html; sourceTree = ""; }; + 24A200A60F90D1DD003BB5A7 /* cscrollview_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = cscrollview_8h.html; sourceTree = ""; }; + 24A200A70F90D1DD003BB5A7 /* ctabview_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = ctabview_8cpp.html; sourceTree = ""; }; + 24A200A80F90D1DD003BB5A7 /* ctabview_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = ctabview_8h.html; sourceTree = ""; }; + 24A200A90F90D1DD003BB5A7 /* deprecated.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = deprecated.html; sourceTree = ""; }; + 24A200AA0F90D1DD003BB5A7 /* doc_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = doc_8h.html; sourceTree = ""; }; + 24A200AB0F90D1DD003BB5A7 /* doxygen.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = doxygen.css; sourceTree = ""; }; + 24A200AC0F90D1DD003BB5A7 /* doxygen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = doxygen.png; sourceTree = ""; }; + 24A200AD0F90D1DD003BB5A7 /* files.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = files.html; sourceTree = ""; }; + 24A200AE0F90D1DD003BB5A7 /* ftv2blank.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2blank.png; sourceTree = ""; }; + 24A200AF0F90D1DD003BB5A7 /* ftv2doc.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2doc.png; sourceTree = ""; }; + 24A200B00F90D1DD003BB5A7 /* ftv2folderclosed.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2folderclosed.png; sourceTree = ""; }; + 24A200B10F90D1DE003BB5A7 /* ftv2folderopen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2folderopen.png; sourceTree = ""; }; + 24A200B20F90D1DE003BB5A7 /* ftv2lastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2lastnode.png; sourceTree = ""; }; + 24A200B30F90D1DE003BB5A7 /* ftv2link.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2link.png; sourceTree = ""; }; + 24A200B40F90D1DE003BB5A7 /* ftv2mlastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2mlastnode.png; sourceTree = ""; }; + 24A200B50F90D1DE003BB5A7 /* ftv2mnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2mnode.png; sourceTree = ""; }; + 24A200B60F90D1DE003BB5A7 /* ftv2node.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2node.png; sourceTree = ""; }; + 24A200B70F90D1DE003BB5A7 /* ftv2plastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2plastnode.png; sourceTree = ""; }; + 24A200B80F90D1DE003BB5A7 /* ftv2pnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2pnode.png; sourceTree = ""; }; + 24A200B90F90D1DE003BB5A7 /* ftv2vertline.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2vertline.png; sourceTree = ""; }; + 24A200BA0F90D1DE003BB5A7 /* functions.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions.html; sourceTree = ""; }; + 24A200BB0F90D1DE003BB5A7 /* functions_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x62.html; sourceTree = ""; }; + 24A200BC0F90D1DE003BB5A7 /* functions_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x63.html; sourceTree = ""; }; + 24A200BD0F90D1DE003BB5A7 /* functions_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x64.html; sourceTree = ""; }; + 24A200BE0F90D1DE003BB5A7 /* functions_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x65.html; sourceTree = ""; }; + 24A200BF0F90D1DE003BB5A7 /* functions_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x66.html; sourceTree = ""; }; + 24A200C00F90D1DE003BB5A7 /* functions_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x67.html; sourceTree = ""; }; + 24A200C10F90D1DE003BB5A7 /* functions_0x68.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x68.html; sourceTree = ""; }; + 24A200C20F90D1DE003BB5A7 /* functions_0x69.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x69.html; sourceTree = ""; }; + 24A200C30F90D1DE003BB5A7 /* functions_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6b.html; sourceTree = ""; }; + 24A200C40F90D1DE003BB5A7 /* functions_0x6c.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6c.html; sourceTree = ""; }; + 24A200C50F90D1DE003BB5A7 /* functions_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6d.html; sourceTree = ""; }; + 24A200C60F90D1DE003BB5A7 /* functions_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6e.html; sourceTree = ""; }; + 24A200C70F90D1DE003BB5A7 /* functions_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6f.html; sourceTree = ""; }; + 24A200C80F90D1DE003BB5A7 /* functions_0x70.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x70.html; sourceTree = ""; }; + 24A200C90F90D1DE003BB5A7 /* functions_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x72.html; sourceTree = ""; }; + 24A200CA0F90D1DE003BB5A7 /* functions_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x73.html; sourceTree = ""; }; + 24A200CB0F90D1DE003BB5A7 /* functions_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x74.html; sourceTree = ""; }; + 24A200CC0F90D1DE003BB5A7 /* functions_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x75.html; sourceTree = ""; }; + 24A200CD0F90D1DE003BB5A7 /* functions_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x76.html; sourceTree = ""; }; + 24A200CE0F90D1DE003BB5A7 /* functions_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x77.html; sourceTree = ""; }; + 24A200CF0F90D1DE003BB5A7 /* functions_0x78.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x78.html; sourceTree = ""; }; + 24A200D00F90D1DE003BB5A7 /* functions_0x79.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x79.html; sourceTree = ""; }; + 24A200D10F90D1DE003BB5A7 /* functions_0x7a.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x7a.html; sourceTree = ""; }; + 24A200D20F90D1DE003BB5A7 /* functions_0x7e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x7e.html; sourceTree = ""; }; + 24A200D30F90D1DE003BB5A7 /* functions_eval.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_eval.html; sourceTree = ""; }; + 24A200D40F90D1DE003BB5A7 /* functions_func.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func.html; sourceTree = ""; }; + 24A200D50F90D1DE003BB5A7 /* functions_func_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x62.html; sourceTree = ""; }; + 24A200D60F90D1DE003BB5A7 /* functions_func_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x63.html; sourceTree = ""; }; + 24A200D70F90D1DE003BB5A7 /* functions_func_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x64.html; sourceTree = ""; }; + 24A200D80F90D1DE003BB5A7 /* functions_func_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x65.html; sourceTree = ""; }; + 24A200D90F90D1DE003BB5A7 /* functions_func_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x66.html; sourceTree = ""; }; + 24A200DA0F90D1DE003BB5A7 /* functions_func_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x67.html; sourceTree = ""; }; + 24A200DB0F90D1DE003BB5A7 /* functions_func_0x68.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x68.html; sourceTree = ""; }; + 24A200DC0F90D1DE003BB5A7 /* functions_func_0x69.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x69.html; sourceTree = ""; }; + 24A200DD0F90D1DE003BB5A7 /* functions_func_0x6c.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x6c.html; sourceTree = ""; }; + 24A200DE0F90D1DE003BB5A7 /* functions_func_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x6d.html; sourceTree = ""; }; + 24A200DF0F90D1DE003BB5A7 /* functions_func_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x6e.html; sourceTree = ""; }; + 24A200E00F90D1DE003BB5A7 /* functions_func_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x6f.html; sourceTree = ""; }; + 24A200E10F90D1DE003BB5A7 /* functions_func_0x70.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x70.html; sourceTree = ""; }; + 24A200E20F90D1DE003BB5A7 /* functions_func_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x72.html; sourceTree = ""; }; + 24A200E30F90D1DE003BB5A7 /* functions_func_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x73.html; sourceTree = ""; }; + 24A200E40F90D1DE003BB5A7 /* functions_func_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x74.html; sourceTree = ""; }; + 24A200E50F90D1DE003BB5A7 /* functions_func_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x75.html; sourceTree = ""; }; + 24A200E60F90D1DE003BB5A7 /* functions_func_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x76.html; sourceTree = ""; }; + 24A200E70F90D1DE003BB5A7 /* functions_func_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x77.html; sourceTree = ""; }; + 24A200E80F90D1DE003BB5A7 /* functions_func_0x7e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x7e.html; sourceTree = ""; }; + 24A200E90F90D1DE003BB5A7 /* functions_rela.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_rela.html; sourceTree = ""; }; + 24A200EA0F90D1DE003BB5A7 /* functions_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars.html; sourceTree = ""; }; + 24A200EB0F90D1DE003BB5A7 /* functions_vars_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x62.html; sourceTree = ""; }; + 24A200EC0F90D1DE003BB5A7 /* functions_vars_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x63.html; sourceTree = ""; }; + 24A200ED0F90D1DE003BB5A7 /* functions_vars_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x64.html; sourceTree = ""; }; + 24A200EE0F90D1DE003BB5A7 /* functions_vars_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x65.html; sourceTree = ""; }; + 24A200EF0F90D1DE003BB5A7 /* functions_vars_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x66.html; sourceTree = ""; }; + 24A200F00F90D1DE003BB5A7 /* functions_vars_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x67.html; sourceTree = ""; }; + 24A200F10F90D1DE003BB5A7 /* functions_vars_0x68.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x68.html; sourceTree = ""; }; + 24A200F20F90D1DE003BB5A7 /* functions_vars_0x69.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x69.html; sourceTree = ""; }; + 24A200F30F90D1DE003BB5A7 /* functions_vars_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6b.html; sourceTree = ""; }; + 24A200F40F90D1DE003BB5A7 /* functions_vars_0x6c.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6c.html; sourceTree = ""; }; + 24A200F50F90D1DE003BB5A7 /* functions_vars_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6d.html; sourceTree = ""; }; + 24A200F60F90D1DE003BB5A7 /* functions_vars_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6e.html; sourceTree = ""; }; + 24A200F70F90D1DE003BB5A7 /* functions_vars_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6f.html; sourceTree = ""; }; + 24A200F80F90D1DE003BB5A7 /* functions_vars_0x70.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x70.html; sourceTree = ""; }; + 24A200F90F90D1DE003BB5A7 /* functions_vars_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x72.html; sourceTree = ""; }; + 24A200FA0F90D1DE003BB5A7 /* functions_vars_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x73.html; sourceTree = ""; }; + 24A200FB0F90D1DE003BB5A7 /* functions_vars_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x74.html; sourceTree = ""; }; + 24A200FC0F90D1DE003BB5A7 /* functions_vars_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x75.html; sourceTree = ""; }; + 24A200FD0F90D1DE003BB5A7 /* functions_vars_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x76.html; sourceTree = ""; }; + 24A200FE0F90D1DE003BB5A7 /* functions_vars_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x77.html; sourceTree = ""; }; + 24A200FF0F90D1DE003BB5A7 /* functions_vars_0x78.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x78.html; sourceTree = ""; }; + 24A201000F90D1DE003BB5A7 /* functions_vars_0x79.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x79.html; sourceTree = ""; }; + 24A201010F90D1DE003BB5A7 /* functions_vars_0x7a.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x7a.html; sourceTree = ""; }; + 24A201020F90D1DE003BB5A7 /* globals.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals.html; sourceTree = ""; }; + 24A201030F90D1DE003BB5A7 /* globals_0x61.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x61.html; sourceTree = ""; }; + 24A201040F90D1DE003BB5A7 /* globals_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x62.html; sourceTree = ""; }; + 24A201050F90D1DE003BB5A7 /* globals_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x63.html; sourceTree = ""; }; + 24A201060F90D1DE003BB5A7 /* globals_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x65.html; sourceTree = ""; }; + 24A201070F90D1DE003BB5A7 /* globals_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x66.html; sourceTree = ""; }; + 24A201080F90D1DE003BB5A7 /* globals_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x67.html; sourceTree = ""; }; + 24A201090F90D1DE003BB5A7 /* globals_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x6b.html; sourceTree = ""; }; + 24A2010A0F90D1DE003BB5A7 /* globals_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x6d.html; sourceTree = ""; }; + 24A2010B0F90D1DE003BB5A7 /* globals_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x6e.html; sourceTree = ""; }; + 24A2010C0F90D1DE003BB5A7 /* globals_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x6f.html; sourceTree = ""; }; + 24A2010D0F90D1DE003BB5A7 /* globals_0x71.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x71.html; sourceTree = ""; }; + 24A2010E0F90D1DE003BB5A7 /* globals_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x72.html; sourceTree = ""; }; + 24A2010F0F90D1DE003BB5A7 /* globals_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x73.html; sourceTree = ""; }; + 24A201100F90D1DE003BB5A7 /* globals_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x74.html; sourceTree = ""; }; + 24A201110F90D1DE003BB5A7 /* globals_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x75.html; sourceTree = ""; }; + 24A201120F90D1DE003BB5A7 /* globals_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x76.html; sourceTree = ""; }; + 24A201130F90D1DE003BB5A7 /* globals_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x77.html; sourceTree = ""; }; + 24A201140F90D1DE003BB5A7 /* globals_defs.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_defs.html; sourceTree = ""; }; + 24A201150F90D1DE003BB5A7 /* globals_enum.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_enum.html; sourceTree = ""; }; + 24A201160F90D1DE003BB5A7 /* globals_eval.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_eval.html; sourceTree = ""; }; + 24A201170F90D1DE003BB5A7 /* globals_type.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_type.html; sourceTree = ""; }; + 24A201180F90D1DE003BB5A7 /* globals_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_vars.html; sourceTree = ""; }; + 24A201190F90D1DE003BB5A7 /* hierarchy.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = hierarchy.html; sourceTree = ""; }; + 24A2011A0F90D1DE003BB5A7 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = index.html; sourceTree = ""; }; + 24A2011B0F90D1DE003BB5A7 /* intro.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = intro.html; sourceTree = ""; }; + 24A2011C0F90D1DE003BB5A7 /* license.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = license.html; sourceTree = ""; }; + 24A2011D0F90D1DE003BB5A7 /* maceditor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = maceditor.html; sourceTree = ""; }; + 24A2011E0F90D1DE003BB5A7 /* main.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = main.html; sourceTree = ""; }; + 24A2011F0F90D1DE003BB5A7 /* others.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = others.html; sourceTree = ""; }; + 24A201200F90D1DE003BB5A7 /* pages.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = pages.html; sourceTree = ""; }; + 24A201210F90D1DE003BB5A7 /* plugguieditor_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = plugguieditor_8cpp.html; sourceTree = ""; }; + 24A201220F90D1DE003BB5A7 /* plugguieditor_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = plugguieditor_8h.html; sourceTree = ""; }; + 24A201230F90D1DE003BB5A7 /* sequences.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = sequences.html; sourceTree = ""; }; + 24A201240F90D1DE003BB5A7 /* struct_c_color-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_c_color-members.html"; sourceTree = ""; }; + 24A201250F90D1DE003BB5A7 /* struct_c_color.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_c_color.html; sourceTree = ""; }; + 24A201260F90D1DE003BB5A7 /* struct_c_point-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_c_point-members.html"; sourceTree = ""; }; + 24A201270F90D1DE003BB5A7 /* struct_c_point.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_c_point.html; sourceTree = ""; }; + 24A201280F90D1DE003BB5A7 /* struct_c_rect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_c_rect-members.html"; sourceTree = ""; }; + 24A201290F90D1DE003BB5A7 /* struct_c_rect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_c_rect.html; sourceTree = ""; }; + 24A2012A0F90D1DE003BB5A7 /* struct_e_rect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_e_rect-members.html"; sourceTree = ""; }; + 24A2012B0F90D1DE003BB5A7 /* struct_e_rect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_e_rect.html; sourceTree = ""; }; + 24A2012C0F90D1DE003BB5A7 /* struct_vst_file_select-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_vst_file_select-members.html"; sourceTree = ""; }; + 24A2012D0F90D1DE003BB5A7 /* struct_vst_file_select.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_vst_file_select.html; sourceTree = ""; }; + 24A2012E0F90D1DE003BB5A7 /* struct_vst_file_type-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_vst_file_type-members.html"; sourceTree = ""; }; + 24A2012F0F90D1DE003BB5A7 /* struct_vst_file_type.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_vst_file_type.html; sourceTree = ""; }; + 24A201300F90D1DE003BB5A7 /* struct_vst_key_code-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_vst_key_code-members.html"; sourceTree = ""; }; + 24A201310F90D1DE003BB5A7 /* struct_vst_key_code.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_vst_key_code.html; sourceTree = ""; }; + 24A201320F90D1DE003BB5A7 /* tab_b.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_b.gif; sourceTree = ""; }; + 24A201330F90D1DE003BB5A7 /* tab_l.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_l.gif; sourceTree = ""; }; + 24A201340F90D1DE003BB5A7 /* tab_r.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_r.gif; sourceTree = ""; }; + 24A201350F90D1DE003BB5A7 /* tabs.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = tabs.css; sourceTree = ""; }; + 24A201360F90D1DE003BB5A7 /* thanks.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = thanks.html; sourceTree = ""; }; + 24A201370F90D1DE003BB5A7 /* tree.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = tree.html; sourceTree = ""; }; + 24A201380F90D1DE003BB5A7 /* vstcontrols_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstcontrols_8cpp.html; sourceTree = ""; }; + 24A201390F90D1DE003BB5A7 /* vstcontrols_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstcontrols_8h.html; sourceTree = ""; }; + 24A2013A0F90D1DE003BB5A7 /* vstgui_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstgui_8cpp.html; sourceTree = ""; }; + 24A2013B0F90D1DE003BB5A7 /* vstgui_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstgui_8h.html; sourceTree = ""; }; + 24A2013C0F90D1DE003BB5A7 /* vstkeycode_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstkeycode_8h.html; sourceTree = ""; }; + 24A2013D0F90D1DE003BB5A7 /* vstoffline.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstoffline.html; sourceTree = ""; }; + 24A2013E0F90D1DE003BB5A7 /* vstparamstruct.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstparamstruct.html; sourceTree = ""; }; + 24A2013F0F90D1DE003BB5A7 /* vstplugscarbon_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstplugscarbon_8h.html; sourceTree = ""; }; + 24A201400F90D1DE003BB5A7 /* vstplugsmac_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstplugsmac_8h.html; sourceTree = ""; }; + 24A201410F90D1DE003BB5A7 /* vstplugsmacho_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstplugsmacho_8h.html; sourceTree = ""; }; + 24A201420F90D1DE003BB5A7 /* vstplugsquartz_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstplugsquartz_8h.html; sourceTree = ""; }; + 24A201430F90D1DE003BB5A7 /* whatsnew.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = whatsnew.html; sourceTree = ""; }; + 24A201440F90D1DE003BB5A7 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = index.html; sourceTree = ""; }; + 24A201450F90D1DE003BB5A7 /* Migrating from 2.3.rtf */ = {isa = PBXFileReference; lastKnownFileType = text.rtf; path = "Migrating from 2.3.rtf"; sourceTree = ""; }; + 24A201460F90D1DE003BB5A7 /* plugguieditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = plugguieditor.cpp; sourceTree = ""; }; + 24A201470F90D1DE003BB5A7 /* plugguieditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = plugguieditor.h; sourceTree = ""; }; + 24A201480F90D1DE003BB5A7 /* vstcontrols.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstcontrols.cpp; sourceTree = ""; }; + 24A201490F90D1DE003BB5A7 /* vstcontrols.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstcontrols.h; sourceTree = ""; }; + 24A2014A0F90D1DE003BB5A7 /* vstgui.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstgui.cpp; sourceTree = ""; }; + 24A2014B0F90D1DE003BB5A7 /* vstgui.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstgui.h; sourceTree = ""; }; + 24A2014C0F90D1DE003BB5A7 /* vstkeycode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstkeycode.h; sourceTree = ""; }; + 24A2014D0F90D1DE003BB5A7 /* vstplugscarbon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstplugscarbon.h; sourceTree = ""; }; + 24A2014E0F90D1DE003BB5A7 /* vstplugsmac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstplugsmac.h; sourceTree = ""; }; + 24A2014F0F90D1DE003BB5A7 /* vstplugsmacho.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstplugsmacho.h; sourceTree = ""; }; + 24A201500F90D1DE003BB5A7 /* vstplugsquartz.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstplugsquartz.h; sourceTree = ""; }; + 24A2FEBD0F90D1DC003BB5A7 /* Thumbs.db */ = {isa = PBXFileReference; lastKnownFileType = file; path = Thumbs.db; sourceTree = ""; }; + 24A2FEBE0F90D1DC003BB5A7 /* VST_Logo_Usage_Guideline.pdf */ = {isa = PBXFileReference; lastKnownFileType = image.pdf; path = VST_Logo_Usage_Guideline.pdf; sourceTree = ""; }; + 24A2FEBF0F90D1DC003BB5A7 /* VSTLogoAlpha.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = VSTLogoAlpha.png; sourceTree = ""; }; + 24A2FEC00F90D1DC003BB5A7 /* VSTLogoBlack.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = VSTLogoBlack.jpg; sourceTree = ""; }; + 24A2FEC10F90D1DC003BB5A7 /* VSTLogoWhite.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = VSTLogoWhite.jpg; sourceTree = ""; }; + 24A2FEC60F90D1DC003BB5A7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 24A2FEC80F90D1DC003BB5A7 /* VSTMonitor */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.bundle"; path = VSTMonitor; sourceTree = ""; }; + 24A2FEC90F90D1DC003BB5A7 /* PkgInfo */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = PkgInfo; sourceTree = ""; }; + 24A2FECB0F90D1DC003BB5A7 /* bmp50000.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50000.bmp; sourceTree = ""; }; + 24A2FECC0F90D1DC003BB5A7 /* bmp50001.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50001.bmp; sourceTree = ""; }; + 24A2FECD0F90D1DC003BB5A7 /* bmp50002.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50002.bmp; sourceTree = ""; }; + 24A2FECE0F90D1DC003BB5A7 /* bmp50003.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50003.bmp; sourceTree = ""; }; + 24A2FECF0F90D1DC003BB5A7 /* bmp50004.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50004.bmp; sourceTree = ""; }; + 24A2FED00F90D1DC003BB5A7 /* bmp50005.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50005.bmp; sourceTree = ""; }; + 24A2FED10F90D1DC003BB5A7 /* bmp50006.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50006.bmp; sourceTree = ""; }; + 24A2FED20F90D1DC003BB5A7 /* bmp50007.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50007.bmp; sourceTree = ""; }; + 24A2FED30F90D1DC003BB5A7 /* bmp50008.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50008.bmp; sourceTree = ""; }; + 24A2FED40F90D1DC003BB5A7 /* VSTParamTool.app */ = {isa = PBXFileReference; lastKnownFileType = wrapper.application; path = VSTParamTool.app; sourceTree = ""; }; + 24A2FED60F90D1DC003BB5A7 /* vstmonitor.dll */ = {isa = PBXFileReference; lastKnownFileType = file; path = vstmonitor.dll; sourceTree = ""; }; + 24A2FED70F90D1DC003BB5A7 /* vstparamtool.exe */ = {isa = PBXFileReference; lastKnownFileType = file; path = vstparamtool.exe; sourceTree = ""; }; + 24A2FEDA0F90D1DC003BB5A7 /* folder.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = folder.gif; sourceTree = ""; }; + 24A2FEDB0F90D1DC003BB5A7 /* mac.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = mac.gif; sourceTree = ""; }; + 24A2FEDC0F90D1DC003BB5A7 /* vstpluglogo_small.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = vstpluglogo_small.jpg; sourceTree = ""; }; + 24A2FEDD0F90D1DC003BB5A7 /* win.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = win.gif; sourceTree = ""; }; + 24A2FEDF0F90D1DC003BB5A7 /* aeffect_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = aeffect_8h.html; sourceTree = ""; }; + 24A2FEE00F90D1DC003BB5A7 /* aeffectx_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = aeffectx_8h.html; sourceTree = ""; }; + 24A2FEE10F90D1DC003BB5A7 /* aeffeditor_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = aeffeditor_8h.html; sourceTree = ""; }; + 24A2FEE20F90D1DC003BB5A7 /* annotated.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = annotated.html; sourceTree = ""; }; + 24A2FEE30F90D1DC003BB5A7 /* audioeffect_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = audioeffect_8cpp.html; sourceTree = ""; }; + 24A2FEE40F90D1DC003BB5A7 /* audioeffect_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = audioeffect_8h.html; sourceTree = ""; }; + 24A2FEE50F90D1DC003BB5A7 /* audioeffectx_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = audioeffectx_8cpp.html; sourceTree = ""; }; + 24A2FEE60F90D1DC003BB5A7 /* audioeffectx_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = audioeffectx_8h.html; sourceTree = ""; }; + 24A2FEE70F90D1DC003BB5A7 /* Blocksizechange.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Blocksizechange.gif; sourceTree = ""; }; + 24A2FEE80F90D1DC003BB5A7 /* class_a_eff_editor-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "class_a_eff_editor-members.html"; sourceTree = ""; }; + 24A2FEE90F90D1DC003BB5A7 /* class_a_eff_editor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = class_a_eff_editor.html; sourceTree = ""; }; + 24A2FEEA0F90D1DC003BB5A7 /* class_audio_effect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "class_audio_effect-members.html"; sourceTree = ""; }; + 24A2FEEB0F90D1DC003BB5A7 /* class_audio_effect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = class_audio_effect.html; sourceTree = ""; }; + 24A2FEEC0F90D1DC003BB5A7 /* class_audio_effect.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_audio_effect.png; sourceTree = ""; }; + 24A2FEED0F90D1DC003BB5A7 /* class_audio_effect_x-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "class_audio_effect_x-members.html"; sourceTree = ""; }; + 24A2FEEE0F90D1DC003BB5A7 /* class_audio_effect_x.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = class_audio_effect_x.html; sourceTree = ""; }; + 24A2FEEF0F90D1DC003BB5A7 /* class_audio_effect_x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_audio_effect_x.png; sourceTree = ""; }; + 24A2FEF00F90D1DC003BB5A7 /* ControlChanged.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = ControlChanged.gif; sourceTree = ""; }; + 24A2FEF10F90D1DC003BB5A7 /* deprecated.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = deprecated.html; sourceTree = ""; }; + 24A2FEF20F90D1DC003BB5A7 /* dir_2d3252dd12c84c66c1d25b26bb45a1f5.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dir_2d3252dd12c84c66c1d25b26bb45a1f5.html; sourceTree = ""; }; + 24A2FEF30F90D1DC003BB5A7 /* dir_77c628dfee72e555f82d5ef53b733f38.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dir_77c628dfee72e555f82d5ef53b733f38.html; sourceTree = ""; }; + 24A2FEF40F90D1DC003BB5A7 /* dir_f81105d3b854bea570aaf3bae5cb64c1.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dir_f81105d3b854bea570aaf3bae5cb64c1.html; sourceTree = ""; }; + 24A2FEF50F90D1DC003BB5A7 /* dir_fa0454ab79b4262333bf837ea3d765e9.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dir_fa0454ab79b4262333bf837ea3d765e9.html; sourceTree = ""; }; + 24A2FEF60F90D1DC003BB5A7 /* dirs.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dirs.html; sourceTree = ""; }; + 24A2FEF70F90D1DC003BB5A7 /* doc_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = doc_8h.html; sourceTree = ""; }; + 24A2FEF80F90D1DC003BB5A7 /* doxygen.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = doxygen.css; sourceTree = ""; }; + 24A2FEF90F90D1DC003BB5A7 /* doxygen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = doxygen.png; sourceTree = ""; }; + 24A2FEFA0F90D1DC003BB5A7 /* files.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = files.html; sourceTree = ""; }; + 24A2FEFB0F90D1DC003BB5A7 /* ftv2blank.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2blank.png; sourceTree = ""; }; + 24A2FEFC0F90D1DC003BB5A7 /* ftv2doc.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2doc.png; sourceTree = ""; }; + 24A2FEFD0F90D1DC003BB5A7 /* ftv2folderclosed.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2folderclosed.png; sourceTree = ""; }; + 24A2FEFE0F90D1DC003BB5A7 /* ftv2folderopen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2folderopen.png; sourceTree = ""; }; + 24A2FEFF0F90D1DC003BB5A7 /* ftv2lastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2lastnode.png; sourceTree = ""; }; + 24A2FF000F90D1DC003BB5A7 /* ftv2link.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2link.png; sourceTree = ""; }; + 24A2FF010F90D1DC003BB5A7 /* ftv2mlastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2mlastnode.png; sourceTree = ""; }; + 24A2FF020F90D1DC003BB5A7 /* ftv2mnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2mnode.png; sourceTree = ""; }; + 24A2FF030F90D1DC003BB5A7 /* ftv2node.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2node.png; sourceTree = ""; }; + 24A2FF040F90D1DC003BB5A7 /* ftv2plastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2plastnode.png; sourceTree = ""; }; + 24A2FF050F90D1DC003BB5A7 /* ftv2pnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2pnode.png; sourceTree = ""; }; + 24A2FF060F90D1DC003BB5A7 /* ftv2vertline.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2vertline.png; sourceTree = ""; }; + 24A2FF070F90D1DC003BB5A7 /* functions.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions.html; sourceTree = ""; }; + 24A2FF080F90D1DC003BB5A7 /* functions_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x62.html; sourceTree = ""; }; + 24A2FF090F90D1DC003BB5A7 /* functions_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x63.html; sourceTree = ""; }; + 24A2FF0A0F90D1DC003BB5A7 /* functions_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x64.html; sourceTree = ""; }; + 24A2FF0B0F90D1DC003BB5A7 /* functions_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x65.html; sourceTree = ""; }; + 24A2FF0C0F90D1DC003BB5A7 /* functions_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x66.html; sourceTree = ""; }; + 24A2FF0D0F90D1DC003BB5A7 /* functions_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x67.html; sourceTree = ""; }; + 24A2FF0E0F90D1DC003BB5A7 /* functions_0x68.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x68.html; sourceTree = ""; }; + 24A2FF0F0F90D1DC003BB5A7 /* functions_0x69.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x69.html; sourceTree = ""; }; + 24A2FF100F90D1DC003BB5A7 /* functions_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6b.html; sourceTree = ""; }; + 24A2FF110F90D1DC003BB5A7 /* functions_0x6c.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6c.html; sourceTree = ""; }; + 24A2FF120F90D1DC003BB5A7 /* functions_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6d.html; sourceTree = ""; }; + 24A2FF130F90D1DC003BB5A7 /* functions_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6e.html; sourceTree = ""; }; + 24A2FF140F90D1DC003BB5A7 /* functions_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6f.html; sourceTree = ""; }; + 24A2FF150F90D1DC003BB5A7 /* functions_0x70.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x70.html; sourceTree = ""; }; + 24A2FF160F90D1DC003BB5A7 /* functions_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x72.html; sourceTree = ""; }; + 24A2FF170F90D1DC003BB5A7 /* functions_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x73.html; sourceTree = ""; }; + 24A2FF180F90D1DC003BB5A7 /* functions_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x74.html; sourceTree = ""; }; + 24A2FF190F90D1DC003BB5A7 /* functions_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x75.html; sourceTree = ""; }; + 24A2FF1A0F90D1DC003BB5A7 /* functions_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x76.html; sourceTree = ""; }; + 24A2FF1B0F90D1DC003BB5A7 /* functions_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x77.html; sourceTree = ""; }; + 24A2FF1C0F90D1DC003BB5A7 /* functions_0x78.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x78.html; sourceTree = ""; }; + 24A2FF1D0F90D1DC003BB5A7 /* functions_0x79.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x79.html; sourceTree = ""; }; + 24A2FF1E0F90D1DC003BB5A7 /* functions_0x7e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x7e.html; sourceTree = ""; }; + 24A2FF1F0F90D1DC003BB5A7 /* functions_func.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_func.html; sourceTree = ""; }; + 24A2FF200F90D1DC003BB5A7 /* functions_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_vars.html; sourceTree = ""; }; + 24A2FF210F90D1DC003BB5A7 /* globals.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals.html; sourceTree = ""; }; + 24A2FF220F90D1DC003BB5A7 /* globals_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x62.html; sourceTree = ""; }; + 24A2FF230F90D1DC003BB5A7 /* globals_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x63.html; sourceTree = ""; }; + 24A2FF240F90D1DC003BB5A7 /* globals_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x64.html; sourceTree = ""; }; + 24A2FF250F90D1DC003BB5A7 /* globals_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x65.html; sourceTree = ""; }; + 24A2FF260F90D1DC003BB5A7 /* globals_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x66.html; sourceTree = ""; }; + 24A2FF270F90D1DC003BB5A7 /* globals_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x6b.html; sourceTree = ""; }; + 24A2FF280F90D1DC003BB5A7 /* globals_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x6d.html; sourceTree = ""; }; + 24A2FF290F90D1DC003BB5A7 /* globals_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x74.html; sourceTree = ""; }; + 24A2FF2A0F90D1DC003BB5A7 /* globals_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x76.html; sourceTree = ""; }; + 24A2FF2B0F90D1DC003BB5A7 /* globals_defs.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_defs.html; sourceTree = ""; }; + 24A2FF2C0F90D1DC003BB5A7 /* globals_enum.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_enum.html; sourceTree = ""; }; + 24A2FF2D0F90D1DC003BB5A7 /* globals_eval.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval.html; sourceTree = ""; }; + 24A2FF2E0F90D1DC003BB5A7 /* globals_eval_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval_0x65.html; sourceTree = ""; }; + 24A2FF2F0F90D1DC003BB5A7 /* globals_eval_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval_0x6b.html; sourceTree = ""; }; + 24A2FF300F90D1DC003BB5A7 /* globals_eval_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval_0x6d.html; sourceTree = ""; }; + 24A2FF310F90D1DC003BB5A7 /* globals_eval_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval_0x76.html; sourceTree = ""; }; + 24A2FF320F90D1DC003BB5A7 /* globals_func.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_func.html; sourceTree = ""; }; + 24A2FF330F90D1DC003BB5A7 /* globals_type.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_type.html; sourceTree = ""; }; + 24A2FF340F90D1DC003BB5A7 /* globals_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_vars.html; sourceTree = ""; }; + 24A2FF350F90D1DC003BB5A7 /* hierarchy.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = hierarchy.html; sourceTree = ""; }; + 24A2FF360F90D1DC003BB5A7 /* history.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = history.html; sourceTree = ""; }; + 24A2FF370F90D1DC003BB5A7 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = index.html; sourceTree = ""; }; + 24A2FF380F90D1DC003BB5A7 /* Initialisation.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Initialisation.gif; sourceTree = ""; }; + 24A2FF390F90D1DC003BB5A7 /* intro.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = intro.html; sourceTree = ""; }; + 24A2FF3A0F90D1DC003BB5A7 /* IOchange.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = IOchange.gif; sourceTree = ""; }; + 24A2FF3B0F90D1DC003BB5A7 /* license.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = license.html; sourceTree = ""; }; + 24A2FF3C0F90D1DC003BB5A7 /* maceditor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = maceditor.html; sourceTree = ""; }; + 24A2FF3D0F90D1DC003BB5A7 /* main.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = main.html; sourceTree = ""; }; + 24A2FF3E0F90D1DC003BB5A7 /* namespace_host_can_dos.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespace_host_can_dos.html; sourceTree = ""; }; + 24A2FF3F0F90D1DC003BB5A7 /* namespace_plug_can_dos.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespace_plug_can_dos.html; sourceTree = ""; }; + 24A2FF400F90D1DC003BB5A7 /* namespacemembers.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespacemembers.html; sourceTree = ""; }; + 24A2FF410F90D1DC003BB5A7 /* namespacemembers_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespacemembers_vars.html; sourceTree = ""; }; + 24A2FF420F90D1DC003BB5A7 /* namespaces.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespaces.html; sourceTree = ""; }; + 24A2FF430F90D1DC003BB5A7 /* Offlineprocessing.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Offlineprocessing.gif; sourceTree = ""; }; + 24A2FF440F90D1DC003BB5A7 /* others.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = others.html; sourceTree = ""; }; + 24A2FF450F90D1DC003BB5A7 /* pages.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = pages.html; sourceTree = ""; }; + 24A2FF460F90D1DC003BB5A7 /* Sampleratechange.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Sampleratechange.gif; sourceTree = ""; }; + 24A2FF470F90D1DC003BB5A7 /* sequences.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = sequences.html; sourceTree = ""; }; + 24A2FF480F90D1DC003BB5A7 /* SpeakerarrangementnegotiationforVSTfx.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = SpeakerarrangementnegotiationforVSTfx.gif; sourceTree = ""; }; + 24A2FF490F90D1DC003BB5A7 /* struct_a_effect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_a_effect-members.html"; sourceTree = ""; }; + 24A2FF4A0F90D1DC003BB5A7 /* struct_a_effect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_a_effect.html; sourceTree = ""; }; + 24A2FF4B0F90D1DC003BB5A7 /* struct_e_rect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_e_rect-members.html"; sourceTree = ""; }; + 24A2FF4C0F90D1DC003BB5A7 /* struct_e_rect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_e_rect.html; sourceTree = ""; }; + 24A2FF4D0F90D1DC003BB5A7 /* struct_midi_key_name-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_midi_key_name-members.html"; sourceTree = ""; }; + 24A2FF4E0F90D1DC003BB5A7 /* struct_midi_key_name.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_midi_key_name.html; sourceTree = ""; }; + 24A2FF4F0F90D1DC003BB5A7 /* struct_midi_program_category-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_midi_program_category-members.html"; sourceTree = ""; }; + 24A2FF500F90D1DC003BB5A7 /* struct_midi_program_category.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_midi_program_category.html; sourceTree = ""; }; + 24A2FF510F90D1DC003BB5A7 /* struct_midi_program_name-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_midi_program_name-members.html"; sourceTree = ""; }; + 24A2FF520F90D1DC003BB5A7 /* struct_midi_program_name.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_midi_program_name.html; sourceTree = ""; }; + 24A2FF530F90D1DC003BB5A7 /* struct_vst_audio_file-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_audio_file-members.html"; sourceTree = ""; }; + 24A2FF540F90D1DC003BB5A7 /* struct_vst_audio_file.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_audio_file.html; sourceTree = ""; }; + 24A2FF550F90D1DC003BB5A7 /* struct_vst_audio_file_marker-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_audio_file_marker-members.html"; sourceTree = ""; }; + 24A2FF560F90D1DC003BB5A7 /* struct_vst_audio_file_marker.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_audio_file_marker.html; sourceTree = ""; }; + 24A2FF570F90D1DC003BB5A7 /* struct_vst_event-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_event-members.html"; sourceTree = ""; }; + 24A2FF580F90D1DC003BB5A7 /* struct_vst_event.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_event.html; sourceTree = ""; }; + 24A2FF590F90D1DD003BB5A7 /* struct_vst_events-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_events-members.html"; sourceTree = ""; }; + 24A2FF5A0F90D1DD003BB5A7 /* struct_vst_events.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_events.html; sourceTree = ""; }; + 24A2FF5B0F90D1DD003BB5A7 /* struct_vst_file_select-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_file_select-members.html"; sourceTree = ""; }; + 24A2FF5C0F90D1DD003BB5A7 /* struct_vst_file_select.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_file_select.html; sourceTree = ""; }; + 24A2FF5D0F90D1DD003BB5A7 /* struct_vst_file_type-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_file_type-members.html"; sourceTree = ""; }; + 24A2FF5E0F90D1DD003BB5A7 /* struct_vst_file_type.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_file_type.html; sourceTree = ""; }; + 24A2FF5F0F90D1DD003BB5A7 /* struct_vst_key_code-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_key_code-members.html"; sourceTree = ""; }; + 24A2FF600F90D1DD003BB5A7 /* struct_vst_key_code.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_key_code.html; sourceTree = ""; }; + 24A2FF610F90D1DD003BB5A7 /* struct_vst_midi_event-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_midi_event-members.html"; sourceTree = ""; }; + 24A2FF620F90D1DD003BB5A7 /* struct_vst_midi_event.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_midi_event.html; sourceTree = ""; }; + 24A2FF630F90D1DD003BB5A7 /* struct_vst_midi_sysex_event-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_midi_sysex_event-members.html"; sourceTree = ""; }; + 24A2FF640F90D1DD003BB5A7 /* struct_vst_midi_sysex_event.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_midi_sysex_event.html; sourceTree = ""; }; + 24A2FF650F90D1DD003BB5A7 /* struct_vst_offline_task-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_offline_task-members.html"; sourceTree = ""; }; + 24A2FF660F90D1DD003BB5A7 /* struct_vst_offline_task.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_offline_task.html; sourceTree = ""; }; + 24A2FF670F90D1DD003BB5A7 /* struct_vst_parameter_properties-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_parameter_properties-members.html"; sourceTree = ""; }; + 24A2FF680F90D1DD003BB5A7 /* struct_vst_parameter_properties.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_parameter_properties.html; sourceTree = ""; }; + 24A2FF690F90D1DD003BB5A7 /* struct_vst_patch_chunk_info-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_patch_chunk_info-members.html"; sourceTree = ""; }; + 24A2FF6A0F90D1DD003BB5A7 /* struct_vst_patch_chunk_info.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_patch_chunk_info.html; sourceTree = ""; }; + 24A2FF6B0F90D1DD003BB5A7 /* struct_vst_pin_properties-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_pin_properties-members.html"; sourceTree = ""; }; + 24A2FF6C0F90D1DD003BB5A7 /* struct_vst_pin_properties.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_pin_properties.html; sourceTree = ""; }; + 24A2FF6D0F90D1DD003BB5A7 /* struct_vst_speaker_arrangement-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_speaker_arrangement-members.html"; sourceTree = ""; }; + 24A2FF6E0F90D1DD003BB5A7 /* struct_vst_speaker_arrangement.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_speaker_arrangement.html; sourceTree = ""; }; + 24A2FF6F0F90D1DD003BB5A7 /* struct_vst_speaker_properties-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_speaker_properties-members.html"; sourceTree = ""; }; + 24A2FF700F90D1DD003BB5A7 /* struct_vst_speaker_properties.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_speaker_properties.html; sourceTree = ""; }; + 24A2FF710F90D1DD003BB5A7 /* struct_vst_time_info-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_time_info-members.html"; sourceTree = ""; }; + 24A2FF720F90D1DD003BB5A7 /* struct_vst_time_info.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_time_info.html; sourceTree = ""; }; + 24A2FF730F90D1DD003BB5A7 /* struct_vst_variable_io-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_variable_io-members.html"; sourceTree = ""; }; + 24A2FF740F90D1DD003BB5A7 /* struct_vst_variable_io.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_variable_io.html; sourceTree = ""; }; + 24A2FF750F90D1DD003BB5A7 /* struct_vst_window-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_window-members.html"; sourceTree = ""; }; + 24A2FF760F90D1DD003BB5A7 /* struct_vst_window.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_window.html; sourceTree = ""; }; + 24A2FF770F90D1DD003BB5A7 /* structfx_bank-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "structfx_bank-members.html"; sourceTree = ""; }; + 24A2FF780F90D1DD003BB5A7 /* structfx_bank.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = structfx_bank.html; sourceTree = ""; }; + 24A2FF790F90D1DD003BB5A7 /* structfx_program-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "structfx_program-members.html"; sourceTree = ""; }; + 24A2FF7A0F90D1DD003BB5A7 /* structfx_program.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = structfx_program.html; sourceTree = ""; }; + 24A2FF7B0F90D1DD003BB5A7 /* tab_b.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_b.gif; sourceTree = ""; }; + 24A2FF7C0F90D1DD003BB5A7 /* tab_l.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_l.gif; sourceTree = ""; }; + 24A2FF7D0F90D1DD003BB5A7 /* tab_r.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_r.gif; sourceTree = ""; }; + 24A2FF7E0F90D1DD003BB5A7 /* tabs.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = tabs.css; sourceTree = ""; }; + 24A2FF7F0F90D1DD003BB5A7 /* Termination.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Termination.gif; sourceTree = ""; }; + 24A2FF800F90D1DD003BB5A7 /* thanks.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = thanks.html; sourceTree = ""; }; + 24A2FF810F90D1DD003BB5A7 /* tree.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = tree.html; sourceTree = ""; }; + 24A2FF820F90D1DD003BB5A7 /* TurnOff.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = TurnOff.gif; sourceTree = ""; }; + 24A2FF830F90D1DD003BB5A7 /* TurnOn.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = TurnOn.gif; sourceTree = ""; }; + 24A2FF840F90D1DD003BB5A7 /* vstfxstore_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = vstfxstore_8h.html; sourceTree = ""; }; + 24A2FF850F90D1DD003BB5A7 /* vstoffline.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = vstoffline.html; sourceTree = ""; }; + 24A2FF860F90D1DD003BB5A7 /* vstparamstruct.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = vstparamstruct.html; sourceTree = ""; }; + 24A2FF870F90D1DD003BB5A7 /* vstpluglogo.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = vstpluglogo.jpg; sourceTree = ""; }; + 24A2FF880F90D1DD003BB5A7 /* vstplugmain_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = vstplugmain_8cpp.html; sourceTree = ""; }; + 24A2FF890F90D1DD003BB5A7 /* whatsnew.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = whatsnew.html; sourceTree = ""; }; + 24A2FF8A0F90D1DD003BB5A7 /* sdk.menu.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = sdk.menu.html; sourceTree = ""; }; + 24A2FF8B0F90D1DD003BB5A7 /* sdk.overview.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = sdk.overview.html; sourceTree = ""; }; + 24A2FF8C0F90D1DD003BB5A7 /* sdkdoc.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = sdkdoc.css; sourceTree = ""; }; + 24A2FF8D0F90D1DD003BB5A7 /* VST Licensing Agreement.rtf */ = {isa = PBXFileReference; lastKnownFileType = text.rtf; path = "VST Licensing Agreement.rtf"; sourceTree = ""; }; + 24A2FF8E0F90D1DD003BB5A7 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = index.html; sourceTree = ""; }; + 24A2FF910F90D1DD003BB5A7 /* aeffect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aeffect.h; sourceTree = ""; }; + 24A2FF920F90D1DD003BB5A7 /* aeffectx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aeffectx.h; sourceTree = ""; }; + 24A2FF930F90D1DD003BB5A7 /* vstfxstore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstfxstore.h; sourceTree = ""; }; + 24A2FF980F90D1DD003BB5A7 /* adelay.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = adelay.cpp; sourceTree = ""; }; + 24A2FF990F90D1DD003BB5A7 /* adelay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adelay.h; sourceTree = ""; }; + 24A2FF9A0F90D1DD003BB5A7 /* adelaymain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = adelaymain.cpp; sourceTree = ""; }; + 24A2FF9D0F90D1DD003BB5A7 /* bmp00128.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp00128.bmp; sourceTree = ""; }; + 24A2FF9E0F90D1DD003BB5A7 /* bmp00129.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp00129.bmp; sourceTree = ""; }; + 24A2FF9F0F90D1DD003BB5A7 /* bmp00130.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp00130.bmp; sourceTree = ""; }; + 24A2FFA00F90D1DD003BB5A7 /* surrounddelay.rc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = surrounddelay.rc; sourceTree = ""; }; + 24A2FFA10F90D1DD003BB5A7 /* sdeditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sdeditor.cpp; sourceTree = ""; }; + 24A2FFA20F90D1DD003BB5A7 /* sdeditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sdeditor.h; sourceTree = ""; }; + 24A2FFA30F90D1DD003BB5A7 /* surrounddelay.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = surrounddelay.cpp; sourceTree = ""; }; + 24A2FFA40F90D1DD003BB5A7 /* surrounddelay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = surrounddelay.h; sourceTree = ""; }; + 24A2FFA60F90D1DD003BB5A7 /* adelay.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = adelay.vcproj; sourceTree = ""; }; + 24A2FFA70F90D1DD003BB5A7 /* surrounddelay.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = surrounddelay.vcproj; sourceTree = ""; }; + 24A2FFAA0F90D1DD003BB5A7 /* again.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = again.cpp; sourceTree = ""; }; + 24A2FFAB0F90D1DD003BB5A7 /* again.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = again.h; sourceTree = ""; }; + 24A2FFAD0F90D1DD003BB5A7 /* again.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = again.vcproj; sourceTree = ""; }; + 24A2FFAF0F90D1DD003BB5A7 /* minihost-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = "minihost-Info.plist"; sourceTree = ""; }; + 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = "vst 2.4 examples.xcodeproj"; sourceTree = ""; }; + 24A2FFB30F90D1DD003BB5A7 /* vst2.4Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = vst2.4Info.plist; sourceTree = ""; }; + 24A2FFB60F90D1DD003BB5A7 /* minieditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = minieditor.cpp; sourceTree = ""; }; + 24A2FFB70F90D1DD003BB5A7 /* minihost.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = minihost.cpp; sourceTree = ""; }; + 24A2FFB90F90D1DD003BB5A7 /* minihost.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = minihost.vcproj; sourceTree = ""; }; + 24A2FFBC0F90D1DD003BB5A7 /* vstxsynth.rc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = vstxsynth.rc; sourceTree = ""; }; + 24A2FFBD0F90D1DD003BB5A7 /* vstxsynth.vstxml */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = vstxsynth.vstxml; sourceTree = ""; }; + 24A2FFBF0F90D1DD003BB5A7 /* gmnames.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gmnames.h; sourceTree = ""; }; + 24A2FFC00F90D1DD003BB5A7 /* vstxsynth.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstxsynth.cpp; sourceTree = ""; }; + 24A2FFC10F90D1DD003BB5A7 /* vstxsynth.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstxsynth.h; sourceTree = ""; }; + 24A2FFC20F90D1DD003BB5A7 /* vstxsynthproc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstxsynthproc.cpp; sourceTree = ""; }; + 24A2FFC40F90D1DD003BB5A7 /* vstxsynth.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = vstxsynth.vcproj; sourceTree = ""; }; + 24A2FFC60F90D1DD003BB5A7 /* samples.sln */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = samples.sln; sourceTree = ""; }; + 24A2FFC70F90D1DD003BB5A7 /* vstplug.def */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = vstplug.def; sourceTree = ""; }; + 24A2FFC90F90D1DD003BB5A7 /* adelay.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = adelay.vcproj; sourceTree = ""; }; + 24A2FFCA0F90D1DD003BB5A7 /* again.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = again.vcproj; sourceTree = ""; }; + 24A2FFCB0F90D1DD003BB5A7 /* minihost.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = minihost.vcproj; sourceTree = ""; }; + 24A2FFCC0F90D1DD003BB5A7 /* samples.sln */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = samples.sln; sourceTree = ""; }; + 24A2FFCD0F90D1DD003BB5A7 /* surrounddelay.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = surrounddelay.vcproj; sourceTree = ""; }; + 24A2FFCE0F90D1DD003BB5A7 /* vstxsynth.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = vstxsynth.vcproj; sourceTree = ""; }; + 24A2FFD00F90D1DD003BB5A7 /* adelay.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = adelay.dsp; sourceTree = ""; }; + 24A2FFD10F90D1DD003BB5A7 /* again.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = again.dsp; sourceTree = ""; }; + 24A2FFD20F90D1DD003BB5A7 /* minihost.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = minihost.dsp; sourceTree = ""; }; + 24A2FFD30F90D1DD003BB5A7 /* samples.dsw */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = samples.dsw; sourceTree = ""; }; + 24A2FFD40F90D1DD003BB5A7 /* surrounddelay.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = surrounddelay.dsp; sourceTree = ""; }; + 24A2FFD50F90D1DD003BB5A7 /* vstxsynth.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = vstxsynth.dsp; sourceTree = ""; }; + 24A2FFD80F90D1DD003BB5A7 /* aeffeditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aeffeditor.h; sourceTree = ""; }; + 24A2FFD90F90D1DD003BB5A7 /* audioeffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = audioeffect.cpp; sourceTree = ""; }; + 24A2FFDA0F90D1DD003BB5A7 /* audioeffect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = audioeffect.h; sourceTree = ""; }; + 24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = audioeffectx.cpp; sourceTree = ""; }; + 24A2FFDC0F90D1DD003BB5A7 /* audioeffectx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = audioeffectx.h; sourceTree = ""; }; + 24A2FFDD0F90D1DD003BB5A7 /* vstplugmain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstplugmain.cpp; sourceTree = ""; }; + 24A2FFE10F90D1DD003BB5A7 /* audiounit.exp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.exports; path = audiounit.exp; sourceTree = ""; }; + 24A2FFE20F90D1DD003BB5A7 /* cw_vst_prefix.pch++ */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "cw_vst_prefix.pch++"; sourceTree = ""; }; + 24A2FFE30F90D1DD003BB5A7 /* drawtest.cw9prj */ = {isa = PBXFileReference; lastKnownFileType = file; path = drawtest.cw9prj; sourceTree = ""; }; + 24A2FFE40F90D1DD003BB5A7 /* drawtest.plc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.plc; sourceTree = ""; }; + 24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = drawtest.xcode; sourceTree = ""; }; + 24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = drawtest.xcodeproj; sourceTree = ""; }; + 24A2FFEB0F90D1DD003BB5A7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 24A2FFEC0F90D1DD003BB5A7 /* xcode_au_prefix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xcode_au_prefix.h; sourceTree = ""; }; + 24A2FFED0F90D1DD003BB5A7 /* xcode_vst_prefix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xcode_vst_prefix.h; sourceTree = ""; }; + 24A2FFEF0F90D1DD003BB5A7 /* audiounit.r */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.rez; path = audiounit.r; sourceTree = ""; }; + 24A2FFF00F90D1DD003BB5A7 /* bmp00001.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = bmp00001.png; sourceTree = ""; }; + 24A2FFF10F90D1DD003BB5A7 /* bmp00100.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = bmp00100.png; sourceTree = ""; }; + 24A2FFF20F90D1DD003BB5A7 /* bmp01000.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = bmp01000.png; sourceTree = ""; }; + 24A2FFF30F90D1DD003BB5A7 /* bmp10001.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10001.bmp; sourceTree = ""; }; + 24A2FFF40F90D1DD003BB5A7 /* bmp10002.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10002.bmp; sourceTree = ""; }; + 24A2FFF50F90D1DD003BB5A7 /* bmp10003.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10003.bmp; sourceTree = ""; }; + 24A2FFF60F90D1DD003BB5A7 /* bmp10004.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10004.bmp; sourceTree = ""; }; + 24A2FFF70F90D1DD003BB5A7 /* bmp10005.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10005.bmp; sourceTree = ""; }; + 24A2FFF80F90D1DD003BB5A7 /* bmp10006.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10006.bmp; sourceTree = ""; }; + 24A2FFF90F90D1DD003BB5A7 /* bmp10007.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10007.bmp; sourceTree = ""; }; + 24A2FFFA0F90D1DD003BB5A7 /* bmp10008.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10008.bmp; sourceTree = ""; }; + 24A2FFFB0F90D1DD003BB5A7 /* bmp10009.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10009.bmp; sourceTree = ""; }; + 24A2FFFC0F90D1DD003BB5A7 /* bmp10010.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10010.bmp; sourceTree = ""; }; + 24A2FFFD0F90D1DD003BB5A7 /* bmp10011.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10011.bmp; sourceTree = ""; }; + 24A2FFFE0F90D1DD003BB5A7 /* bmp10012.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10012.bmp; sourceTree = ""; }; + 24A2FFFF0F90D1DD003BB5A7 /* bmp10013.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10013.bmp; sourceTree = ""; }; + 24CFB70307E7A0220081BD57 /* PkgInfo */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = PkgInfo; path = mac/PkgInfo; sourceTree = ""; }; + 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = PocketVerbsProc.cpp; path = source/PocketVerbsProc.cpp; sourceTree = ""; }; + 24D8287E09A9164A0093AEF8 /* xcode_vst_prefix.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = xcode_vst_prefix.h; path = mac/xcode_vst_prefix.h; sourceTree = SOURCE_ROOT; }; + 8D01CCD10486CAD60068D4B7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = mac/Info.plist; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXGroup section */ + 089C166AFE841209C02AAC07 /* FM-Chopper */ = { + isa = PBXGroup; + children = ( + 089C1671FE841209C02AAC07 /* External Frameworks and Libraries */, + 19C28FB4FE9D528D11CA2CBB /* Products */, + 089C167CFE841241C02AAC07 /* Resources */, + 08FB77ADFE841716C02AAC07 /* Source */, + 24A2FEBB0F90D1DB003BB5A7 /* vstsdk2.4 */, + ); + name = "FM-Chopper"; + sourceTree = ""; + }; + 089C1671FE841209C02AAC07 /* External Frameworks and Libraries */ = { + isa = PBXGroup; + children = ( + 2434720A098313350063BBF1 /* QuickTime.framework */, + 08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */, + ); + name = "External Frameworks and Libraries"; + sourceTree = ""; + }; + 089C167CFE841241C02AAC07 /* Resources */ = { + isa = PBXGroup; + children = ( + 24D8287E09A9164A0093AEF8 /* xcode_vst_prefix.h */, + 24CFB70307E7A0220081BD57 /* PkgInfo */, + 8D01CCD10486CAD60068D4B7 /* Info.plist */, + ); + name = Resources; + sourceTree = ""; + }; + 08FB77ADFE841716C02AAC07 /* Source */ = { + isa = PBXGroup; + children = ( + 2407DEB6089929BA00EB68BF /* PocketVerbs.cpp */, + 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */, + 245463B80991757100464AD3 /* PocketVerbs.h */, + ); + name = Source; + sourceTree = ""; + }; + 19C28FB4FE9D528D11CA2CBB /* Products */ = { + isa = PBXGroup; + children = ( + 2407DE920899296600EB68BF /* PocketVerbs.vst */, + ); + name = Products; + sourceTree = ""; + }; + 24A200030F90D1DD003BB5A7 /* source */ = { + isa = PBXGroup; + children = ( + 24A200040F90D1DD003BB5A7 /* controlsgui.cpp */, + 24A200050F90D1DD003BB5A7 /* controlsgui.h */, + 24A200060F90D1DD003BB5A7 /* pdrawtesteditor.cpp */, + 24A200070F90D1DD003BB5A7 /* pdrawtesteditor.h */, + 24A200080F90D1DD003BB5A7 /* pdrawtesteffect.cpp */, + 24A200090F90D1DD003BB5A7 /* pdrawtesteffect.h */, + 24A2000A0F90D1DD003BB5A7 /* pdrawtestmain.cpp */, + 24A2000B0F90D1DD003BB5A7 /* pdrawtestview.cpp */, + 24A2000C0F90D1DD003BB5A7 /* pdrawtestview.h */, + 24A2000D0F90D1DD003BB5A7 /* pprimitivesviews.cpp */, + 24A2000E0F90D1DD003BB5A7 /* pprimitivesviews.h */, + ); + name = source; + path = /vstsdk2.4/vstgui.sf/drawtest/source; + sourceTree = ""; + }; + 24A2000F0F90D1DD003BB5A7 /* win */ = { + isa = PBXGroup; + children = ( + 24A200100F90D1DD003BB5A7 /* drawtest.def */, + 24A200110F90D1DD003BB5A7 /* drawtest.rc */, + 24A200120F90D1DD003BB5A7 /* drawtest.vcproj */, + ); + name = win; + path = /vstsdk2.4/vstgui.sf/drawtest/win; + sourceTree = ""; + }; + 24A200130F90D1DD003BB5A7 /* win.vc6 */ = { + isa = PBXGroup; + children = ( + 24A200140F90D1DD003BB5A7 /* drawtest.dsp */, + 24A200150F90D1DD003BB5A7 /* drawtest.dsw */, + ); + name = win.vc6; + path = /vstsdk2.4/vstgui.sf/drawtest/win.vc6; + sourceTree = ""; + }; + 24A200160F90D1DD003BB5A7 /* vstgui */ = { + isa = PBXGroup; + children = ( + 24A200170F90D1DD003BB5A7 /* aeffguieditor.cpp */, + 24A200180F90D1DD003BB5A7 /* aeffguieditor.h */, + 24A200190F90D1DD003BB5A7 /* cfileselector.cpp */, + 24A2001A0F90D1DD003BB5A7 /* cfileselector.h */, + 24A2001B0F90D1DD003BB5A7 /* Changelog */, + 24A2001C0F90D1DD003BB5A7 /* cscrollview.cpp */, + 24A2001D0F90D1DD003BB5A7 /* cscrollview.h */, + 24A2001E0F90D1DD003BB5A7 /* ctabview.cpp */, + 24A2001F0F90D1DD003BB5A7 /* ctabview.h */, + 24A200200F90D1DD003BB5A7 /* Documentation */, + 24A201460F90D1DE003BB5A7 /* plugguieditor.cpp */, + 24A201470F90D1DE003BB5A7 /* plugguieditor.h */, + 24A201480F90D1DE003BB5A7 /* vstcontrols.cpp */, + 24A201490F90D1DE003BB5A7 /* vstcontrols.h */, + 24A2014A0F90D1DE003BB5A7 /* vstgui.cpp */, + 24A2014B0F90D1DE003BB5A7 /* vstgui.h */, + 24A2014C0F90D1DE003BB5A7 /* vstkeycode.h */, + 24A2014D0F90D1DE003BB5A7 /* vstplugscarbon.h */, + 24A2014E0F90D1DE003BB5A7 /* vstplugsmac.h */, + 24A2014F0F90D1DE003BB5A7 /* vstplugsmacho.h */, + 24A201500F90D1DE003BB5A7 /* vstplugsquartz.h */, + ); + name = vstgui; + path = /vstsdk2.4/vstgui.sf/vstgui; + sourceTree = ""; + }; + 24A200200F90D1DD003BB5A7 /* Documentation */ = { + isa = PBXGroup; + children = ( + 24A200210F90D1DD003BB5A7 /* html */, + 24A201440F90D1DE003BB5A7 /* index.html */, + 24A201450F90D1DE003BB5A7 /* Migrating from 2.3.rtf */, + ); + name = Documentation; + path = /vstsdk2.4/vstgui.sf/vstgui/Documentation; + sourceTree = ""; + }; + 24A200210F90D1DD003BB5A7 /* html */ = { + isa = PBXGroup; + children = ( + 24A200220F90D1DD003BB5A7 /* aeffguieditor_8cpp.html */, + 24A200230F90D1DD003BB5A7 /* aeffguieditor_8h.html */, + 24A200240F90D1DD003BB5A7 /* annotated.html */, + 24A200250F90D1DD003BB5A7 /* cfileselector_8cpp.html */, + 24A200260F90D1DD003BB5A7 /* cfileselector_8h.html */, + 24A200270F90D1DD003BB5A7 /* class_a_eff_g_u_i_editor-members.html */, + 24A200280F90D1DD003BB5A7 /* class_a_eff_g_u_i_editor.html */, + 24A200290F90D1DD003BB5A7 /* class_c_anim_knob-members.html */, + 24A2002A0F90D1DD003BB5A7 /* class_c_anim_knob.html */, + 24A2002B0F90D1DD003BB5A7 /* class_c_anim_knob.png */, + 24A2002C0F90D1DD003BB5A7 /* class_c_attribute_list_entry-members.html */, + 24A2002D0F90D1DD003BB5A7 /* class_c_attribute_list_entry.html */, + 24A2002E0F90D1DD003BB5A7 /* class_c_auto_animation-members.html */, + 24A2002F0F90D1DD003BB5A7 /* class_c_auto_animation.html */, + 24A200300F90D1DD003BB5A7 /* class_c_auto_animation.png */, + 24A200310F90D1DD003BB5A7 /* class_c_bitmap-members.html */, + 24A200320F90D1DD003BB5A7 /* class_c_bitmap.html */, + 24A200330F90D1DD003BB5A7 /* class_c_bitmap.png */, + 24A200340F90D1DD003BB5A7 /* class_c_c_view-members.html */, + 24A200350F90D1DD003BB5A7 /* class_c_c_view.html */, + 24A200360F90D1DD003BB5A7 /* class_c_control-members.html */, + 24A200370F90D1DD003BB5A7 /* class_c_control.html */, + 24A200380F90D1DD003BB5A7 /* class_c_control.png */, + 24A200390F90D1DD003BB5A7 /* class_c_control_listener-members.html */, + 24A2003A0F90D1DD003BB5A7 /* class_c_control_listener.html */, + 24A2003B0F90D1DD003BB5A7 /* class_c_control_listener.png */, + 24A2003C0F90D1DD003BB5A7 /* class_c_drag_container-members.html */, + 24A2003D0F90D1DD003BB5A7 /* class_c_drag_container.html */, + 24A2003E0F90D1DD003BB5A7 /* class_c_drag_container.png */, + 24A2003F0F90D1DD003BB5A7 /* class_c_draw_context-members.html */, + 24A200400F90D1DD003BB5A7 /* class_c_draw_context.html */, + 24A200410F90D1DD003BB5A7 /* class_c_draw_context.png */, + 24A200420F90D1DD003BB5A7 /* class_c_file_selector-members.html */, + 24A200430F90D1DD003BB5A7 /* class_c_file_selector.html */, + 24A200440F90D1DD003BB5A7 /* class_c_frame-members.html */, + 24A200450F90D1DD003BB5A7 /* class_c_frame.html */, + 24A200460F90D1DD003BB5A7 /* class_c_frame.png */, + 24A200470F90D1DD003BB5A7 /* class_c_horizontal_slider-members.html */, + 24A200480F90D1DD003BB5A7 /* class_c_horizontal_slider.html */, + 24A200490F90D1DD003BB5A7 /* class_c_horizontal_slider.png */, + 24A2004A0F90D1DD003BB5A7 /* class_c_horizontal_switch-members.html */, + 24A2004B0F90D1DD003BB5A7 /* class_c_horizontal_switch.html */, + 24A2004C0F90D1DD003BB5A7 /* class_c_horizontal_switch.png */, + 24A2004D0F90D1DD003BB5A7 /* class_c_kick_button-members.html */, + 24A2004E0F90D1DD003BB5A7 /* class_c_kick_button.html */, + 24A2004F0F90D1DD003BB5A7 /* class_c_kick_button.png */, + 24A200500F90D1DD003BB5A7 /* class_c_knob-members.html */, + 24A200510F90D1DD003BB5A7 /* class_c_knob.html */, + 24A200520F90D1DD003BB5A7 /* class_c_knob.png */, + 24A200530F90D1DD003BB5A7 /* class_c_movie_bitmap-members.html */, + 24A200540F90D1DD003BB5A7 /* class_c_movie_bitmap.html */, + 24A200550F90D1DD003BB5A7 /* class_c_movie_bitmap.png */, + 24A200560F90D1DD003BB5A7 /* class_c_movie_button-members.html */, + 24A200570F90D1DD003BB5A7 /* class_c_movie_button.html */, + 24A200580F90D1DD003BB5A7 /* class_c_movie_button.png */, + 24A200590F90D1DD003BB5A7 /* class_c_offscreen_context-members.html */, + 24A2005A0F90D1DD003BB5A7 /* class_c_offscreen_context.html */, + 24A2005B0F90D1DD003BB5A7 /* class_c_offscreen_context.png */, + 24A2005C0F90D1DD003BB5A7 /* class_c_on_off_button-members.html */, + 24A2005D0F90D1DD003BB5A7 /* class_c_on_off_button.html */, + 24A2005E0F90D1DD003BB5A7 /* class_c_on_off_button.png */, + 24A2005F0F90D1DD003BB5A7 /* class_c_option_menu-members.html */, + 24A200600F90D1DD003BB5A7 /* class_c_option_menu.html */, + 24A200610F90D1DD003BB5A7 /* class_c_option_menu.png */, + 24A200620F90D1DD003BB5A7 /* class_c_option_menu_scheme-members.html */, + 24A200630F90D1DD003BB5A7 /* class_c_option_menu_scheme.html */, + 24A200640F90D1DD003BB5A7 /* class_c_option_menu_scheme.png */, + 24A200650F90D1DD003BB5A7 /* class_c_param_display-members.html */, + 24A200660F90D1DD003BB5A7 /* class_c_param_display.html */, + 24A200670F90D1DD003BB5A7 /* class_c_param_display.png */, + 24A200680F90D1DD003BB5A7 /* class_c_reference_counter-members.html */, + 24A200690F90D1DD003BB5A7 /* class_c_reference_counter.html */, + 24A2006A0F90D1DD003BB5A7 /* class_c_reference_counter.png */, + 24A2006B0F90D1DD003BB5A7 /* class_c_rocker_switch-members.html */, + 24A2006C0F90D1DD003BB5A7 /* class_c_rocker_switch.html */, + 24A2006D0F90D1DD003BB5A7 /* class_c_rocker_switch.png */, + 24A2006E0F90D1DD003BB5A7 /* class_c_scroll_container-members.html */, + 24A2006F0F90D1DD003BB5A7 /* class_c_scroll_container.html */, + 24A200700F90D1DD003BB5A7 /* class_c_scroll_container.png */, + 24A200710F90D1DD003BB5A7 /* class_c_scroll_view-members.html */, + 24A200720F90D1DD003BB5A7 /* class_c_scroll_view.html */, + 24A200730F90D1DD003BB5A7 /* class_c_scroll_view.png */, + 24A200740F90D1DD003BB5A7 /* class_c_scrollbar-members.html */, + 24A200750F90D1DD003BB5A7 /* class_c_scrollbar.html */, + 24A200760F90D1DD003BB5A7 /* class_c_scrollbar.png */, + 24A200770F90D1DD003BB5A7 /* class_c_slider-members.html */, + 24A200780F90D1DD003BB5A7 /* class_c_slider.html */, + 24A200790F90D1DD003BB5A7 /* class_c_slider.png */, + 24A2007A0F90D1DD003BB5A7 /* class_c_special_digit-members.html */, + 24A2007B0F90D1DD003BB5A7 /* class_c_special_digit.html */, + 24A2007C0F90D1DD003BB5A7 /* class_c_special_digit.png */, + 24A2007D0F90D1DD003BB5A7 /* class_c_splash_screen-members.html */, + 24A2007E0F90D1DD003BB5A7 /* class_c_splash_screen.html */, + 24A2007F0F90D1DD003BB5A7 /* class_c_splash_screen.png */, + 24A200800F90D1DD003BB5A7 /* class_c_splash_screen_view-members.html */, + 24A200810F90D1DD003BB5A7 /* class_c_splash_screen_view.html */, + 24A200820F90D1DD003BB5A7 /* class_c_splash_screen_view.png */, + 24A200830F90D1DD003BB5A7 /* class_c_tab_button-members.html */, + 24A200840F90D1DD003BB5A7 /* class_c_tab_button.html */, + 24A200850F90D1DD003BB5A7 /* class_c_tab_button.png */, + 24A200860F90D1DD003BB5A7 /* class_c_tab_child_view-members.html */, + 24A200870F90D1DD003BB5A7 /* class_c_tab_child_view.html */, + 24A200880F90D1DD003BB5A7 /* class_c_tab_child_view.png */, + 24A200890F90D1DD003BB5A7 /* class_c_tab_view-members.html */, + 24A2008A0F90D1DD003BB5A7 /* class_c_tab_view.html */, + 24A2008B0F90D1DD003BB5A7 /* class_c_tab_view.png */, + 24A2008C0F90D1DD003BB5A7 /* class_c_text_edit-members.html */, + 24A2008D0F90D1DD003BB5A7 /* class_c_text_edit.html */, + 24A2008E0F90D1DD003BB5A7 /* class_c_text_edit.png */, + 24A2008F0F90D1DD003BB5A7 /* class_c_text_label-members.html */, + 24A200900F90D1DD003BB5A7 /* class_c_text_label.html */, + 24A200910F90D1DD003BB5A7 /* class_c_text_label.png */, + 24A200920F90D1DD003BB5A7 /* class_c_vertical_slider-members.html */, + 24A200930F90D1DD003BB5A7 /* class_c_vertical_slider.html */, + 24A200940F90D1DD003BB5A7 /* class_c_vertical_slider.png */, + 24A200950F90D1DD003BB5A7 /* class_c_vertical_switch-members.html */, + 24A200960F90D1DD003BB5A7 /* class_c_vertical_switch.html */, + 24A200970F90D1DD003BB5A7 /* class_c_vertical_switch.png */, + 24A200980F90D1DD003BB5A7 /* class_c_view-members.html */, + 24A200990F90D1DD003BB5A7 /* class_c_view.html */, + 24A2009A0F90D1DD003BB5A7 /* class_c_view.png */, + 24A2009B0F90D1DD003BB5A7 /* class_c_view_container-members.html */, + 24A2009C0F90D1DD003BB5A7 /* class_c_view_container.html */, + 24A2009D0F90D1DD003BB5A7 /* class_c_view_container.png */, + 24A2009E0F90D1DD003BB5A7 /* class_c_vu_meter-members.html */, + 24A2009F0F90D1DD003BB5A7 /* class_c_vu_meter.html */, + 24A200A00F90D1DD003BB5A7 /* class_c_vu_meter.png */, + 24A200A10F90D1DD003BB5A7 /* class_i_scrollbar_drawer-members.html */, + 24A200A20F90D1DD003BB5A7 /* class_i_scrollbar_drawer.html */, + 24A200A30F90D1DD003BB5A7 /* class_plugin_g_u_i_editor-members.html */, + 24A200A40F90D1DD003BB5A7 /* class_plugin_g_u_i_editor.html */, + 24A200A50F90D1DD003BB5A7 /* cscrollview_8cpp.html */, + 24A200A60F90D1DD003BB5A7 /* cscrollview_8h.html */, + 24A200A70F90D1DD003BB5A7 /* ctabview_8cpp.html */, + 24A200A80F90D1DD003BB5A7 /* ctabview_8h.html */, + 24A200A90F90D1DD003BB5A7 /* deprecated.html */, + 24A200AA0F90D1DD003BB5A7 /* doc_8h.html */, + 24A200AB0F90D1DD003BB5A7 /* doxygen.css */, + 24A200AC0F90D1DD003BB5A7 /* doxygen.png */, + 24A200AD0F90D1DD003BB5A7 /* files.html */, + 24A200AE0F90D1DD003BB5A7 /* ftv2blank.png */, + 24A200AF0F90D1DD003BB5A7 /* ftv2doc.png */, + 24A200B00F90D1DD003BB5A7 /* ftv2folderclosed.png */, + 24A200B10F90D1DE003BB5A7 /* ftv2folderopen.png */, + 24A200B20F90D1DE003BB5A7 /* ftv2lastnode.png */, + 24A200B30F90D1DE003BB5A7 /* ftv2link.png */, + 24A200B40F90D1DE003BB5A7 /* ftv2mlastnode.png */, + 24A200B50F90D1DE003BB5A7 /* ftv2mnode.png */, + 24A200B60F90D1DE003BB5A7 /* ftv2node.png */, + 24A200B70F90D1DE003BB5A7 /* ftv2plastnode.png */, + 24A200B80F90D1DE003BB5A7 /* ftv2pnode.png */, + 24A200B90F90D1DE003BB5A7 /* ftv2vertline.png */, + 24A200BA0F90D1DE003BB5A7 /* functions.html */, + 24A200BB0F90D1DE003BB5A7 /* functions_0x62.html */, + 24A200BC0F90D1DE003BB5A7 /* functions_0x63.html */, + 24A200BD0F90D1DE003BB5A7 /* functions_0x64.html */, + 24A200BE0F90D1DE003BB5A7 /* functions_0x65.html */, + 24A200BF0F90D1DE003BB5A7 /* functions_0x66.html */, + 24A200C00F90D1DE003BB5A7 /* functions_0x67.html */, + 24A200C10F90D1DE003BB5A7 /* functions_0x68.html */, + 24A200C20F90D1DE003BB5A7 /* functions_0x69.html */, + 24A200C30F90D1DE003BB5A7 /* functions_0x6b.html */, + 24A200C40F90D1DE003BB5A7 /* functions_0x6c.html */, + 24A200C50F90D1DE003BB5A7 /* functions_0x6d.html */, + 24A200C60F90D1DE003BB5A7 /* functions_0x6e.html */, + 24A200C70F90D1DE003BB5A7 /* functions_0x6f.html */, + 24A200C80F90D1DE003BB5A7 /* functions_0x70.html */, + 24A200C90F90D1DE003BB5A7 /* functions_0x72.html */, + 24A200CA0F90D1DE003BB5A7 /* functions_0x73.html */, + 24A200CB0F90D1DE003BB5A7 /* functions_0x74.html */, + 24A200CC0F90D1DE003BB5A7 /* functions_0x75.html */, + 24A200CD0F90D1DE003BB5A7 /* functions_0x76.html */, + 24A200CE0F90D1DE003BB5A7 /* functions_0x77.html */, + 24A200CF0F90D1DE003BB5A7 /* functions_0x78.html */, + 24A200D00F90D1DE003BB5A7 /* functions_0x79.html */, + 24A200D10F90D1DE003BB5A7 /* functions_0x7a.html */, + 24A200D20F90D1DE003BB5A7 /* functions_0x7e.html */, + 24A200D30F90D1DE003BB5A7 /* functions_eval.html */, + 24A200D40F90D1DE003BB5A7 /* functions_func.html */, + 24A200D50F90D1DE003BB5A7 /* functions_func_0x62.html */, + 24A200D60F90D1DE003BB5A7 /* functions_func_0x63.html */, + 24A200D70F90D1DE003BB5A7 /* functions_func_0x64.html */, + 24A200D80F90D1DE003BB5A7 /* functions_func_0x65.html */, + 24A200D90F90D1DE003BB5A7 /* functions_func_0x66.html */, + 24A200DA0F90D1DE003BB5A7 /* functions_func_0x67.html */, + 24A200DB0F90D1DE003BB5A7 /* functions_func_0x68.html */, + 24A200DC0F90D1DE003BB5A7 /* functions_func_0x69.html */, + 24A200DD0F90D1DE003BB5A7 /* functions_func_0x6c.html */, + 24A200DE0F90D1DE003BB5A7 /* functions_func_0x6d.html */, + 24A200DF0F90D1DE003BB5A7 /* functions_func_0x6e.html */, + 24A200E00F90D1DE003BB5A7 /* functions_func_0x6f.html */, + 24A200E10F90D1DE003BB5A7 /* functions_func_0x70.html */, + 24A200E20F90D1DE003BB5A7 /* functions_func_0x72.html */, + 24A200E30F90D1DE003BB5A7 /* functions_func_0x73.html */, + 24A200E40F90D1DE003BB5A7 /* functions_func_0x74.html */, + 24A200E50F90D1DE003BB5A7 /* functions_func_0x75.html */, + 24A200E60F90D1DE003BB5A7 /* functions_func_0x76.html */, + 24A200E70F90D1DE003BB5A7 /* functions_func_0x77.html */, + 24A200E80F90D1DE003BB5A7 /* functions_func_0x7e.html */, + 24A200E90F90D1DE003BB5A7 /* functions_rela.html */, + 24A200EA0F90D1DE003BB5A7 /* functions_vars.html */, + 24A200EB0F90D1DE003BB5A7 /* functions_vars_0x62.html */, + 24A200EC0F90D1DE003BB5A7 /* functions_vars_0x63.html */, + 24A200ED0F90D1DE003BB5A7 /* functions_vars_0x64.html */, + 24A200EE0F90D1DE003BB5A7 /* functions_vars_0x65.html */, + 24A200EF0F90D1DE003BB5A7 /* functions_vars_0x66.html */, + 24A200F00F90D1DE003BB5A7 /* functions_vars_0x67.html */, + 24A200F10F90D1DE003BB5A7 /* functions_vars_0x68.html */, + 24A200F20F90D1DE003BB5A7 /* functions_vars_0x69.html */, + 24A200F30F90D1DE003BB5A7 /* functions_vars_0x6b.html */, + 24A200F40F90D1DE003BB5A7 /* functions_vars_0x6c.html */, + 24A200F50F90D1DE003BB5A7 /* functions_vars_0x6d.html */, + 24A200F60F90D1DE003BB5A7 /* functions_vars_0x6e.html */, + 24A200F70F90D1DE003BB5A7 /* functions_vars_0x6f.html */, + 24A200F80F90D1DE003BB5A7 /* functions_vars_0x70.html */, + 24A200F90F90D1DE003BB5A7 /* functions_vars_0x72.html */, + 24A200FA0F90D1DE003BB5A7 /* functions_vars_0x73.html */, + 24A200FB0F90D1DE003BB5A7 /* functions_vars_0x74.html */, + 24A200FC0F90D1DE003BB5A7 /* functions_vars_0x75.html */, + 24A200FD0F90D1DE003BB5A7 /* functions_vars_0x76.html */, + 24A200FE0F90D1DE003BB5A7 /* functions_vars_0x77.html */, + 24A200FF0F90D1DE003BB5A7 /* functions_vars_0x78.html */, + 24A201000F90D1DE003BB5A7 /* functions_vars_0x79.html */, + 24A201010F90D1DE003BB5A7 /* functions_vars_0x7a.html */, + 24A201020F90D1DE003BB5A7 /* globals.html */, + 24A201030F90D1DE003BB5A7 /* globals_0x61.html */, + 24A201040F90D1DE003BB5A7 /* globals_0x62.html */, + 24A201050F90D1DE003BB5A7 /* globals_0x63.html */, + 24A201060F90D1DE003BB5A7 /* globals_0x65.html */, + 24A201070F90D1DE003BB5A7 /* globals_0x66.html */, + 24A201080F90D1DE003BB5A7 /* globals_0x67.html */, + 24A201090F90D1DE003BB5A7 /* globals_0x6b.html */, + 24A2010A0F90D1DE003BB5A7 /* globals_0x6d.html */, + 24A2010B0F90D1DE003BB5A7 /* globals_0x6e.html */, + 24A2010C0F90D1DE003BB5A7 /* globals_0x6f.html */, + 24A2010D0F90D1DE003BB5A7 /* globals_0x71.html */, + 24A2010E0F90D1DE003BB5A7 /* globals_0x72.html */, + 24A2010F0F90D1DE003BB5A7 /* globals_0x73.html */, + 24A201100F90D1DE003BB5A7 /* globals_0x74.html */, + 24A201110F90D1DE003BB5A7 /* globals_0x75.html */, + 24A201120F90D1DE003BB5A7 /* globals_0x76.html */, + 24A201130F90D1DE003BB5A7 /* globals_0x77.html */, + 24A201140F90D1DE003BB5A7 /* globals_defs.html */, + 24A201150F90D1DE003BB5A7 /* globals_enum.html */, + 24A201160F90D1DE003BB5A7 /* globals_eval.html */, + 24A201170F90D1DE003BB5A7 /* globals_type.html */, + 24A201180F90D1DE003BB5A7 /* globals_vars.html */, + 24A201190F90D1DE003BB5A7 /* hierarchy.html */, + 24A2011A0F90D1DE003BB5A7 /* index.html */, + 24A2011B0F90D1DE003BB5A7 /* intro.html */, + 24A2011C0F90D1DE003BB5A7 /* license.html */, + 24A2011D0F90D1DE003BB5A7 /* maceditor.html */, + 24A2011E0F90D1DE003BB5A7 /* main.html */, + 24A2011F0F90D1DE003BB5A7 /* others.html */, + 24A201200F90D1DE003BB5A7 /* pages.html */, + 24A201210F90D1DE003BB5A7 /* plugguieditor_8cpp.html */, + 24A201220F90D1DE003BB5A7 /* plugguieditor_8h.html */, + 24A201230F90D1DE003BB5A7 /* sequences.html */, + 24A201240F90D1DE003BB5A7 /* struct_c_color-members.html */, + 24A201250F90D1DE003BB5A7 /* struct_c_color.html */, + 24A201260F90D1DE003BB5A7 /* struct_c_point-members.html */, + 24A201270F90D1DE003BB5A7 /* struct_c_point.html */, + 24A201280F90D1DE003BB5A7 /* struct_c_rect-members.html */, + 24A201290F90D1DE003BB5A7 /* struct_c_rect.html */, + 24A2012A0F90D1DE003BB5A7 /* struct_e_rect-members.html */, + 24A2012B0F90D1DE003BB5A7 /* struct_e_rect.html */, + 24A2012C0F90D1DE003BB5A7 /* struct_vst_file_select-members.html */, + 24A2012D0F90D1DE003BB5A7 /* struct_vst_file_select.html */, + 24A2012E0F90D1DE003BB5A7 /* struct_vst_file_type-members.html */, + 24A2012F0F90D1DE003BB5A7 /* struct_vst_file_type.html */, + 24A201300F90D1DE003BB5A7 /* struct_vst_key_code-members.html */, + 24A201310F90D1DE003BB5A7 /* struct_vst_key_code.html */, + 24A201320F90D1DE003BB5A7 /* tab_b.gif */, + 24A201330F90D1DE003BB5A7 /* tab_l.gif */, + 24A201340F90D1DE003BB5A7 /* tab_r.gif */, + 24A201350F90D1DE003BB5A7 /* tabs.css */, + 24A201360F90D1DE003BB5A7 /* thanks.html */, + 24A201370F90D1DE003BB5A7 /* tree.html */, + 24A201380F90D1DE003BB5A7 /* vstcontrols_8cpp.html */, + 24A201390F90D1DE003BB5A7 /* vstcontrols_8h.html */, + 24A2013A0F90D1DE003BB5A7 /* vstgui_8cpp.html */, + 24A2013B0F90D1DE003BB5A7 /* vstgui_8h.html */, + 24A2013C0F90D1DE003BB5A7 /* vstkeycode_8h.html */, + 24A2013D0F90D1DE003BB5A7 /* vstoffline.html */, + 24A2013E0F90D1DE003BB5A7 /* vstparamstruct.html */, + 24A2013F0F90D1DE003BB5A7 /* vstplugscarbon_8h.html */, + 24A201400F90D1DE003BB5A7 /* vstplugsmac_8h.html */, + 24A201410F90D1DE003BB5A7 /* vstplugsmacho_8h.html */, + 24A201420F90D1DE003BB5A7 /* vstplugsquartz_8h.html */, + 24A201430F90D1DE003BB5A7 /* whatsnew.html */, + ); + name = html; + path = /vstsdk2.4/vstgui.sf/vstgui/Documentation/html; + sourceTree = ""; + }; + 24A203CE0F90D272003BB5A7 /* Products */ = { + isa = PBXGroup; + children = ( + 24A203D70F90D272003BB5A7 /* again.vst */, + 24A203D90F90D272003BB5A7 /* adelay.vst */, + 24A203DB0F90D272003BB5A7 /* vstxsynth.vst */, + 24A203DD0F90D272003BB5A7 /* surrounddelay.vst */, + 24A203DF0F90D272003BB5A7 /* minihost.app */, + ); + name = Products; + sourceTree = ""; + }; + 24A203E00F90D272003BB5A7 /* Products */ = { + isa = PBXGroup; + children = ( + 24A203E50F90D272003BB5A7 /* drawtest.component */, + 24A203E70F90D272003BB5A7 /* drawtest.vst */, + ); + name = Products; + sourceTree = ""; + }; + 24A203E80F90D272003BB5A7 /* Products */ = { + isa = PBXGroup; + children = ( + 24A203ED0F90D272003BB5A7 /* drawtest.component */, + 24A203EF0F90D272003BB5A7 /* drawtest.vst */, + ); + name = Products; + sourceTree = ""; + }; + 24A2FEBB0F90D1DB003BB5A7 /* vstsdk2.4 */ = { + isa = PBXGroup; + children = ( + 24A2FEBC0F90D1DC003BB5A7 /* artwork */, + 24A2FEC20F90D1DC003BB5A7 /* bin */, + 24A2FED80F90D1DC003BB5A7 /* doc */, + 24A2FF8E0F90D1DD003BB5A7 /* index.html */, + 24A2FF8F0F90D1DD003BB5A7 /* pluginterfaces */, + 24A2FF940F90D1DD003BB5A7 /* public.sdk */, + 24A2FFDE0F90D1DD003BB5A7 /* vstgui.sf */, + ); + name = vstsdk2.4; + path = /vstsdk2.4; + sourceTree = ""; + }; + 24A2FEBC0F90D1DC003BB5A7 /* artwork */ = { + isa = PBXGroup; + children = ( + 24A2FEBD0F90D1DC003BB5A7 /* Thumbs.db */, + 24A2FEBE0F90D1DC003BB5A7 /* VST_Logo_Usage_Guideline.pdf */, + 24A2FEBF0F90D1DC003BB5A7 /* VSTLogoAlpha.png */, + 24A2FEC00F90D1DC003BB5A7 /* VSTLogoBlack.jpg */, + 24A2FEC10F90D1DC003BB5A7 /* VSTLogoWhite.jpg */, + ); + name = artwork; + path = /vstsdk2.4/artwork; + sourceTree = ""; + }; + 24A2FEC20F90D1DC003BB5A7 /* bin */ = { + isa = PBXGroup; + children = ( + 24A2FEC30F90D1DC003BB5A7 /* mac */, + 24A2FED50F90D1DC003BB5A7 /* win */, + ); + name = bin; + path = /vstsdk2.4/bin; + sourceTree = ""; + }; + 24A2FEC30F90D1DC003BB5A7 /* mac */ = { + isa = PBXGroup; + children = ( + 24A2FEC40F90D1DC003BB5A7 /* VSTMonitor.vst */, + 24A2FED40F90D1DC003BB5A7 /* VSTParamTool.app */, + ); + name = mac; + path = /vstsdk2.4/bin/mac; + sourceTree = ""; + }; + 24A2FEC40F90D1DC003BB5A7 /* VSTMonitor.vst */ = { + isa = PBXGroup; + children = ( + 24A2FEC50F90D1DC003BB5A7 /* Contents */, + ); + name = VSTMonitor.vst; + path = /vstsdk2.4/bin/mac/VSTMonitor.vst; + sourceTree = ""; + }; + 24A2FEC50F90D1DC003BB5A7 /* Contents */ = { + isa = PBXGroup; + children = ( + 24A2FEC60F90D1DC003BB5A7 /* Info.plist */, + 24A2FEC70F90D1DC003BB5A7 /* MacOS */, + 24A2FEC90F90D1DC003BB5A7 /* PkgInfo */, + 24A2FECA0F90D1DC003BB5A7 /* Resources */, + ); + name = Contents; + path = /vstsdk2.4/bin/mac/VSTMonitor.vst/Contents; + sourceTree = ""; + }; + 24A2FEC70F90D1DC003BB5A7 /* MacOS */ = { + isa = PBXGroup; + children = ( + 24A2FEC80F90D1DC003BB5A7 /* VSTMonitor */, + ); + name = MacOS; + path = /vstsdk2.4/bin/mac/VSTMonitor.vst/Contents/MacOS; + sourceTree = ""; + }; + 24A2FECA0F90D1DC003BB5A7 /* Resources */ = { + isa = PBXGroup; + children = ( + 24A2FECB0F90D1DC003BB5A7 /* bmp50000.bmp */, + 24A2FECC0F90D1DC003BB5A7 /* bmp50001.bmp */, + 24A2FECD0F90D1DC003BB5A7 /* bmp50002.bmp */, + 24A2FECE0F90D1DC003BB5A7 /* bmp50003.bmp */, + 24A2FECF0F90D1DC003BB5A7 /* bmp50004.bmp */, + 24A2FED00F90D1DC003BB5A7 /* bmp50005.bmp */, + 24A2FED10F90D1DC003BB5A7 /* bmp50006.bmp */, + 24A2FED20F90D1DC003BB5A7 /* bmp50007.bmp */, + 24A2FED30F90D1DC003BB5A7 /* bmp50008.bmp */, + ); + name = Resources; + path = /vstsdk2.4/bin/mac/VSTMonitor.vst/Contents/Resources; + sourceTree = ""; + }; + 24A2FED50F90D1DC003BB5A7 /* win */ = { + isa = PBXGroup; + children = ( + 24A2FED60F90D1DC003BB5A7 /* vstmonitor.dll */, + 24A2FED70F90D1DC003BB5A7 /* vstparamtool.exe */, + ); + name = win; + path = /vstsdk2.4/bin/win; + sourceTree = ""; + }; + 24A2FED80F90D1DC003BB5A7 /* doc */ = { + isa = PBXGroup; + children = ( + 24A2FED90F90D1DC003BB5A7 /* gfx */, + 24A2FEDE0F90D1DC003BB5A7 /* html */, + 24A2FF8A0F90D1DD003BB5A7 /* sdk.menu.html */, + 24A2FF8B0F90D1DD003BB5A7 /* sdk.overview.html */, + 24A2FF8C0F90D1DD003BB5A7 /* sdkdoc.css */, + 24A2FF8D0F90D1DD003BB5A7 /* VST Licensing Agreement.rtf */, + ); + name = doc; + path = /vstsdk2.4/doc; + sourceTree = ""; + }; + 24A2FED90F90D1DC003BB5A7 /* gfx */ = { + isa = PBXGroup; + children = ( + 24A2FEDA0F90D1DC003BB5A7 /* folder.gif */, + 24A2FEDB0F90D1DC003BB5A7 /* mac.gif */, + 24A2FEDC0F90D1DC003BB5A7 /* vstpluglogo_small.jpg */, + 24A2FEDD0F90D1DC003BB5A7 /* win.gif */, + ); + name = gfx; + path = /vstsdk2.4/doc/gfx; + sourceTree = ""; + }; + 24A2FEDE0F90D1DC003BB5A7 /* html */ = { + isa = PBXGroup; + children = ( + 24A2FEDF0F90D1DC003BB5A7 /* aeffect_8h.html */, + 24A2FEE00F90D1DC003BB5A7 /* aeffectx_8h.html */, + 24A2FEE10F90D1DC003BB5A7 /* aeffeditor_8h.html */, + 24A2FEE20F90D1DC003BB5A7 /* annotated.html */, + 24A2FEE30F90D1DC003BB5A7 /* audioeffect_8cpp.html */, + 24A2FEE40F90D1DC003BB5A7 /* audioeffect_8h.html */, + 24A2FEE50F90D1DC003BB5A7 /* audioeffectx_8cpp.html */, + 24A2FEE60F90D1DC003BB5A7 /* audioeffectx_8h.html */, + 24A2FEE70F90D1DC003BB5A7 /* Blocksizechange.gif */, + 24A2FEE80F90D1DC003BB5A7 /* class_a_eff_editor-members.html */, + 24A2FEE90F90D1DC003BB5A7 /* class_a_eff_editor.html */, + 24A2FEEA0F90D1DC003BB5A7 /* class_audio_effect-members.html */, + 24A2FEEB0F90D1DC003BB5A7 /* class_audio_effect.html */, + 24A2FEEC0F90D1DC003BB5A7 /* class_audio_effect.png */, + 24A2FEED0F90D1DC003BB5A7 /* class_audio_effect_x-members.html */, + 24A2FEEE0F90D1DC003BB5A7 /* class_audio_effect_x.html */, + 24A2FEEF0F90D1DC003BB5A7 /* class_audio_effect_x.png */, + 24A2FEF00F90D1DC003BB5A7 /* ControlChanged.gif */, + 24A2FEF10F90D1DC003BB5A7 /* deprecated.html */, + 24A2FEF20F90D1DC003BB5A7 /* dir_2d3252dd12c84c66c1d25b26bb45a1f5.html */, + 24A2FEF30F90D1DC003BB5A7 /* dir_77c628dfee72e555f82d5ef53b733f38.html */, + 24A2FEF40F90D1DC003BB5A7 /* dir_f81105d3b854bea570aaf3bae5cb64c1.html */, + 24A2FEF50F90D1DC003BB5A7 /* dir_fa0454ab79b4262333bf837ea3d765e9.html */, + 24A2FEF60F90D1DC003BB5A7 /* dirs.html */, + 24A2FEF70F90D1DC003BB5A7 /* doc_8h.html */, + 24A2FEF80F90D1DC003BB5A7 /* doxygen.css */, + 24A2FEF90F90D1DC003BB5A7 /* doxygen.png */, + 24A2FEFA0F90D1DC003BB5A7 /* files.html */, + 24A2FEFB0F90D1DC003BB5A7 /* ftv2blank.png */, + 24A2FEFC0F90D1DC003BB5A7 /* ftv2doc.png */, + 24A2FEFD0F90D1DC003BB5A7 /* ftv2folderclosed.png */, + 24A2FEFE0F90D1DC003BB5A7 /* ftv2folderopen.png */, + 24A2FEFF0F90D1DC003BB5A7 /* ftv2lastnode.png */, + 24A2FF000F90D1DC003BB5A7 /* ftv2link.png */, + 24A2FF010F90D1DC003BB5A7 /* ftv2mlastnode.png */, + 24A2FF020F90D1DC003BB5A7 /* ftv2mnode.png */, + 24A2FF030F90D1DC003BB5A7 /* ftv2node.png */, + 24A2FF040F90D1DC003BB5A7 /* ftv2plastnode.png */, + 24A2FF050F90D1DC003BB5A7 /* ftv2pnode.png */, + 24A2FF060F90D1DC003BB5A7 /* ftv2vertline.png */, + 24A2FF070F90D1DC003BB5A7 /* functions.html */, + 24A2FF080F90D1DC003BB5A7 /* functions_0x62.html */, + 24A2FF090F90D1DC003BB5A7 /* functions_0x63.html */, + 24A2FF0A0F90D1DC003BB5A7 /* functions_0x64.html */, + 24A2FF0B0F90D1DC003BB5A7 /* functions_0x65.html */, + 24A2FF0C0F90D1DC003BB5A7 /* functions_0x66.html */, + 24A2FF0D0F90D1DC003BB5A7 /* functions_0x67.html */, + 24A2FF0E0F90D1DC003BB5A7 /* functions_0x68.html */, + 24A2FF0F0F90D1DC003BB5A7 /* functions_0x69.html */, + 24A2FF100F90D1DC003BB5A7 /* functions_0x6b.html */, + 24A2FF110F90D1DC003BB5A7 /* functions_0x6c.html */, + 24A2FF120F90D1DC003BB5A7 /* functions_0x6d.html */, + 24A2FF130F90D1DC003BB5A7 /* functions_0x6e.html */, + 24A2FF140F90D1DC003BB5A7 /* functions_0x6f.html */, + 24A2FF150F90D1DC003BB5A7 /* functions_0x70.html */, + 24A2FF160F90D1DC003BB5A7 /* functions_0x72.html */, + 24A2FF170F90D1DC003BB5A7 /* functions_0x73.html */, + 24A2FF180F90D1DC003BB5A7 /* functions_0x74.html */, + 24A2FF190F90D1DC003BB5A7 /* functions_0x75.html */, + 24A2FF1A0F90D1DC003BB5A7 /* functions_0x76.html */, + 24A2FF1B0F90D1DC003BB5A7 /* functions_0x77.html */, + 24A2FF1C0F90D1DC003BB5A7 /* functions_0x78.html */, + 24A2FF1D0F90D1DC003BB5A7 /* functions_0x79.html */, + 24A2FF1E0F90D1DC003BB5A7 /* functions_0x7e.html */, + 24A2FF1F0F90D1DC003BB5A7 /* functions_func.html */, + 24A2FF200F90D1DC003BB5A7 /* functions_vars.html */, + 24A2FF210F90D1DC003BB5A7 /* globals.html */, + 24A2FF220F90D1DC003BB5A7 /* globals_0x62.html */, + 24A2FF230F90D1DC003BB5A7 /* globals_0x63.html */, + 24A2FF240F90D1DC003BB5A7 /* globals_0x64.html */, + 24A2FF250F90D1DC003BB5A7 /* globals_0x65.html */, + 24A2FF260F90D1DC003BB5A7 /* globals_0x66.html */, + 24A2FF270F90D1DC003BB5A7 /* globals_0x6b.html */, + 24A2FF280F90D1DC003BB5A7 /* globals_0x6d.html */, + 24A2FF290F90D1DC003BB5A7 /* globals_0x74.html */, + 24A2FF2A0F90D1DC003BB5A7 /* globals_0x76.html */, + 24A2FF2B0F90D1DC003BB5A7 /* globals_defs.html */, + 24A2FF2C0F90D1DC003BB5A7 /* globals_enum.html */, + 24A2FF2D0F90D1DC003BB5A7 /* globals_eval.html */, + 24A2FF2E0F90D1DC003BB5A7 /* globals_eval_0x65.html */, + 24A2FF2F0F90D1DC003BB5A7 /* globals_eval_0x6b.html */, + 24A2FF300F90D1DC003BB5A7 /* globals_eval_0x6d.html */, + 24A2FF310F90D1DC003BB5A7 /* globals_eval_0x76.html */, + 24A2FF320F90D1DC003BB5A7 /* globals_func.html */, + 24A2FF330F90D1DC003BB5A7 /* globals_type.html */, + 24A2FF340F90D1DC003BB5A7 /* globals_vars.html */, + 24A2FF350F90D1DC003BB5A7 /* hierarchy.html */, + 24A2FF360F90D1DC003BB5A7 /* history.html */, + 24A2FF370F90D1DC003BB5A7 /* index.html */, + 24A2FF380F90D1DC003BB5A7 /* Initialisation.gif */, + 24A2FF390F90D1DC003BB5A7 /* intro.html */, + 24A2FF3A0F90D1DC003BB5A7 /* IOchange.gif */, + 24A2FF3B0F90D1DC003BB5A7 /* license.html */, + 24A2FF3C0F90D1DC003BB5A7 /* maceditor.html */, + 24A2FF3D0F90D1DC003BB5A7 /* main.html */, + 24A2FF3E0F90D1DC003BB5A7 /* namespace_host_can_dos.html */, + 24A2FF3F0F90D1DC003BB5A7 /* namespace_plug_can_dos.html */, + 24A2FF400F90D1DC003BB5A7 /* namespacemembers.html */, + 24A2FF410F90D1DC003BB5A7 /* namespacemembers_vars.html */, + 24A2FF420F90D1DC003BB5A7 /* namespaces.html */, + 24A2FF430F90D1DC003BB5A7 /* Offlineprocessing.gif */, + 24A2FF440F90D1DC003BB5A7 /* others.html */, + 24A2FF450F90D1DC003BB5A7 /* pages.html */, + 24A2FF460F90D1DC003BB5A7 /* Sampleratechange.gif */, + 24A2FF470F90D1DC003BB5A7 /* sequences.html */, + 24A2FF480F90D1DC003BB5A7 /* SpeakerarrangementnegotiationforVSTfx.gif */, + 24A2FF490F90D1DC003BB5A7 /* struct_a_effect-members.html */, + 24A2FF4A0F90D1DC003BB5A7 /* struct_a_effect.html */, + 24A2FF4B0F90D1DC003BB5A7 /* struct_e_rect-members.html */, + 24A2FF4C0F90D1DC003BB5A7 /* struct_e_rect.html */, + 24A2FF4D0F90D1DC003BB5A7 /* struct_midi_key_name-members.html */, + 24A2FF4E0F90D1DC003BB5A7 /* struct_midi_key_name.html */, + 24A2FF4F0F90D1DC003BB5A7 /* struct_midi_program_category-members.html */, + 24A2FF500F90D1DC003BB5A7 /* struct_midi_program_category.html */, + 24A2FF510F90D1DC003BB5A7 /* struct_midi_program_name-members.html */, + 24A2FF520F90D1DC003BB5A7 /* struct_midi_program_name.html */, + 24A2FF530F90D1DC003BB5A7 /* struct_vst_audio_file-members.html */, + 24A2FF540F90D1DC003BB5A7 /* struct_vst_audio_file.html */, + 24A2FF550F90D1DC003BB5A7 /* struct_vst_audio_file_marker-members.html */, + 24A2FF560F90D1DC003BB5A7 /* struct_vst_audio_file_marker.html */, + 24A2FF570F90D1DC003BB5A7 /* struct_vst_event-members.html */, + 24A2FF580F90D1DC003BB5A7 /* struct_vst_event.html */, + 24A2FF590F90D1DD003BB5A7 /* struct_vst_events-members.html */, + 24A2FF5A0F90D1DD003BB5A7 /* struct_vst_events.html */, + 24A2FF5B0F90D1DD003BB5A7 /* struct_vst_file_select-members.html */, + 24A2FF5C0F90D1DD003BB5A7 /* struct_vst_file_select.html */, + 24A2FF5D0F90D1DD003BB5A7 /* struct_vst_file_type-members.html */, + 24A2FF5E0F90D1DD003BB5A7 /* struct_vst_file_type.html */, + 24A2FF5F0F90D1DD003BB5A7 /* struct_vst_key_code-members.html */, + 24A2FF600F90D1DD003BB5A7 /* struct_vst_key_code.html */, + 24A2FF610F90D1DD003BB5A7 /* struct_vst_midi_event-members.html */, + 24A2FF620F90D1DD003BB5A7 /* struct_vst_midi_event.html */, + 24A2FF630F90D1DD003BB5A7 /* struct_vst_midi_sysex_event-members.html */, + 24A2FF640F90D1DD003BB5A7 /* struct_vst_midi_sysex_event.html */, + 24A2FF650F90D1DD003BB5A7 /* struct_vst_offline_task-members.html */, + 24A2FF660F90D1DD003BB5A7 /* struct_vst_offline_task.html */, + 24A2FF670F90D1DD003BB5A7 /* struct_vst_parameter_properties-members.html */, + 24A2FF680F90D1DD003BB5A7 /* struct_vst_parameter_properties.html */, + 24A2FF690F90D1DD003BB5A7 /* struct_vst_patch_chunk_info-members.html */, + 24A2FF6A0F90D1DD003BB5A7 /* struct_vst_patch_chunk_info.html */, + 24A2FF6B0F90D1DD003BB5A7 /* struct_vst_pin_properties-members.html */, + 24A2FF6C0F90D1DD003BB5A7 /* struct_vst_pin_properties.html */, + 24A2FF6D0F90D1DD003BB5A7 /* struct_vst_speaker_arrangement-members.html */, + 24A2FF6E0F90D1DD003BB5A7 /* struct_vst_speaker_arrangement.html */, + 24A2FF6F0F90D1DD003BB5A7 /* struct_vst_speaker_properties-members.html */, + 24A2FF700F90D1DD003BB5A7 /* struct_vst_speaker_properties.html */, + 24A2FF710F90D1DD003BB5A7 /* struct_vst_time_info-members.html */, + 24A2FF720F90D1DD003BB5A7 /* struct_vst_time_info.html */, + 24A2FF730F90D1DD003BB5A7 /* struct_vst_variable_io-members.html */, + 24A2FF740F90D1DD003BB5A7 /* struct_vst_variable_io.html */, + 24A2FF750F90D1DD003BB5A7 /* struct_vst_window-members.html */, + 24A2FF760F90D1DD003BB5A7 /* struct_vst_window.html */, + 24A2FF770F90D1DD003BB5A7 /* structfx_bank-members.html */, + 24A2FF780F90D1DD003BB5A7 /* structfx_bank.html */, + 24A2FF790F90D1DD003BB5A7 /* structfx_program-members.html */, + 24A2FF7A0F90D1DD003BB5A7 /* structfx_program.html */, + 24A2FF7B0F90D1DD003BB5A7 /* tab_b.gif */, + 24A2FF7C0F90D1DD003BB5A7 /* tab_l.gif */, + 24A2FF7D0F90D1DD003BB5A7 /* tab_r.gif */, + 24A2FF7E0F90D1DD003BB5A7 /* tabs.css */, + 24A2FF7F0F90D1DD003BB5A7 /* Termination.gif */, + 24A2FF800F90D1DD003BB5A7 /* thanks.html */, + 24A2FF810F90D1DD003BB5A7 /* tree.html */, + 24A2FF820F90D1DD003BB5A7 /* TurnOff.gif */, + 24A2FF830F90D1DD003BB5A7 /* TurnOn.gif */, + 24A2FF840F90D1DD003BB5A7 /* vstfxstore_8h.html */, + 24A2FF850F90D1DD003BB5A7 /* vstoffline.html */, + 24A2FF860F90D1DD003BB5A7 /* vstparamstruct.html */, + 24A2FF870F90D1DD003BB5A7 /* vstpluglogo.jpg */, + 24A2FF880F90D1DD003BB5A7 /* vstplugmain_8cpp.html */, + 24A2FF890F90D1DD003BB5A7 /* whatsnew.html */, + ); + name = html; + path = /vstsdk2.4/doc/html; + sourceTree = ""; + }; + 24A2FF8F0F90D1DD003BB5A7 /* pluginterfaces */ = { + isa = PBXGroup; + children = ( + 24A2FF900F90D1DD003BB5A7 /* vst2.x */, + ); + name = pluginterfaces; + path = /vstsdk2.4/pluginterfaces; + sourceTree = ""; + }; + 24A2FF900F90D1DD003BB5A7 /* vst2.x */ = { + isa = PBXGroup; + children = ( + 24A2FF910F90D1DD003BB5A7 /* aeffect.h */, + 24A2FF920F90D1DD003BB5A7 /* aeffectx.h */, + 24A2FF930F90D1DD003BB5A7 /* vstfxstore.h */, + ); + name = vst2.x; + path = /vstsdk2.4/pluginterfaces/vst2.x; + sourceTree = ""; + }; + 24A2FF940F90D1DD003BB5A7 /* public.sdk */ = { + isa = PBXGroup; + children = ( + 24A2FF950F90D1DD003BB5A7 /* samples */, + 24A2FFD60F90D1DD003BB5A7 /* source */, + ); + name = public.sdk; + path = /vstsdk2.4/public.sdk; + sourceTree = ""; + }; + 24A2FF950F90D1DD003BB5A7 /* samples */ = { + isa = PBXGroup; + children = ( + 24A2FF960F90D1DD003BB5A7 /* vst2.x */, + ); + name = samples; + path = /vstsdk2.4/public.sdk/samples; + sourceTree = ""; + }; + 24A2FF960F90D1DD003BB5A7 /* vst2.x */ = { + isa = PBXGroup; + children = ( + 24A2FF970F90D1DD003BB5A7 /* adelay */, + 24A2FFA80F90D1DD003BB5A7 /* again */, + 24A2FFAE0F90D1DD003BB5A7 /* mac */, + 24A2FFB40F90D1DD003BB5A7 /* minihost */, + 24A2FFBA0F90D1DD003BB5A7 /* vstxsynth */, + 24A2FFC50F90D1DD003BB5A7 /* win */, + 24A2FFC80F90D1DD003BB5A7 /* win.vc2003 */, + 24A2FFCF0F90D1DD003BB5A7 /* win.vc6 */, + ); + name = vst2.x; + path = /vstsdk2.4/public.sdk/samples/vst2.x; + sourceTree = ""; + }; + 24A2FF970F90D1DD003BB5A7 /* adelay */ = { + isa = PBXGroup; + children = ( + 24A2FF980F90D1DD003BB5A7 /* adelay.cpp */, + 24A2FF990F90D1DD003BB5A7 /* adelay.h */, + 24A2FF9A0F90D1DD003BB5A7 /* adelaymain.cpp */, + 24A2FF9B0F90D1DD003BB5A7 /* editor */, + 24A2FFA30F90D1DD003BB5A7 /* surrounddelay.cpp */, + 24A2FFA40F90D1DD003BB5A7 /* surrounddelay.h */, + 24A2FFA50F90D1DD003BB5A7 /* win */, + ); + name = adelay; + path = /vstsdk2.4/public.sdk/samples/vst2.x/adelay; + sourceTree = ""; + }; + 24A2FF9B0F90D1DD003BB5A7 /* editor */ = { + isa = PBXGroup; + children = ( + 24A2FF9C0F90D1DD003BB5A7 /* resources */, + 24A2FFA10F90D1DD003BB5A7 /* sdeditor.cpp */, + 24A2FFA20F90D1DD003BB5A7 /* sdeditor.h */, + ); + name = editor; + path = /vstsdk2.4/public.sdk/samples/vst2.x/adelay/editor; + sourceTree = ""; + }; + 24A2FF9C0F90D1DD003BB5A7 /* resources */ = { + isa = PBXGroup; + children = ( + 24A2FF9D0F90D1DD003BB5A7 /* bmp00128.bmp */, + 24A2FF9E0F90D1DD003BB5A7 /* bmp00129.bmp */, + 24A2FF9F0F90D1DD003BB5A7 /* bmp00130.bmp */, + 24A2FFA00F90D1DD003BB5A7 /* surrounddelay.rc */, + ); + name = resources; + path = /vstsdk2.4/public.sdk/samples/vst2.x/adelay/editor/resources; + sourceTree = ""; + }; + 24A2FFA50F90D1DD003BB5A7 /* win */ = { + isa = PBXGroup; + children = ( + 24A2FFA60F90D1DD003BB5A7 /* adelay.vcproj */, + 24A2FFA70F90D1DD003BB5A7 /* surrounddelay.vcproj */, + ); + name = win; + path = /vstsdk2.4/public.sdk/samples/vst2.x/adelay/win; + sourceTree = ""; + }; + 24A2FFA80F90D1DD003BB5A7 /* again */ = { + isa = PBXGroup; + children = ( + 24A2FFA90F90D1DD003BB5A7 /* source */, + 24A2FFAC0F90D1DD003BB5A7 /* win */, + ); + name = again; + path = /vstsdk2.4/public.sdk/samples/vst2.x/again; + sourceTree = ""; + }; + 24A2FFA90F90D1DD003BB5A7 /* source */ = { + isa = PBXGroup; + children = ( + 24A2FFAA0F90D1DD003BB5A7 /* again.cpp */, + 24A2FFAB0F90D1DD003BB5A7 /* again.h */, + ); + name = source; + path = /vstsdk2.4/public.sdk/samples/vst2.x/again/source; + sourceTree = ""; + }; + 24A2FFAC0F90D1DD003BB5A7 /* win */ = { + isa = PBXGroup; + children = ( + 24A2FFAD0F90D1DD003BB5A7 /* again.vcproj */, + ); + name = win; + path = /vstsdk2.4/public.sdk/samples/vst2.x/again/win; + sourceTree = ""; + }; + 24A2FFAE0F90D1DD003BB5A7 /* mac */ = { + isa = PBXGroup; + children = ( + 24A2FFAF0F90D1DD003BB5A7 /* minihost-Info.plist */, + 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */, + 24A2FFB30F90D1DD003BB5A7 /* vst2.4Info.plist */, + ); + name = mac; + path = /vstsdk2.4/public.sdk/samples/vst2.x/mac; + sourceTree = ""; + }; + 24A2FFB40F90D1DD003BB5A7 /* minihost */ = { + isa = PBXGroup; + children = ( + 24A2FFB50F90D1DD003BB5A7 /* source */, + 24A2FFB80F90D1DD003BB5A7 /* win */, + ); + name = minihost; + path = /vstsdk2.4/public.sdk/samples/vst2.x/minihost; + sourceTree = ""; + }; + 24A2FFB50F90D1DD003BB5A7 /* source */ = { + isa = PBXGroup; + children = ( + 24A2FFB60F90D1DD003BB5A7 /* minieditor.cpp */, + 24A2FFB70F90D1DD003BB5A7 /* minihost.cpp */, + ); + name = source; + path = /vstsdk2.4/public.sdk/samples/vst2.x/minihost/source; + sourceTree = ""; + }; + 24A2FFB80F90D1DD003BB5A7 /* win */ = { + isa = PBXGroup; + children = ( + 24A2FFB90F90D1DD003BB5A7 /* minihost.vcproj */, + ); + name = win; + path = /vstsdk2.4/public.sdk/samples/vst2.x/minihost/win; + sourceTree = ""; + }; + 24A2FFBA0F90D1DD003BB5A7 /* vstxsynth */ = { + isa = PBXGroup; + children = ( + 24A2FFBB0F90D1DD003BB5A7 /* resource */, + 24A2FFBE0F90D1DD003BB5A7 /* source */, + 24A2FFC30F90D1DD003BB5A7 /* win */, + ); + name = vstxsynth; + path = /vstsdk2.4/public.sdk/samples/vst2.x/vstxsynth; + sourceTree = ""; + }; + 24A2FFBB0F90D1DD003BB5A7 /* resource */ = { + isa = PBXGroup; + children = ( + 24A2FFBC0F90D1DD003BB5A7 /* vstxsynth.rc */, + 24A2FFBD0F90D1DD003BB5A7 /* vstxsynth.vstxml */, + ); + name = resource; + path = /vstsdk2.4/public.sdk/samples/vst2.x/vstxsynth/resource; + sourceTree = ""; + }; + 24A2FFBE0F90D1DD003BB5A7 /* source */ = { + isa = PBXGroup; + children = ( + 24A2FFBF0F90D1DD003BB5A7 /* gmnames.h */, + 24A2FFC00F90D1DD003BB5A7 /* vstxsynth.cpp */, + 24A2FFC10F90D1DD003BB5A7 /* vstxsynth.h */, + 24A2FFC20F90D1DD003BB5A7 /* vstxsynthproc.cpp */, + ); + name = source; + path = /vstsdk2.4/public.sdk/samples/vst2.x/vstxsynth/source; + sourceTree = ""; + }; + 24A2FFC30F90D1DD003BB5A7 /* win */ = { + isa = PBXGroup; + children = ( + 24A2FFC40F90D1DD003BB5A7 /* vstxsynth.vcproj */, + ); + name = win; + path = /vstsdk2.4/public.sdk/samples/vst2.x/vstxsynth/win; + sourceTree = ""; + }; + 24A2FFC50F90D1DD003BB5A7 /* win */ = { + isa = PBXGroup; + children = ( + 24A2FFC60F90D1DD003BB5A7 /* samples.sln */, + 24A2FFC70F90D1DD003BB5A7 /* vstplug.def */, + ); + name = win; + path = /vstsdk2.4/public.sdk/samples/vst2.x/win; + sourceTree = ""; + }; + 24A2FFC80F90D1DD003BB5A7 /* win.vc2003 */ = { + isa = PBXGroup; + children = ( + 24A2FFC90F90D1DD003BB5A7 /* adelay.vcproj */, + 24A2FFCA0F90D1DD003BB5A7 /* again.vcproj */, + 24A2FFCB0F90D1DD003BB5A7 /* minihost.vcproj */, + 24A2FFCC0F90D1DD003BB5A7 /* samples.sln */, + 24A2FFCD0F90D1DD003BB5A7 /* surrounddelay.vcproj */, + 24A2FFCE0F90D1DD003BB5A7 /* vstxsynth.vcproj */, + ); + name = win.vc2003; + path = /vstsdk2.4/public.sdk/samples/vst2.x/win.vc2003; + sourceTree = ""; + }; + 24A2FFCF0F90D1DD003BB5A7 /* win.vc6 */ = { + isa = PBXGroup; + children = ( + 24A2FFD00F90D1DD003BB5A7 /* adelay.dsp */, + 24A2FFD10F90D1DD003BB5A7 /* again.dsp */, + 24A2FFD20F90D1DD003BB5A7 /* minihost.dsp */, + 24A2FFD30F90D1DD003BB5A7 /* samples.dsw */, + 24A2FFD40F90D1DD003BB5A7 /* surrounddelay.dsp */, + 24A2FFD50F90D1DD003BB5A7 /* vstxsynth.dsp */, + ); + name = win.vc6; + path = /vstsdk2.4/public.sdk/samples/vst2.x/win.vc6; + sourceTree = ""; + }; + 24A2FFD60F90D1DD003BB5A7 /* source */ = { + isa = PBXGroup; + children = ( + 24A2FFD70F90D1DD003BB5A7 /* vst2.x */, + ); + name = source; + path = /vstsdk2.4/public.sdk/source; + sourceTree = ""; + }; + 24A2FFD70F90D1DD003BB5A7 /* vst2.x */ = { + isa = PBXGroup; + children = ( + 24A2FFD80F90D1DD003BB5A7 /* aeffeditor.h */, + 24A2FFD90F90D1DD003BB5A7 /* audioeffect.cpp */, + 24A2FFDA0F90D1DD003BB5A7 /* audioeffect.h */, + 24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */, + 24A2FFDC0F90D1DD003BB5A7 /* audioeffectx.h */, + 24A2FFDD0F90D1DD003BB5A7 /* vstplugmain.cpp */, + ); + name = vst2.x; + path = /vstsdk2.4/public.sdk/source/vst2.x; + sourceTree = ""; + }; + 24A2FFDE0F90D1DD003BB5A7 /* vstgui.sf */ = { + isa = PBXGroup; + children = ( + 24A2FFDF0F90D1DD003BB5A7 /* drawtest */, + 24A200160F90D1DD003BB5A7 /* vstgui */, + ); + name = vstgui.sf; + path = /vstsdk2.4/vstgui.sf; + sourceTree = ""; + }; + 24A2FFDF0F90D1DD003BB5A7 /* drawtest */ = { + isa = PBXGroup; + children = ( + 24A2FFE00F90D1DD003BB5A7 /* mac */, + 24A2FFEE0F90D1DD003BB5A7 /* resources */, + 24A200030F90D1DD003BB5A7 /* source */, + 24A2000F0F90D1DD003BB5A7 /* win */, + 24A200130F90D1DD003BB5A7 /* win.vc6 */, + ); + name = drawtest; + path = /vstsdk2.4/vstgui.sf/drawtest; + sourceTree = ""; + }; + 24A2FFE00F90D1DD003BB5A7 /* mac */ = { + isa = PBXGroup; + children = ( + 24A2FFE10F90D1DD003BB5A7 /* audiounit.exp */, + 24A2FFE20F90D1DD003BB5A7 /* cw_vst_prefix.pch++ */, + 24A2FFE30F90D1DD003BB5A7 /* drawtest.cw9prj */, + 24A2FFE40F90D1DD003BB5A7 /* drawtest.plc */, + 24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */, + 24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */, + 24A2FFEB0F90D1DD003BB5A7 /* Info.plist */, + 24A2FFEC0F90D1DD003BB5A7 /* xcode_au_prefix.h */, + 24A2FFED0F90D1DD003BB5A7 /* xcode_vst_prefix.h */, + ); + name = mac; + path = /vstsdk2.4/vstgui.sf/drawtest/mac; + sourceTree = ""; + }; + 24A2FFEE0F90D1DD003BB5A7 /* resources */ = { + isa = PBXGroup; + children = ( + 24A2FFEF0F90D1DD003BB5A7 /* audiounit.r */, + 24A2FFF00F90D1DD003BB5A7 /* bmp00001.png */, + 24A2FFF10F90D1DD003BB5A7 /* bmp00100.png */, + 24A2FFF20F90D1DD003BB5A7 /* bmp01000.png */, + 24A2FFF30F90D1DD003BB5A7 /* bmp10001.bmp */, + 24A2FFF40F90D1DD003BB5A7 /* bmp10002.bmp */, + 24A2FFF50F90D1DD003BB5A7 /* bmp10003.bmp */, + 24A2FFF60F90D1DD003BB5A7 /* bmp10004.bmp */, + 24A2FFF70F90D1DD003BB5A7 /* bmp10005.bmp */, + 24A2FFF80F90D1DD003BB5A7 /* bmp10006.bmp */, + 24A2FFF90F90D1DD003BB5A7 /* bmp10007.bmp */, + 24A2FFFA0F90D1DD003BB5A7 /* bmp10008.bmp */, + 24A2FFFB0F90D1DD003BB5A7 /* bmp10009.bmp */, + 24A2FFFC0F90D1DD003BB5A7 /* bmp10010.bmp */, + 24A2FFFD0F90D1DD003BB5A7 /* bmp10011.bmp */, + 24A2FFFE0F90D1DD003BB5A7 /* bmp10012.bmp */, + 24A2FFFF0F90D1DD003BB5A7 /* bmp10013.bmp */, + 24A200000F90D1DD003BB5A7 /* bmp10014.bmp */, + 24A200010F90D1DD003BB5A7 /* bmp10015.bmp */, + 24A200020F90D1DD003BB5A7 /* bmp10016.bmp */, + ); + name = resources; + path = /vstsdk2.4/vstgui.sf/drawtest/resources; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXHeadersBuildPhase section */ + 8D01CCC70486CAD60068D4B7 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 245463B90991757100464AD3 /* PocketVerbs.h in Headers */, + 24D8287F09A9164A0093AEF8 /* xcode_vst_prefix.h in Headers */, + 24A202190F90D1DE003BB5A7 /* aeffect.h in Headers */, + 24A2021A0F90D1DE003BB5A7 /* aeffectx.h in Headers */, + 24A2021B0F90D1DE003BB5A7 /* vstfxstore.h in Headers */, + 24A2021D0F90D1DE003BB5A7 /* adelay.h in Headers */, + 24A202240F90D1DE003BB5A7 /* sdeditor.h in Headers */, + 24A202260F90D1DE003BB5A7 /* surrounddelay.h in Headers */, + 24A2022A0F90D1DE003BB5A7 /* again.h in Headers */, + 24A202330F90D1DE003BB5A7 /* gmnames.h in Headers */, + 24A202350F90D1DE003BB5A7 /* vstxsynth.h in Headers */, + 24A202460F90D1DE003BB5A7 /* aeffeditor.h in Headers */, + 24A202480F90D1DE003BB5A7 /* audioeffect.h in Headers */, + 24A2024A0F90D1DE003BB5A7 /* audioeffectx.h in Headers */, + 24A2024D0F90D1DE003BB5A7 /* cw_vst_prefix.pch++ in Headers */, + 24A202510F90D1DE003BB5A7 /* xcode_au_prefix.h in Headers */, + 24A202520F90D1DE003BB5A7 /* xcode_vst_prefix.h in Headers */, + 24A202680F90D1DE003BB5A7 /* controlsgui.h in Headers */, + 24A2026A0F90D1DE003BB5A7 /* pdrawtesteditor.h in Headers */, + 24A2026C0F90D1DE003BB5A7 /* pdrawtesteffect.h in Headers */, + 24A2026F0F90D1DE003BB5A7 /* pdrawtestview.h in Headers */, + 24A202710F90D1DE003BB5A7 /* pprimitivesviews.h in Headers */, + 24A202780F90D1DE003BB5A7 /* aeffguieditor.h in Headers */, + 24A2027A0F90D1DE003BB5A7 /* cfileselector.h in Headers */, + 24A2027D0F90D1DE003BB5A7 /* cscrollview.h in Headers */, + 24A2027F0F90D1DE003BB5A7 /* ctabview.h in Headers */, + 24A203A50F90D1DE003BB5A7 /* plugguieditor.h in Headers */, + 24A203A70F90D1DE003BB5A7 /* vstcontrols.h in Headers */, + 24A203A90F90D1DE003BB5A7 /* vstgui.h in Headers */, + 24A203AA0F90D1DE003BB5A7 /* vstkeycode.h in Headers */, + 24A203AB0F90D1DE003BB5A7 /* vstplugscarbon.h in Headers */, + 24A203AC0F90D1DE003BB5A7 /* vstplugsmac.h in Headers */, + 24A203AD0F90D1DE003BB5A7 /* vstplugsmacho.h in Headers */, + 24A203AE0F90D1DE003BB5A7 /* vstplugsquartz.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + +/* Begin PBXNativeTarget section */ + 8D01CCC60486CAD60068D4B7 /* PocketVerbs */ = { + isa = PBXNativeTarget; + buildConfigurationList = 24BEAAED08919AE700E695F9 /* Build configuration list for PBXNativeTarget "PocketVerbs" */; + buildPhases = ( + 8D01CCC70486CAD60068D4B7 /* Headers */, + 8D01CCC90486CAD60068D4B7 /* Resources */, + 8D01CCCB0486CAD60068D4B7 /* Sources */, + 8D01CCCF0486CAD60068D4B7 /* Rez */, + 24CFB70807E7A07C0081BD57 /* Copy PkgInfo */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = PocketVerbs; + productInstallPath = "$(HOME)/Library/Bundles"; + productName = "FM-Chopper"; + productReference = 2407DE920899296600EB68BF /* PocketVerbs.vst */; + productType = "com.apple.product-type.bundle"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 089C1669FE841209C02AAC07 /* Project object */ = { + isa = PBXProject; + buildConfigurationList = 24BEAAF108919AE700E695F9 /* Build configuration list for PBXProject "PocketVerbs" */; + compatibilityVersion = "Xcode 2.4"; + developmentRegion = English; + hasScannedForEncodings = 1; + knownRegions = ( + English, + Japanese, + French, + German, + ); + mainGroup = 089C166AFE841209C02AAC07 /* FM-Chopper */; + projectDirPath = ""; + projectReferences = ( + { + ProductGroup = 24A203E00F90D272003BB5A7 /* Products */; + ProjectRef = 24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */; + }, + { + ProductGroup = 24A203E80F90D272003BB5A7 /* Products */; + ProjectRef = 24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */; + }, + { + ProductGroup = 24A203CE0F90D272003BB5A7 /* Products */; + ProjectRef = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */; + }, + ); + projectRoot = ""; + targets = ( + 8D01CCC60486CAD60068D4B7 /* PocketVerbs */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXReferenceProxy section */ + 24A203D70F90D272003BB5A7 /* again.vst */ = { + isa = PBXReferenceProxy; + fileType = wrapper.cfbundle; + path = again.vst; + remoteRef = 24A203D60F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 24A203D90F90D272003BB5A7 /* adelay.vst */ = { + isa = PBXReferenceProxy; + fileType = wrapper.cfbundle; + path = adelay.vst; + remoteRef = 24A203D80F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 24A203DB0F90D272003BB5A7 /* vstxsynth.vst */ = { + isa = PBXReferenceProxy; + fileType = wrapper.cfbundle; + path = vstxsynth.vst; + remoteRef = 24A203DA0F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 24A203DD0F90D272003BB5A7 /* surrounddelay.vst */ = { + isa = PBXReferenceProxy; + fileType = wrapper.cfbundle; + path = surrounddelay.vst; + remoteRef = 24A203DC0F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 24A203DF0F90D272003BB5A7 /* minihost.app */ = { + isa = PBXReferenceProxy; + fileType = wrapper.application; + path = minihost.app; + remoteRef = 24A203DE0F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 24A203E50F90D272003BB5A7 /* drawtest.component */ = { + isa = PBXReferenceProxy; + fileType = wrapper.cfbundle; + path = drawtest.component; + remoteRef = 24A203E40F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 24A203E70F90D272003BB5A7 /* drawtest.vst */ = { + isa = PBXReferenceProxy; + fileType = wrapper.cfbundle; + path = drawtest.vst; + remoteRef = 24A203E60F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 24A203ED0F90D272003BB5A7 /* drawtest.component */ = { + isa = PBXReferenceProxy; + fileType = wrapper.cfbundle; + path = drawtest.component; + remoteRef = 24A203EC0F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; + 24A203EF0F90D272003BB5A7 /* drawtest.vst */ = { + isa = PBXReferenceProxy; + fileType = wrapper.cfbundle; + path = drawtest.vst; + remoteRef = 24A203EE0F90D272003BB5A7 /* PBXContainerItemProxy */; + sourceTree = BUILT_PRODUCTS_DIR; + }; +/* End PBXReferenceProxy section */ + +/* Begin PBXResourcesBuildPhase section */ + 8D01CCC90486CAD60068D4B7 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 24CFB70407E7A0220081BD57 /* PkgInfo in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXRezBuildPhase section */ + 8D01CCCF0486CAD60068D4B7 /* Rez */ = { + isa = PBXRezBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXRezBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 24CFB70807E7A07C0081BD57 /* Copy PkgInfo */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "Copy PkgInfo"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/bash; + shellScript = "cp mac/PkgInfo \"$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.vst/Contents/\""; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 8D01CCCB0486CAD60068D4B7 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 2407DEB9089929BA00EB68BF /* PocketVerbs.cpp in Sources */, + 24D8287009A914000093AEF8 /* PocketVerbsProc.cpp in Sources */, + 24A203CB0F90D251003BB5A7 /* audioeffect.cpp in Sources */, + 24A203CC0F90D251003BB5A7 /* audioeffectx.cpp in Sources */, + 24A203CD0F90D251003BB5A7 /* vstplugmain.cpp in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin XCBuildConfiguration section */ + 24BEAAEE08919AE700E695F9 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + COPY_PHASE_STRIP = NO; + FRAMEWORK_SEARCH_PATHS = ""; + GCC_DYNAMIC_NO_PIC = NO; + GCC_ENABLE_FIX_AND_CONTINUE = YES; + GCC_ENABLE_TRIGRAPHS = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = YES; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = ""; + GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO; + GCC_WARN_FOUR_CHARACTER_CONSTANTS = NO; + GCC_WARN_UNKNOWN_PRAGMAS = NO; + HEADER_SEARCH_PATHS = "/vstsdk2.4/**"; + INFOPLIST_FILE = ./mac/Info.plist; + LIBRARY_SEARCH_PATHS = ""; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = Gain; + SECTORDER_FLAGS = ""; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + WRAPPER_EXTENSION = vst; + }; + name = Debug; + }; + 24BEAAEF08919AE700E695F9 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = ( + ppc, + i386, + x86_64, + ); + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + FRAMEWORK_SEARCH_PATHS = ""; + GCC_C_LANGUAGE_STANDARD = c99; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + GCC_ENABLE_TRIGRAPHS = NO; + GCC_GENERATE_DEBUGGING_SYMBOLS = NO; + GCC_MODEL_TUNING = G4; + GCC_OPTIMIZATION_LEVEL = s; + GCC_PRECOMPILE_PREFIX_HEADER = YES; + GCC_PREFIX_HEADER = ""; + GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO; + GCC_WARN_FOUR_CHARACTER_CONSTANTS = NO; + GCC_WARN_UNKNOWN_PRAGMAS = NO; + HEADER_SEARCH_PATHS = "/vstsdk2.4/**"; + INFOPLIST_FILE = ./mac/Info.plist; + LIBRARY_SEARCH_PATHS = ""; + MACOSX_DEPLOYMENT_TARGET = 10.4; + OTHER_CFLAGS = ""; + OTHER_LDFLAGS = ""; + OTHER_REZFLAGS = ""; + PRODUCT_NAME = PocketVerbs; + SDKROOT = /Developer/SDKs/MacOSX10.5.sdk; + SECTORDER_FLAGS = ""; + SKIP_INSTALL = NO; + STRIP_INSTALLED_PRODUCT = YES; + STRIP_STYLE = all; + WARNING_CFLAGS = ( + "-Wmost", + "-Wno-four-char-constants", + "-Wno-unknown-pragmas", + ); + WRAPPER_EXTENSION = vst; + }; + name = Release; + }; + 24BEAAF208919AE700E695F9 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(NATIVE_ARCH)"; + GCC_MODEL_TUNING = G5; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = "DEBUG=1"; + INFOPLIST_FILE = ""; + INFOPLIST_PREPROCESS = NO; + }; + name = Debug; + }; + 24BEAAF308919AE700E695F9 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ARCHS = "$(ARCHS_STANDARD_32_64_BIT_PRE_XCODE_3_1)"; + ARCHS_STANDARD_32_64_BIT_PRE_XCODE_3_1 = "x86_64 i386 ppc"; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_C_LANGUAGE_STANDARD = c99; + GCC_MODEL_TUNING = G4; + GCC_OPTIMIZATION_LEVEL = s; + INFOPLIST_FILE = ""; + INFOPLIST_PREPROCESS = NO; + SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.6.sdk"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 24BEAAED08919AE700E695F9 /* Build configuration list for PBXNativeTarget "PocketVerbs" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 24BEAAEE08919AE700E695F9 /* Debug */, + 24BEAAEF08919AE700E695F9 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; + 24BEAAF108919AE700E695F9 /* Build configuration list for PBXProject "PocketVerbs" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 24BEAAF208919AE700E695F9 /* Debug */, + 24BEAAF308919AE700E695F9 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Debug; + }; +/* End XCConfigurationList section */ + }; + rootObject = 089C1669FE841209C02AAC07 /* Project object */; +} diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100755 index 0000000..a80c038 --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/christopherjohnson.xcuserdatad/UserInterfaceState.xcuserstate b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/christopherjohnson.xcuserdatad/UserInterfaceState.xcuserstate new file mode 100755 index 0000000..5c38f94 Binary files /dev/null and b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/christopherjohnson.xcuserdatad/UserInterfaceState.xcuserstate differ diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/spiadmin.xcuserdatad/UserInterfaceState.xcuserstate b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/spiadmin.xcuserdatad/UserInterfaceState.xcuserstate new file mode 100755 index 0000000..314de0f Binary files /dev/null and b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/spiadmin.xcuserdatad/UserInterfaceState.xcuserstate differ diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.mode1v3 b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.mode1v3 new file mode 100755 index 0000000..c572326 --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.mode1v3 @@ -0,0 +1,1372 @@ + + + + + ActivePerspectiveName + Project + AllowedModules + + + BundleLoadPath + + MaxInstances + n + Module + PBXSmartGroupTreeModule + Name + Groups and Files Outline View + + + BundleLoadPath + + MaxInstances + n + Module + PBXNavigatorGroup + Name + Editor + + + BundleLoadPath + + MaxInstances + n + Module + XCTaskListModule + Name + Task List + + + BundleLoadPath + + MaxInstances + n + Module + XCDetailModule + Name + File and Smart Group Detail Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXBuildResultsModule + Name + Detailed Build Results Viewer + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXProjectFindModule + Name + Project Batch Find Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCProjectFormatConflictsModule + Name + Project Format Conflicts List + + + BundleLoadPath + + MaxInstances + n + Module + PBXBookmarksModule + Name + Bookmarks Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXClassBrowserModule + Name + Class Browser + + + BundleLoadPath + + MaxInstances + n + Module + PBXCVSModule + Name + Source Code Control Tool + + + BundleLoadPath + + MaxInstances + n + Module + PBXDebugBreakpointsModule + Name + Debug Breakpoints Tool + + + BundleLoadPath + + MaxInstances + n + Module + XCDockableInspector + Name + Inspector + + + BundleLoadPath + + MaxInstances + n + Module + PBXOpenQuicklyModule + Name + Open Quickly Tool + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugSessionModule + Name + Debugger + + + BundleLoadPath + + MaxInstances + 1 + Module + PBXDebugCLIModule + Name + Debug Console + + + BundleLoadPath + + MaxInstances + n + Module + XCSnapshotModule + Name + Snapshots Tool + + + BundlePath + /Xcode3/Library/PrivateFrameworks/DevToolsInterface.framework/Resources + Description + DefaultDescriptionKey + DockingSystemVisible + + Extension + mode1v3 + FavBarConfig + + PBXProjectModuleGUID + 91857D9F148EF61800AAA11B + XCBarModuleItemNames + + XCBarModuleItems + + + FirstTimeWindowDisplayed + + Identifier + com.apple.perspectives.project.mode1v3 + MajorVersion + 33 + MinorVersion + 0 + Name + Default + Notifications + + OpenEditors + + PerspectiveWidths + + -1 + -1 + + Perspectives + + + ChosenToolbarItems + + active-combo-popup + action + NSToolbarFlexibleSpaceItem + debugger-enable-breakpoints + build-and-go + com.apple.ide.PBXToolbarStopButton + get-info + NSToolbarFlexibleSpaceItem + com.apple.pbx.toolbar.searchfield + + ControllerClassBaseName + + IconName + WindowOfProjectWithEditor + Identifier + perspective.project + IsVertical + + Layout + + + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 186 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 089C166AFE841209C02AAC07 + 089C1671FE841209C02AAC07 + 19C28FB4FE9D528D11CA2CBB + 089C167CFE841241C02AAC07 + 08FB77ADFE841716C02AAC07 + 1C37FBAC04509CD000000102 + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 11 + 10 + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {186, 693}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + + XCSharingToken + com.apple.Xcode.GFSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {203, 711}} + GroupTreeTableConfiguration + + MainColumn + 186 + + RubberWindowFrame + 286 197 1261 752 0 0 1680 1028 + + Module + PBXSmartGroupTreeModule + Proportion + 203pt + + + Dock + + + BecomeActive + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20306471E060097A5F4 + PBXProjectModuleLabel + Gain.cpp + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CE0B20406471E060097A5F4 + PBXProjectModuleLabel + Gain.cpp + _historyCapacity + 0 + bookmark + 911C2A9D1491A5F600A430AF + history + + 915DCCBB1491A5B8008574E6 + + + SplitCount + 1 + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {1053, 508}} + RubberWindowFrame + 286 197 1261 752 0 0 1680 1028 + + Module + PBXNavigatorGroup + Proportion + 508pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CE0B20506471E060097A5F4 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{0, 513}, {1053, 198}} + RubberWindowFrame + 286 197 1261 752 0 0 1680 1028 + + Module + XCDetailModule + Proportion + 198pt + + + Proportion + 1053pt + + + Name + Project + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + XCModuleDock + PBXNavigatorGroup + XCDetailModule + + TableOfContents + + 911C2A901491A5F600A430AF + 1CE0B1FE06471DED0097A5F4 + 911C2A911491A5F600A430AF + 1CE0B20306471E060097A5F4 + 1CE0B20506471E060097A5F4 + + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarConfiguration + xcode.toolbar.config.defaultV3 + + + ControllerClassBaseName + + IconName + WindowOfProject + Identifier + perspective.morph + IsVertical + 0 + Layout + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C37FBAC04509CD000000102 + 1C37FAAC04509CD000000102 + 1C08E77C0454961000C914BD + 1C37FABC05509CD000000102 + 1C37FABC05539CD112110102 + E2644B35053B69B200211256 + 1C37FABC04509CD000100104 + 1CC0EA4004350EF90044410B + 1CC0EA4004350EF90041110B + + PBXProjectModuleGUID + 11E0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + yes + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 186 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 29B97314FDCFA39411CA2CEA + 1C37FABC05509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {186, 337}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 1 + XCSharingToken + com.apple.Xcode.GFSharingToken + + GeometryConfiguration + + Frame + {{0, 0}, {203, 355}} + GroupTreeTableConfiguration + + MainColumn + 186 + + RubberWindowFrame + 373 269 690 397 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 100% + + + Name + Morph + PreferredWidth + 300 + ServiceClasses + + XCModuleDock + PBXSmartGroupTreeModule + + TableOfContents + + 11E0B1FE06471DED0097A5F4 + + ToolbarConfiguration + xcode.toolbar.config.default.shortV3 + + + PerspectivesBarVisible + + ShelfIsVisible + + SourceDescription + file at '/Xcode3/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecificationMode1.xcperspec' + StatusbarIsVisible + + TimeStamp + 0.0 + ToolbarConfigUserDefaultsMinorVersion + 2 + ToolbarDisplayMode + 1 + ToolbarIsVisible + + ToolbarSizeMode + 1 + Type + Perspectives + UpdateMessage + The Default Workspace in this version of Xcode now includes support to hide and show the detail view (what has been referred to as the "Metro-Morph" feature). You must discard your current Default Workspace settings and update to the latest Default Workspace in order to gain this feature. Do you wish to update to the latest Workspace defaults for project '%@'? + WindowJustification + 5 + WindowOrderList + + 91857DA0148EF61800AAA11B + /Users/spiadmin/Documents/Gain/Gain.xcodeproj + + WindowString + 286 197 1261 752 0 0 1680 1028 + WindowToolsV3 + + + FirstTimeWindowDisplayed + + Identifier + windowTool.build + IsVertical + + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528F0623707200166675 + PBXProjectModuleLabel + + StatusBarVisibility + + + GeometryConfiguration + + Frame + {{0, 0}, {743, 413}} + RubberWindowFrame + 112 208 743 695 0 0 1680 1028 + + Module + PBXNavigatorGroup + Proportion + 413pt + + + ContentConfiguration + + PBXProjectModuleGUID + XCMainBuildResultsModuleGUID + PBXProjectModuleLabel + Build Results + XCBuildResultsTrigger_Collapse + 1021 + XCBuildResultsTrigger_Open + 1011 + + GeometryConfiguration + + Frame + {{0, 418}, {743, 236}} + RubberWindowFrame + 112 208 743 695 0 0 1680 1028 + + Module + PBXBuildResultsModule + Proportion + 236pt + + + Proportion + 654pt + + + Name + Build Results + ServiceClasses + + PBXBuildResultsModule + + StatusbarIsVisible + + TableOfContents + + 91857DA0148EF61800AAA11B + 911C2A921491A5F600A430AF + 1CD0528F0623707200166675 + XCMainBuildResultsModuleGUID + + ToolbarConfiguration + xcode.toolbar.config.buildV3 + WindowContentMinSize + 486 300 + WindowString + 112 208 743 695 0 0 1680 1028 + WindowToolGUID + 91857DA0148EF61800AAA11B + WindowToolIsVisible + + + + Identifier + windowTool.debugger + Layout + + + Dock + + + ContentConfiguration + + Debugger + + HorizontalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {317, 164}} + {{317, 0}, {377, 164}} + + + VerticalSplitView + + _collapsingFrameDimension + 0.0 + _indexOfCollapsedView + 0 + _percentageOfCollapsedView + 0.0 + isCollapsed + yes + sizes + + {{0, 0}, {694, 164}} + {{0, 164}, {694, 216}} + + + + LauncherConfigVersion + 8 + PBXProjectModuleGUID + 1C162984064C10D400B95A72 + PBXProjectModuleLabel + Debug - GLUTExamples (Underwater) + + GeometryConfiguration + + DebugConsoleDrawerSize + {100, 120} + DebugConsoleVisible + None + DebugConsoleWindowFrame + {{200, 200}, {500, 300}} + DebugSTDIOWindowFrame + {{200, 200}, {500, 300}} + Frame + {{0, 0}, {694, 380}} + RubberWindowFrame + 321 238 694 422 0 0 1440 878 + + Module + PBXDebugSessionModule + Proportion + 100% + + + Proportion + 100% + + + Name + Debugger + ServiceClasses + + PBXDebugSessionModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CD10A99069EF8BA00B06720 + 1C0AD2AB069F1E9B00FABCE6 + 1C162984064C10D400B95A72 + 1C0AD2AC069F1E9B00FABCE6 + + ToolbarConfiguration + xcode.toolbar.config.debugV3 + WindowString + 321 238 694 422 0 0 1440 878 + WindowToolGUID + 1CD10A99069EF8BA00B06720 + WindowToolIsVisible + 0 + + + Identifier + windowTool.find + Layout + + + Dock + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1CDD528C0622207200134675 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1CD0528D0623707200166675 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {781, 167}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXNavigatorGroup + Proportion + 781pt + + + Proportion + 50% + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD0528E0623707200166675 + PBXProjectModuleLabel + Project Find + + GeometryConfiguration + + Frame + {{8, 0}, {773, 254}} + RubberWindowFrame + 62 385 781 470 0 0 1440 878 + + Module + PBXProjectFindModule + Proportion + 50% + + + Proportion + 428pt + + + Name + Project Find + ServiceClasses + + PBXProjectFindModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C530D57069F1CE1000CFCEE + 1C530D58069F1CE1000CFCEE + 1C530D59069F1CE1000CFCEE + 1CDD528C0622207200134675 + 1C530D5A069F1CE1000CFCEE + 1CE0B1FE06471DED0097A5F4 + 1CD0528E0623707200166675 + + WindowString + 62 385 781 470 0 0 1440 878 + WindowToolGUID + 1C530D57069F1CE1000CFCEE + WindowToolIsVisible + 0 + + + Identifier + MENUSEPARATOR + + + Identifier + windowTool.debuggerConsole + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAAC065D492600B07095 + PBXProjectModuleLabel + Debugger Console + + GeometryConfiguration + + Frame + {{0, 0}, {650, 250}} + RubberWindowFrame + 516 632 650 250 0 0 1680 1027 + + Module + PBXDebugCLIModule + Proportion + 209pt + + + Proportion + 209pt + + + Name + Debugger Console + ServiceClasses + + PBXDebugCLIModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAAD065D492600B07095 + 1C78EAAE065D492600B07095 + 1C78EAAC065D492600B07095 + + ToolbarConfiguration + xcode.toolbar.config.consoleV3 + WindowString + 650 41 650 250 0 0 1280 1002 + WindowToolGUID + 1C78EAAD065D492600B07095 + WindowToolIsVisible + 0 + + + Identifier + windowTool.snapshots + Layout + + + Dock + + + Module + XCSnapshotModule + Proportion + 100% + + + Proportion + 100% + + + Name + Snapshots + ServiceClasses + + XCSnapshotModule + + StatusbarIsVisible + Yes + ToolbarConfiguration + xcode.toolbar.config.snapshots + WindowString + 315 824 300 550 0 0 1440 878 + WindowToolIsVisible + Yes + + + Identifier + windowTool.scm + Layout + + + Dock + + + ContentConfiguration + + PBXProjectModuleGUID + 1C78EAB2065D492600B07095 + PBXProjectModuleLabel + <No Editor> + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 1C78EAB3065D492600B07095 + + SplitCount + 1 + + StatusBarVisibility + 1 + + GeometryConfiguration + + Frame + {{0, 0}, {452, 0}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + + Module + PBXNavigatorGroup + Proportion + 0pt + + + BecomeActive + 1 + ContentConfiguration + + PBXProjectModuleGUID + 1CD052920623707200166675 + PBXProjectModuleLabel + SCM + + GeometryConfiguration + + ConsoleFrame + {{0, 259}, {452, 0}} + Frame + {{0, 7}, {452, 259}} + RubberWindowFrame + 743 379 452 308 0 0 1280 1002 + TableConfiguration + + Status + 30 + FileName + 199 + Path + 197.0950012207031 + + TableFrame + {{0, 0}, {452, 250}} + + Module + PBXCVSModule + Proportion + 262pt + + + Proportion + 266pt + + + Name + SCM + ServiceClasses + + PBXCVSModule + + StatusbarIsVisible + 1 + TableOfContents + + 1C78EAB4065D492600B07095 + 1C78EAB5065D492600B07095 + 1C78EAB2065D492600B07095 + 1CD052920623707200166675 + + ToolbarConfiguration + xcode.toolbar.config.scm + WindowString + 743 379 452 308 0 0 1280 1002 + + + Identifier + windowTool.breakpoints + IsVertical + 0 + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + PBXBottomSmartGroupGIDs + + 1C77FABC04509CD000000102 + + PBXProjectModuleGUID + 1CE0B1FE06471DED0097A5F4 + PBXProjectModuleLabel + Files + PBXProjectStructureProvided + no + PBXSmartGroupTreeModuleColumnData + + PBXSmartGroupTreeModuleColumnWidthsKey + + 168 + + PBXSmartGroupTreeModuleColumnsKey_v4 + + MainColumn + + + PBXSmartGroupTreeModuleOutlineStateKey_v7 + + PBXSmartGroupTreeModuleOutlineStateExpansionKey + + 1C77FABC04509CD000000102 + + PBXSmartGroupTreeModuleOutlineStateSelectionKey + + + 0 + + + PBXSmartGroupTreeModuleOutlineStateVisibleRectKey + {{0, 0}, {168, 350}} + + PBXTopSmartGroupGIDs + + XCIncludePerspectivesSwitch + 0 + + GeometryConfiguration + + Frame + {{0, 0}, {185, 368}} + GroupTreeTableConfiguration + + MainColumn + 168 + + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + PBXSmartGroupTreeModule + Proportion + 185pt + + + ContentConfiguration + + PBXProjectModuleGUID + 1CA1AED706398EBD00589147 + PBXProjectModuleLabel + Detail + + GeometryConfiguration + + Frame + {{190, 0}, {554, 368}} + RubberWindowFrame + 315 424 744 409 0 0 1440 878 + + Module + XCDetailModule + Proportion + 554pt + + + Proportion + 368pt + + + MajorVersion + 3 + MinorVersion + 0 + Name + Breakpoints + ServiceClasses + + PBXSmartGroupTreeModule + XCDetailModule + + StatusbarIsVisible + 1 + TableOfContents + + 1CDDB66807F98D9800BB5817 + 1CDDB66907F98D9800BB5817 + 1CE0B1FE06471DED0097A5F4 + 1CA1AED706398EBD00589147 + + ToolbarConfiguration + xcode.toolbar.config.breakpointsV3 + WindowString + 315 424 744 409 0 0 1440 878 + WindowToolGUID + 1CDDB66807F98D9800BB5817 + WindowToolIsVisible + 1 + + + Identifier + windowTool.debugAnimator + Layout + + + Dock + + + Module + PBXNavigatorGroup + Proportion + 100% + + + Proportion + 100% + + + Name + Debug Visualizer + ServiceClasses + + PBXNavigatorGroup + + StatusbarIsVisible + 1 + ToolbarConfiguration + xcode.toolbar.config.debugAnimatorV3 + WindowString + 100 100 700 500 0 0 1280 1002 + + + Identifier + windowTool.bookmarks + Layout + + + Dock + + + Module + PBXBookmarksModule + Proportion + 100% + + + Proportion + 100% + + + Name + Bookmarks + ServiceClasses + + PBXBookmarksModule + + StatusbarIsVisible + 0 + WindowString + 538 42 401 187 0 0 1280 1002 + + + Identifier + windowTool.projectFormatConflicts + Layout + + + Dock + + + Module + XCProjectFormatConflictsModule + Proportion + 100% + + + Proportion + 100% + + + Name + Project Format Conflicts + ServiceClasses + + XCProjectFormatConflictsModule + + StatusbarIsVisible + 0 + WindowContentMinSize + 450 300 + WindowString + 50 850 472 307 0 0 1440 877 + + + Identifier + windowTool.classBrowser + Layout + + + Dock + + + BecomeActive + 1 + ContentConfiguration + + OptionsSetName + Hierarchy, all classes + PBXProjectModuleGUID + 1CA6456E063B45B4001379D8 + PBXProjectModuleLabel + Class Browser - NSObject + + GeometryConfiguration + + ClassesFrame + {{0, 0}, {374, 96}} + ClassesTreeTableConfiguration + + PBXClassNameColumnIdentifier + 208 + PBXClassBookColumnIdentifier + 22 + + Frame + {{0, 0}, {630, 331}} + MembersFrame + {{0, 105}, {374, 395}} + MembersTreeTableConfiguration + + PBXMemberTypeIconColumnIdentifier + 22 + PBXMemberNameColumnIdentifier + 216 + PBXMemberTypeColumnIdentifier + 97 + PBXMemberBookColumnIdentifier + 22 + + PBXModuleWindowStatusBarHidden2 + 1 + RubberWindowFrame + 385 179 630 352 0 0 1440 878 + + Module + PBXClassBrowserModule + Proportion + 332pt + + + Proportion + 332pt + + + Name + Class Browser + ServiceClasses + + PBXClassBrowserModule + + StatusbarIsVisible + 0 + TableOfContents + + 1C0AD2AF069F1E9B00FABCE6 + 1C0AD2B0069F1E9B00FABCE6 + 1CA6456E063B45B4001379D8 + + ToolbarConfiguration + xcode.toolbar.config.classbrowser + WindowString + 385 179 630 352 0 0 1440 878 + WindowToolGUID + 1C0AD2AF069F1E9B00FABCE6 + WindowToolIsVisible + 0 + + + Identifier + windowTool.refactoring + IncludeInToolsMenu + 0 + Layout + + + Dock + + + BecomeActive + 1 + GeometryConfiguration + + Frame + {0, 0}, {500, 335} + RubberWindowFrame + {0, 0}, {500, 335} + + Module + XCRefactoringModule + Proportion + 100% + + + Proportion + 100% + + + Name + Refactoring + ServiceClasses + + XCRefactoringModule + + WindowString + 200 200 500 356 0 0 1920 1200 + + + + diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.pbxuser b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.pbxuser new file mode 100755 index 0000000..df94780 --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.pbxuser @@ -0,0 +1,143 @@ +// !$*UTF8*$! +{ + 089C1669FE841209C02AAC07 /* Project object */ = { + activeBuildConfigurationName = Release; + activeTarget = 8D01CCC60486CAD60068D4B7 /* Gain */; + codeSenseManager = 91857D95148EF55400AAA11B /* Code sense */; + perUserDictionary = { + PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 829, + 20, + 48, + 43, + 43, + 20, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + PBXFileDataSource_Target_ColumnID, + ); + }; + PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = { + PBXFileTableDataSourceColumnSortingDirectionKey = "-1"; + PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; + PBXFileTableDataSourceColumnWidthsKey = ( + 20, + 789, + 60, + 20, + 48, + 43, + 43, + ); + PBXFileTableDataSourceColumnsKey = ( + PBXFileDataSource_FiletypeID, + PBXFileDataSource_Filename_ColumnID, + PBXTargetDataSource_PrimaryAttribute, + PBXFileDataSource_Built_ColumnID, + PBXFileDataSource_ObjectSize_ColumnID, + PBXFileDataSource_Errors_ColumnID, + PBXFileDataSource_Warnings_ColumnID, + ); + }; + PBXPerProjectTemplateStateSaveDate = 345089498; + PBXWorkspaceStateSaveDate = 345089498; + }; + perUserProjectItems = { + 911C2A9D1491A5F600A430AF /* PBXTextBookmark */ = 911C2A9D1491A5F600A430AF /* PBXTextBookmark */; + 915DCCBB1491A5B8008574E6 /* PBXTextBookmark */ = 915DCCBB1491A5B8008574E6 /* PBXTextBookmark */; + }; + sourceControlManager = 91857D94148EF55400AAA11B /* Source Control */; + userBuildSettings = { + }; + }; + 2407DEB6089929BA00EB68BF /* Gain.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {992, 1768}}"; + sepNavSelRange = "{247, 0}"; + sepNavVisRange = "{0, 1657}"; + }; + }; + 245463B80991757100464AD3 /* Gain.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {992, 975}}"; + sepNavSelRange = "{1552, 0}"; + sepNavVisRange = "{796, 1857}"; + sepNavWindowFrame = "{{15, 465}, {750, 558}}"; + }; + }; + 24A2FF9A0F90D1DD003BB5A7 /* adelaymain.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {992, 488}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRange = "{0, 798}"; + }; + }; + 24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {859, 19825}}"; + sepNavSelRange = "{10641, 0}"; + sepNavVisRange = "{10076, 1095}"; + }; + }; + 24D8286F09A914000093AEF8 /* GainProc.cpp */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {992, 482}}"; + sepNavSelRange = "{239, 0}"; + sepNavVisRange = "{0, 950}"; + }; + }; + 24D8287E09A9164A0093AEF8 /* xcode_vst_prefix.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {992, 493}}"; + sepNavSelRange = "{249, 0}"; + sepNavVisRange = "{0, 249}"; + }; + }; + 8D01CCC60486CAD60068D4B7 /* Gain */ = { + activeExec = 0; + }; + 911C2A9D1491A5F600A430AF /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 2407DEB6089929BA00EB68BF /* Gain.cpp */; + name = "Gain.cpp: 10"; + rLen = 0; + rLoc = 247; + rType = 0; + vrLen = 1657; + vrLoc = 0; + }; + 915DCCBB1491A5B8008574E6 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 2407DEB6089929BA00EB68BF /* Gain.cpp */; + name = "Gain.cpp: 10"; + rLen = 0; + rLoc = 247; + rType = 0; + vrLen = 1625; + vrLoc = 0; + }; + 91857D94148EF55400AAA11B /* Source Control */ = { + isa = PBXSourceControlManager; + fallbackIsa = XCSourceControlManager; + isSCMEnabled = 0; + scmConfiguration = { + repositoryNamesForRoots = { + "" = ""; + }; + }; + }; + 91857D95148EF55400AAA11B /* Code sense */ = { + isa = PBXCodeSenseManager; + indexTemplatePath = ""; + }; +} diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/Gain.xcscheme b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/Gain.xcscheme new file mode 100755 index 0000000..8ee693f --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/Gain.xcscheme @@ -0,0 +1,80 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/xcschememanagement.plist b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/xcschememanagement.plist new file mode 100755 index 0000000..5bccbcb --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/xcschememanagement.plist @@ -0,0 +1,22 @@ + + + + + SchemeUserState + + Gain.xcscheme + + orderHint + 8 + + + SuppressBuildableAutocreation + + 8D01CCC60486CAD60068D4B7 + + primary + + + + + diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/xcschememanagement.plist b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/xcschememanagement.plist new file mode 100755 index 0000000..a7bdd62 --- /dev/null +++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/xcschememanagement.plist @@ -0,0 +1,22 @@ + + + + + SchemeUserState + + «PROJECTNAME».xcscheme + + orderHint + 0 + + + SuppressBuildableAutocreation + + 8D01CCC60486CAD60068D4B7 + + primary + + + + + diff --git "a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/\302\253PROJECTNAME\302\273.xcscheme" "b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/\302\253PROJECTNAME\302\273.xcscheme" new file mode 100755 index 0000000..0df2de4 --- /dev/null +++ "b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/\302\253PROJECTNAME\302\273.xcscheme" @@ -0,0 +1,57 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/MacVST/PocketVerbs/mac/Info.plist b/plugins/MacVST/PocketVerbs/mac/Info.plist new file mode 100755 index 0000000..697416c --- /dev/null +++ b/plugins/MacVST/PocketVerbs/mac/Info.plist @@ -0,0 +1,24 @@ + + + + + CFBundleDevelopmentRegion + English + CFBundleExecutable + PocketVerbs + CFBundleIconFile + + CFBundleIdentifier + com.airwindows.PocketVerbs + CFBundleInfoDictionaryVersion + 6.0 + CFBundlePackageType + BNDL + CFBundleSignature + Dthr + CFBundleVersion + 1.0 + CSResourcesFileMapped + + + diff --git a/plugins/MacVST/PocketVerbs/mac/PkgInfo b/plugins/MacVST/PocketVerbs/mac/PkgInfo new file mode 100755 index 0000000..19a9cf6 --- /dev/null +++ b/plugins/MacVST/PocketVerbs/mac/PkgInfo @@ -0,0 +1 @@ +BNDL???? \ No newline at end of file diff --git a/plugins/MacVST/PocketVerbs/mac/xcode_vst_prefix.h b/plugins/MacVST/PocketVerbs/mac/xcode_vst_prefix.h new file mode 100755 index 0000000..eaf4c0b --- /dev/null +++ b/plugins/MacVST/PocketVerbs/mac/xcode_vst_prefix.h @@ -0,0 +1,17 @@ +#define MAC 1 +#define MACX 1 + +#define USE_NAMESPACE 0 + +#define TARGET_API_MAC_CARBON 1 +#define USENAVSERVICES 1 + +#define __CF_USE_FRAMEWORK_INCLUDES__ + +#if __MWERKS__ +#define __NOEXTENSIONS__ +#endif + +#define QUARTZ 1 + +#include \ No newline at end of file diff --git a/plugins/MacVST/PocketVerbs/source/PocketVerbs.cpp b/plugins/MacVST/PocketVerbs/source/PocketVerbs.cpp new file mode 100755 index 0000000..4426e4b --- /dev/null +++ b/plugins/MacVST/PocketVerbs/source/PocketVerbs.cpp @@ -0,0 +1,325 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#include "PocketVerbs.h" +#endif + +AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new PocketVerbs(audioMaster);} + +PocketVerbs::PocketVerbs(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 0.0; + B = 0.5; + C = 0.0; + D = 0.5; + + for(count = 0; count < 6; count++) {dAL[count] = 0.0; dBL[count] = 0.0; dCL[count] = 0.0; dDL[count] = 0.0; dEL[count] = 0.0; + dFL[count] = 0.0; dGL[count] = 0.0; dHL[count] = 0.0; dIL[count] = 0.0; dJL[count] = 0.0; dKL[count] = 0.0; dLL[count] = 0.0; + dML[count] = 0.0; dNL[count] = 0.0; dOL[count] = 0.0; dPL[count] = 0.0; dQL[count] = 0.0; dRL[count] = 0.0; dSL[count] = 0.0; + dTL[count] = 0.0; dUL[count] = 0.0; dVL[count] = 0.0; dWL[count] = 0.0; dXL[count] = 0.0; dYL[count] = 0.0; dZL[count] = 0.0;} + + for(count = 0; count < 15149; count++) {aAL[count] = 0.0;} + for(count = 0; count < 15149; count++) {oAL[count] = 0.0;} + for(count = 0; count < 14617; count++) {aBL[count] = 0.0;} + for(count = 0; count < 14617; count++) {oBL[count] = 0.0;} + for(count = 0; count < 14357; count++) {aCL[count] = 0.0;} + for(count = 0; count < 14357; count++) {oCL[count] = 0.0;} + for(count = 0; count < 13817; count++) {aDL[count] = 0.0;} + for(count = 0; count < 13817; count++) {oDL[count] = 0.0;} + for(count = 0; count < 13561; count++) {aEL[count] = 0.0;} + for(count = 0; count < 13561; count++) {oEL[count] = 0.0;} + for(count = 0; count < 13045; count++) {aFL[count] = 0.0;} + for(count = 0; count < 13045; count++) {oFL[count] = 0.0;} + for(count = 0; count < 11965; count++) {aGL[count] = 0.0;} + for(count = 0; count < 11965; count++) {oGL[count] = 0.0;} + for(count = 0; count < 11129; count++) {aHL[count] = 0.0;} + for(count = 0; count < 11129; count++) {oHL[count] = 0.0;} + for(count = 0; count < 10597; count++) {aIL[count] = 0.0;} + for(count = 0; count < 10597; count++) {oIL[count] = 0.0;} + for(count = 0; count < 9809; count++) {aJL[count] = 0.0;} + for(count = 0; count < 9809; count++) {oJL[count] = 0.0;} + for(count = 0; count < 9521; count++) {aKL[count] = 0.0;} + for(count = 0; count < 9521; count++) {oKL[count] = 0.0;} + for(count = 0; count < 8981; count++) {aLL[count] = 0.0;} + for(count = 0; count < 8981; count++) {oLL[count] = 0.0;} + for(count = 0; count < 8785; count++) {aML[count] = 0.0;} + for(count = 0; count < 8785; count++) {oML[count] = 0.0;} + for(count = 0; count < 8461; count++) {aNL[count] = 0.0;} + for(count = 0; count < 8461; count++) {oNL[count] = 0.0;} + for(count = 0; count < 8309; count++) {aOL[count] = 0.0;} + for(count = 0; count < 8309; count++) {oOL[count] = 0.0;} + for(count = 0; count < 7981; count++) {aPL[count] = 0.0;} + for(count = 0; count < 7981; count++) {oPL[count] = 0.0;} + for(count = 0; count < 7321; count++) {aQL[count] = 0.0;} + for(count = 0; count < 7321; count++) {oQL[count] = 0.0;} + for(count = 0; count < 6817; count++) {aRL[count] = 0.0;} + for(count = 0; count < 6817; count++) {oRL[count] = 0.0;} + for(count = 0; count < 6505; count++) {aSL[count] = 0.0;} + for(count = 0; count < 6505; count++) {oSL[count] = 0.0;} + for(count = 0; count < 6001; count++) {aTL[count] = 0.0;} + for(count = 0; count < 6001; count++) {oTL[count] = 0.0;} + for(count = 0; count < 5837; count++) {aUL[count] = 0.0;} + for(count = 0; count < 5837; count++) {oUL[count] = 0.0;} + for(count = 0; count < 5501; count++) {aVL[count] = 0.0;} + for(count = 0; count < 5501; count++) {oVL[count] = 0.0;} + for(count = 0; count < 5009; count++) {aWL[count] = 0.0;} + for(count = 0; count < 5009; count++) {oWL[count] = 0.0;} + for(count = 0; count < 4849; count++) {aXL[count] = 0.0;} + for(count = 0; count < 4849; count++) {oXL[count] = 0.0;} + for(count = 0; count < 4295; count++) {aYL[count] = 0.0;} + for(count = 0; count < 4295; count++) {oYL[count] = 0.0;} + for(count = 0; count < 4179; count++) {aZL[count] = 0.0;} + for(count = 0; count < 4179; count++) {oZL[count] = 0.0;} + + for(count = 0; count < 6; count++) {dAR[count] = 0.0; dBR[count] = 0.0; dCR[count] = 0.0; dDR[count] = 0.0; dER[count] = 0.0; + dFR[count] = 0.0; dGR[count] = 0.0; dHR[count] = 0.0; dIR[count] = 0.0; dJR[count] = 0.0; dKR[count] = 0.0; dLR[count] = 0.0; + dMR[count] = 0.0; dNR[count] = 0.0; dOR[count] = 0.0; dPR[count] = 0.0; dQR[count] = 0.0; dRR[count] = 0.0; dSR[count] = 0.0; + dTR[count] = 0.0; dUR[count] = 0.0; dVR[count] = 0.0; dWR[count] = 0.0; dXR[count] = 0.0; dYR[count] = 0.0; dZR[count] = 0.0;} + + for(count = 0; count < 15149; count++) {aAR[count] = 0.0;} + for(count = 0; count < 15149; count++) {oAR[count] = 0.0;} + for(count = 0; count < 14617; count++) {aBR[count] = 0.0;} + for(count = 0; count < 14617; count++) {oBR[count] = 0.0;} + for(count = 0; count < 14357; count++) {aCR[count] = 0.0;} + for(count = 0; count < 14357; count++) {oCR[count] = 0.0;} + for(count = 0; count < 13817; count++) {aDR[count] = 0.0;} + for(count = 0; count < 13817; count++) {oDR[count] = 0.0;} + for(count = 0; count < 13561; count++) {aER[count] = 0.0;} + for(count = 0; count < 13561; count++) {oER[count] = 0.0;} + for(count = 0; count < 13045; count++) {aFR[count] = 0.0;} + for(count = 0; count < 13045; count++) {oFR[count] = 0.0;} + for(count = 0; count < 11965; count++) {aGR[count] = 0.0;} + for(count = 0; count < 11965; count++) {oGR[count] = 0.0;} + for(count = 0; count < 11129; count++) {aHR[count] = 0.0;} + for(count = 0; count < 11129; count++) {oHR[count] = 0.0;} + for(count = 0; count < 10597; count++) {aIR[count] = 0.0;} + for(count = 0; count < 10597; count++) {oIR[count] = 0.0;} + for(count = 0; count < 9809; count++) {aJR[count] = 0.0;} + for(count = 0; count < 9809; count++) {oJR[count] = 0.0;} + for(count = 0; count < 9521; count++) {aKR[count] = 0.0;} + for(count = 0; count < 9521; count++) {oKR[count] = 0.0;} + for(count = 0; count < 8981; count++) {aLR[count] = 0.0;} + for(count = 0; count < 8981; count++) {oLR[count] = 0.0;} + for(count = 0; count < 8785; count++) {aMR[count] = 0.0;} + for(count = 0; count < 8785; count++) {oMR[count] = 0.0;} + for(count = 0; count < 8461; count++) {aNR[count] = 0.0;} + for(count = 0; count < 8461; count++) {oNR[count] = 0.0;} + for(count = 0; count < 8309; count++) {aOR[count] = 0.0;} + for(count = 0; count < 8309; count++) {oOR[count] = 0.0;} + for(count = 0; count < 7981; count++) {aPR[count] = 0.0;} + for(count = 0; count < 7981; count++) {oPR[count] = 0.0;} + for(count = 0; count < 7321; count++) {aQR[count] = 0.0;} + for(count = 0; count < 7321; count++) {oQR[count] = 0.0;} + for(count = 0; count < 6817; count++) {aRR[count] = 0.0;} + for(count = 0; count < 6817; count++) {oRR[count] = 0.0;} + for(count = 0; count < 6505; count++) {aSR[count] = 0.0;} + for(count = 0; count < 6505; count++) {oSR[count] = 0.0;} + for(count = 0; count < 6001; count++) {aTR[count] = 0.0;} + for(count = 0; count < 6001; count++) {oTR[count] = 0.0;} + for(count = 0; count < 5837; count++) {aUR[count] = 0.0;} + for(count = 0; count < 5837; count++) {oUR[count] = 0.0;} + for(count = 0; count < 5501; count++) {aVR[count] = 0.0;} + for(count = 0; count < 5501; count++) {oVR[count] = 0.0;} + for(count = 0; count < 5009; count++) {aWR[count] = 0.0;} + for(count = 0; count < 5009; count++) {oWR[count] = 0.0;} + for(count = 0; count < 4849; count++) {aXR[count] = 0.0;} + for(count = 0; count < 4849; count++) {oXR[count] = 0.0;} + for(count = 0; count < 4295; count++) {aYR[count] = 0.0;} + for(count = 0; count < 4295; count++) {oYR[count] = 0.0;} + for(count = 0; count < 4179; count++) {aZR[count] = 0.0;} + for(count = 0; count < 4179; count++) {oZR[count] = 0.0;} + + outAL = 1; alpAL = 1; + outBL = 1; alpBL = 1; + outCL = 1; alpCL = 1; + outDL = 1; alpDL = 1; + outEL = 1; alpEL = 1; + outFL = 1; alpFL = 1; + outGL = 1; alpGL = 1; + outHL = 1; alpHL = 1; + outIL = 1; alpIL = 1; + outJL = 1; alpJL = 1; + outKL = 1; alpKL = 1; + outLL = 1; alpLL = 1; + outML = 1; alpML = 1; + outNL = 1; alpNL = 1; + outOL = 1; alpOL = 1; + outPL = 1; alpPL = 1; + outQL = 1; alpQL = 1; + outRL = 1; alpRL = 1; + outSL = 1; alpSL = 1; + outTL = 1; alpTL = 1; + outUL = 1; alpUL = 1; + outVL = 1; alpVL = 1; + outWL = 1; alpWL = 1; + outXL = 1; alpXL = 1; + outYL = 1; alpYL = 1; + outZL = 1; alpZL = 1; + + outAR = 1; alpAR = 1; delayA = 4; maxdelayA = 7573; + outBR = 1; alpBR = 1; delayB = 4; maxdelayB = 7307; + outCR = 1; alpCR = 1; delayC = 4; maxdelayC = 7177; + outDR = 1; alpDR = 1; delayD = 4; maxdelayD = 6907; + outER = 1; alpER = 1; delayE = 4; maxdelayE = 6779; + outFR = 1; alpFR = 1; delayF = 4; maxdelayF = 6521; + outGR = 1; alpGR = 1; delayG = 4; maxdelayG = 5981; + outHR = 1; alpHR = 1; delayH = 4; maxdelayH = 5563; + outIR = 1; alpIR = 1; delayI = 4; maxdelayI = 5297; + outJR = 1; alpJR = 1; delayJ = 4; maxdelayJ = 4903; + outKR = 1; alpKR = 1; delayK = 4; maxdelayK = 4759; + outLR = 1; alpLR = 1; delayL = 4; maxdelayL = 4489; + outMR = 1; alpMR = 1; delayM = 4; maxdelayM = 4391; + outNR = 1; alpNR = 1; delayN = 4; maxdelayN = 4229; + outOR = 1; alpOR = 1; delayO = 4; maxdelayO = 4153; + outPR = 1; alpPR = 1; delayP = 4; maxdelayP = 3989; + outQR = 1; alpQR = 1; delayQ = 4; maxdelayQ = 3659; + outRR = 1; alpRR = 1; delayR = 4; maxdelayR = 3407; + outSR = 1; alpSR = 1; delayS = 4; maxdelayS = 3251; + outTR = 1; alpTR = 1; delayT = 4; maxdelayT = 2999; + outUR = 1; alpUR = 1; delayU = 4; maxdelayU = 2917; + outVR = 1; alpVR = 1; delayV = 4; maxdelayV = 2749; + outWR = 1; alpWR = 1; delayW = 4; maxdelayW = 2503; + outXR = 1; alpXR = 1; delayX = 4; maxdelayX = 2423; + outYR = 1; alpYR = 1; delayY = 4; maxdelayY = 2146; + outZR = 1; alpZR = 1; delayZ = 4; maxdelayZ = 2088; + + savedRoomsize = -1.0; //force update to begin + countdown = -1; + peakL = 1.0; + peakR = 1.0; + fpd = 17; + //this is reset: values being initialized only once. Startup values, whatever they are. + + _canDo.insert("plugAsChannelInsert"); // plug-in can be used as a channel insert effect. + _canDo.insert("plugAsSend"); // plug-in can be used as a send effect. + _canDo.insert("x2in2out"); + setNumInputs(kNumInputs); + setNumOutputs(kNumOutputs); + setUniqueID(kUniqueId); + canProcessReplacing(); // supports output replacing + canDoubleReplacing(); // supports double precision processing + programsAreChunks(true); + vst_strncpy (_programName, "Default", kVstMaxProgNameLen); // default program name +} + +PocketVerbs::~PocketVerbs() {} +VstInt32 PocketVerbs::getVendorVersion () {return 1000;} +void PocketVerbs::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void PocketVerbs::getProgramName(char *name) {vst_strncpy (name, _programName, kVstMaxProgNameLen);} +//airwindows likes to ignore this stuff. Make your own programs, and make a different plugin rather than +//trying to do versioning and preventing people from using older versions. Maybe they like the old one! + +static float pinParameter(float data) +{ + if (data < 0.0f) return 0.0f; + if (data > 1.0f) return 1.0f; + return data; +} + +VstInt32 PocketVerbs::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + chunkData[1] = B; + chunkData[2] = C; + chunkData[3] = D; + /* Note: The way this is set up, it will break if you manage to save settings on an Intel + machine and load them on a PPC Mac. However, it's fine if you stick to the machine you + started with. */ + + *data = chunkData; + return kNumParameters * sizeof(float); +} + +VstInt32 PocketVerbs::setChunk (void* data, VstInt32 byteSize, bool isPreset) +{ + float *chunkData = (float *)data; + A = pinParameter(chunkData[0]); + B = pinParameter(chunkData[1]); + C = pinParameter(chunkData[2]); + D = pinParameter(chunkData[3]); + /* We're ignoring byteSize as we found it to be a filthy liar */ + + /* calculate any other fields you need here - you could copy in + code from setParameter() here. */ + return 0; +} + +void PocketVerbs::setParameter(VstInt32 index, float value) { + switch (index) { + case kParamA: A = value; break; + case kParamB: B = value; break; + case kParamC: C = value; break; + case kParamD: D = value; break; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float PocketVerbs::getParameter(VstInt32 index) { + switch (index) { + case kParamA: return A; break; + case kParamB: return B; break; + case kParamC: return C; break; + case kParamD: return D; break; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void PocketVerbs::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Type", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Size", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "Gating", kVstMaxParamStrLen); break; + case kParamD: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this is our labels for displaying in the VST host +} + +void PocketVerbs::getParameterDisplay(VstInt32 index, char *text) { + switch (index) { + case kParamA: switch((VstInt32)( A * 5.999 )) //0 to almost edge of # of params + { case 0: vst_strncpy (text, "Chamber", kVstMaxParamStrLen); break; + case 1: vst_strncpy (text, "Spring", kVstMaxParamStrLen); break; + case 2: vst_strncpy (text, "Tiled", kVstMaxParamStrLen); break; + case 3: vst_strncpy (text, "Room", kVstMaxParamStrLen); break; + case 4: vst_strncpy (text, "Stretch", kVstMaxParamStrLen); break; + case 5: vst_strncpy (text, "Zarathu", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } break; + case kParamB: float2string (B, text, kVstMaxParamStrLen); break; + case kParamC: float2string (C, text, kVstMaxParamStrLen); break; + case kParamD: float2string (D, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void PocketVerbs::getParameterLabel(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 PocketVerbs::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool PocketVerbs::getEffectName(char* name) { + vst_strncpy(name, "PocketVerbs", kVstMaxProductStrLen); return true; +} + +VstPlugCategory PocketVerbs::getPlugCategory() {return kPlugCategEffect;} + +bool PocketVerbs::getProductString(char* text) { + vst_strncpy (text, "airwindows PocketVerbs", kVstMaxProductStrLen); return true; +} + +bool PocketVerbs::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugins/MacVST/PocketVerbs/source/PocketVerbs.h b/plugins/MacVST/PocketVerbs/source/PocketVerbs.h new file mode 100755 index 0000000..7feaf8e --- /dev/null +++ b/plugins/MacVST/PocketVerbs/source/PocketVerbs.h @@ -0,0 +1,295 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#define __PocketVerbs_H + +#ifndef __audioeffect__ +#include "audioeffectx.h" +#endif + +#include +#include +#include + +enum { + kParamA = 0, + kParamB = 1, + kParamC = 2, + kParamD = 3, + kNumParameters = 4 +}; // + +const int kNumPrograms = 0; +const int kNumInputs = 2; +const int kNumOutputs = 2; +const unsigned long kUniqueId = 'pkvb'; //Change this to what the AU identity is! + +class PocketVerbs : + public AudioEffectX +{ +public: + PocketVerbs(audioMasterCallback audioMaster); + ~PocketVerbs(); + virtual bool getEffectName(char* name); // The plug-in name + virtual VstPlugCategory getPlugCategory(); // The general category for the plug-in + virtual bool getProductString(char* text); // This is a unique plug-in string provided by Steinberg + virtual bool getVendorString(char* text); // Vendor info + virtual VstInt32 getVendorVersion(); // Version number + virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames); + virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames); + virtual void getProgramName(char *name); // read the name from the host + virtual void setProgramName(char *name); // changes the name of the preset displayed in the host + virtual VstInt32 getChunk (void** data, bool isPreset); + virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset); + virtual float getParameter(VstInt32 index); // get the parameter value at the specified index + virtual void setParameter(VstInt32 index, float value); // set the parameter at index to value + virtual void getParameterLabel(VstInt32 index, char *text); // label for the parameter (eg dB) + virtual void getParameterName(VstInt32 index, char *text); // name of the parameter + virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value + virtual VstInt32 canDo(char *text); +private: + char _programName[kVstMaxProgNameLen + 1]; + std::set< std::string > _canDo; + + int count; + + + + double dAR[7]; + double dBR[7]; + double dCR[7]; + double dDR[7]; + double dER[7]; + double dFR[7]; + double dGR[7]; + double dHR[7]; + double dIR[7]; + double dJR[7]; + double dKR[7]; + double dLR[7]; + double dMR[7]; + double dNR[7]; + double dOR[7]; + double dPR[7]; + double dQR[7]; + double dRR[7]; + double dSR[7]; + double dTR[7]; + double dUR[7]; + double dVR[7]; + double dWR[7]; + double dXR[7]; + double dYR[7]; + double dZR[7]; + + double aAR[15150]; + double aBR[14618]; + double aCR[14358]; + double aDR[13818]; + double aER[13562]; + double aFR[13046]; + double aGR[11966]; + double aHR[11130]; + double aIR[10598]; + double aJR[9810]; + double aKR[9522]; + double aLR[8982]; + double aMR[8786]; + double aNR[8462]; + double aOR[8310]; + double aPR[7982]; + double aQR[7322]; + double aRR[6818]; + double aSR[6506]; + double aTR[6002]; + double aUR[5838]; + double aVR[5502]; + double aWR[5010]; + double aXR[4850]; + double aYR[4296]; + double aZR[4180]; + + double oAR[15150]; + double oBR[14618]; + double oCR[14358]; + double oDR[13818]; + double oER[13562]; + double oFR[13046]; + double oGR[11966]; + double oHR[11130]; + double oIR[10598]; + double oJR[9810]; + double oKR[9522]; + double oLR[8982]; + double oMR[8786]; + double oNR[8462]; + double oOR[8310]; + double oPR[7982]; + double oQR[7322]; + double oRR[6818]; + double oSR[6506]; + double oTR[6002]; + double oUR[5838]; + double oVR[5502]; + double oWR[5010]; + double oXR[4850]; + double oYR[4296]; + double oZR[4180]; + + double dAL[7]; + double dBL[7]; + double dCL[7]; + double dDL[7]; + double dEL[7]; + double dFL[7]; + double dGL[7]; + double dHL[7]; + double dIL[7]; + double dJL[7]; + double dKL[7]; + double dLL[7]; + double dML[7]; + double dNL[7]; + double dOL[7]; + double dPL[7]; + double dQL[7]; + double dRL[7]; + double dSL[7]; + double dTL[7]; + double dUL[7]; + double dVL[7]; + double dWL[7]; + double dXL[7]; + double dYL[7]; + double dZL[7]; + + double aAL[15150]; + double aBL[14618]; + double aCL[14358]; + double aDL[13818]; + double aEL[13562]; + double aFL[13046]; + double aGL[11966]; + double aHL[11130]; + double aIL[10598]; + double aJL[9810]; + double aKL[9522]; + double aLL[8982]; + double aML[8786]; + double aNL[8462]; + double aOL[8310]; + double aPL[7982]; + double aQL[7322]; + double aRL[6818]; + double aSL[6506]; + double aTL[6002]; + double aUL[5838]; + double aVL[5502]; + double aWL[5010]; + double aXL[4850]; + double aYL[4296]; + double aZL[4180]; + + double oAL[15150]; + double oBL[14618]; + double oCL[14358]; + double oDL[13818]; + double oEL[13562]; + double oFL[13046]; + double oGL[11966]; + double oHL[11130]; + double oIL[10598]; + double oJL[9810]; + double oKL[9522]; + double oLL[8982]; + double oML[8786]; + double oNL[8462]; + double oOL[8310]; + double oPL[7982]; + double oQL[7322]; + double oRL[6818]; + double oSL[6506]; + double oTL[6002]; + double oUL[5838]; + double oVL[5502]; + double oWL[5010]; + double oXL[4850]; + double oYL[4296]; + double oZL[4180]; + + + + int outAL, alpAL; + int outBL, alpBL; + int outCL, alpCL; + int outDL, alpDL; + int outEL, alpEL; + int outFL, alpFL; + int outGL, alpGL; + int outHL, alpHL; + int outIL, alpIL; + int outJL, alpJL; + int outKL, alpKL; + int outLL, alpLL; + int outML, alpML; + int outNL, alpNL; + int outOL, alpOL; + int outPL, alpPL; + int outQL, alpQL; + int outRL, alpRL; + int outSL, alpSL; + int outTL, alpTL; + int outUL, alpUL; + int outVL, alpVL; + int outWL, alpWL; + int outXL, alpXL; + int outYL, alpYL; + int outZL, alpZL; + + int outAR, alpAR, maxdelayA, delayA; + int outBR, alpBR, maxdelayB, delayB; + int outCR, alpCR, maxdelayC, delayC; + int outDR, alpDR, maxdelayD, delayD; + int outER, alpER, maxdelayE, delayE; + int outFR, alpFR, maxdelayF, delayF; + int outGR, alpGR, maxdelayG, delayG; + int outHR, alpHR, maxdelayH, delayH; + int outIR, alpIR, maxdelayI, delayI; + int outJR, alpJR, maxdelayJ, delayJ; + int outKR, alpKR, maxdelayK, delayK; + int outLR, alpLR, maxdelayL, delayL; + int outMR, alpMR, maxdelayM, delayM; + int outNR, alpNR, maxdelayN, delayN; + int outOR, alpOR, maxdelayO, delayO; + int outPR, alpPR, maxdelayP, delayP; + int outQR, alpQR, maxdelayQ, delayQ; + int outRR, alpRR, maxdelayR, delayR; + int outSR, alpSR, maxdelayS, delayS; + int outTR, alpTR, maxdelayT, delayT; + int outUR, alpUR, maxdelayU, delayU; + int outVR, alpVR, maxdelayV, delayV; + int outWR, alpWR, maxdelayW, delayW; + int outXR, alpXR, maxdelayX, delayX; + int outYR, alpYR, maxdelayY, delayY; + int outZR, alpZR, maxdelayZ, delayZ; + + double savedRoomsize; + int countdown; + double peakL; + double peakR; + + uint32_t fpd; + //default stuff + + float A; + float B; + float C; + float D; + +}; + +#endif diff --git a/plugins/MacVST/PocketVerbs/source/PocketVerbsProc.cpp b/plugins/MacVST/PocketVerbs/source/PocketVerbsProc.cpp new file mode 100755 index 0000000..4ea8f51 --- /dev/null +++ b/plugins/MacVST/PocketVerbs/source/PocketVerbsProc.cpp @@ -0,0 +1,18358 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#include "PocketVerbs.h" +#endif + +void PocketVerbs::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + int verbtype = (VstInt32)( A * 5.999 )+1; + + double roomsize = (pow(B,2)*1.9)+0.1; + + double release = 0.00008 * pow(C,3); + if (release == 0.0) {peakL = 1.0; peakR = 1.0;} + double wetnesstarget = D; + double dryness = (1.0 - wetnesstarget); + //verbs use base wetness value internally + double wetness = wetnesstarget; + double constallpass = 0.618033988749894848204586; //golden ratio! + int allpasstemp; + int count; + int max = 70; //biggest divisor to test primes against + double bridgerectifier; + double gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive + //used as an aux, saturates when fed high levels + + //remap values to primes input number in question is 'i' + //max is the largest prime we care about- HF interactions more interesting than the big numbers + //pushing values larger and larger until we have a result + //for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}} + + if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAL; count < 15149; count++) {aAL[count] = 0.0;} + for(count = outAL; count < 15149; count++) {oAL[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBL; count < 14617; count++) {aBL[count] = 0.0;} + for(count = outBL; count < 14617; count++) {oBL[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCL; count < 14357; count++) {aCL[count] = 0.0;} + for(count = outCL; count < 14357; count++) {oCL[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDL; count < 13817; count++) {aDL[count] = 0.0;} + for(count = outDL; count < 13817; count++) {oDL[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpEL; count < 13561; count++) {aEL[count] = 0.0;} + for(count = outEL; count < 13561; count++) {oEL[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFL; count < 13045; count++) {aFL[count] = 0.0;} + for(count = outFL; count < 13045; count++) {oFL[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGL; count < 11965; count++) {aGL[count] = 0.0;} + for(count = outGL; count < 11965; count++) {oGL[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHL; count < 11129; count++) {aHL[count] = 0.0;} + for(count = outHL; count < 11129; count++) {oHL[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIL; count < 10597; count++) {aIL[count] = 0.0;} + for(count = outIL; count < 10597; count++) {oIL[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJL; count < 9809; count++) {aJL[count] = 0.0;} + for(count = outJL; count < 9809; count++) {oJL[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKL; count < 9521; count++) {aKL[count] = 0.0;} + for(count = outKL; count < 9521; count++) {oKL[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLL; count < 8981; count++) {aLL[count] = 0.0;} + for(count = outLL; count < 8981; count++) {oLL[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpML; count < 8785; count++) {aML[count] = 0.0;} + for(count = outML; count < 8785; count++) {oML[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNL; count < 8461; count++) {aNL[count] = 0.0;} + for(count = outNL; count < 8461; count++) {oNL[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOL; count < 8309; count++) {aOL[count] = 0.0;} + for(count = outOL; count < 8309; count++) {oOL[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPL; count < 7981; count++) {aPL[count] = 0.0;} + for(count = outPL; count < 7981; count++) {oPL[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQL; count < 7321; count++) {aQL[count] = 0.0;} + for(count = outQL; count < 7321; count++) {oQL[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRL; count < 6817; count++) {aRL[count] = 0.0;} + for(count = outRL; count < 6817; count++) {oRL[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSL; count < 6505; count++) {aSL[count] = 0.0;} + for(count = outSL; count < 6505; count++) {oSL[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTL; count < 6001; count++) {aTL[count] = 0.0;} + for(count = outTL; count < 6001; count++) {oTL[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUL; count < 5837; count++) {aUL[count] = 0.0;} + for(count = outUL; count < 5837; count++) {oUL[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVL; count < 5501; count++) {aVL[count] = 0.0;} + for(count = outVL; count < 5501; count++) {oVL[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWL; count < 5009; count++) {aWL[count] = 0.0;} + for(count = outWL; count < 5009; count++) {oWL[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXL; count < 4849; count++) {aXL[count] = 0.0;} + for(count = outXL; count < 4849; count++) {oXL[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYL; count < 4295; count++) {aYL[count] = 0.0;} + for(count = outYL; count < 4295; count++) {oYL[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZL; count < 4179; count++) {aZL[count] = 0.0;} + for(count = outZL; count < 4179; count++) {oZL[count] = 0.0;} + break; + } //end of switch statement + //countdown--; we are doing this after the second one + } + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAR; count < 15149; count++) {aAR[count] = 0.0;} + for(count = outAR; count < 15149; count++) {oAR[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBR; count < 14617; count++) {aBR[count] = 0.0;} + for(count = outBR; count < 14617; count++) {oBR[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCR; count < 14357; count++) {aCR[count] = 0.0;} + for(count = outCR; count < 14357; count++) {oCR[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDR; count < 13817; count++) {aDR[count] = 0.0;} + for(count = outDR; count < 13817; count++) {oDR[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpER; count < 13561; count++) {aER[count] = 0.0;} + for(count = outER; count < 13561; count++) {oER[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFR; count < 13045; count++) {aFR[count] = 0.0;} + for(count = outFR; count < 13045; count++) {oFR[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGR; count < 11965; count++) {aGR[count] = 0.0;} + for(count = outGR; count < 11965; count++) {oGR[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHR; count < 11129; count++) {aHR[count] = 0.0;} + for(count = outHR; count < 11129; count++) {oHR[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIR; count < 10597; count++) {aIR[count] = 0.0;} + for(count = outIR; count < 10597; count++) {oIR[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJR; count < 9809; count++) {aJR[count] = 0.0;} + for(count = outJR; count < 9809; count++) {oJR[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKR; count < 9521; count++) {aKR[count] = 0.0;} + for(count = outKR; count < 9521; count++) {oKR[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLR; count < 8981; count++) {aLR[count] = 0.0;} + for(count = outLR; count < 8981; count++) {oLR[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpMR; count < 8785; count++) {aMR[count] = 0.0;} + for(count = outMR; count < 8785; count++) {oMR[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNR; count < 8461; count++) {aNR[count] = 0.0;} + for(count = outNR; count < 8461; count++) {oNR[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOR; count < 8309; count++) {aOR[count] = 0.0;} + for(count = outOR; count < 8309; count++) {oOR[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPR; count < 7981; count++) {aPR[count] = 0.0;} + for(count = outPR; count < 7981; count++) {oPR[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQR; count < 7321; count++) {aQR[count] = 0.0;} + for(count = outQR; count < 7321; count++) {oQR[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRR; count < 6817; count++) {aRR[count] = 0.0;} + for(count = outRR; count < 6817; count++) {oRR[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSR; count < 6505; count++) {aSR[count] = 0.0;} + for(count = outSR; count < 6505; count++) {oSR[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTR; count < 6001; count++) {aTR[count] = 0.0;} + for(count = outTR; count < 6001; count++) {oTR[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUR; count < 5837; count++) {aUR[count] = 0.0;} + for(count = outUR; count < 5837; count++) {oUR[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVR; count < 5501; count++) {aVR[count] = 0.0;} + for(count = outVR; count < 5501; count++) {oVR[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWR; count < 5009; count++) {aWR[count] = 0.0;} + for(count = outWR; count < 5009; count++) {oWR[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXR; count < 4849; count++) {aXR[count] = 0.0;} + for(count = outXR; count < 4849; count++) {oXR[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYR; count < 4295; count++) {aYR[count] = 0.0;} + for(count = outYR; count < 4295; count++) {oYR[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZR; count < 4179; count++) {aZR[count] = 0.0;} + for(count = outZR; count < 4179; count++) {oZR[count] = 0.0;} + break; + } //end of switch statement + countdown--; //every buffer we'll do one of the recalculations for prime buffer sizes + } + + + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + + if (fabs(inputSampleL)<1.18e-37) inputSampleL = fpd * 1.18e-37; + if (fabs(inputSampleR)<1.18e-37) inputSampleR = fpd * 1.18e-37; + + long double drySampleL = inputSampleL; + long double drySampleR = inputSampleR; + + peakL -= release; + if (peakL < fabs(inputSampleL*2.0)) peakL = fabs(inputSampleL*2.0); + if (peakL > 1.0) peakL = 1.0; + peakR -= release; + if (peakR < fabs(inputSampleR*2.0)) peakR = fabs(inputSampleR*2.0); + if (peakR > 1.0) peakR = 1.0; + //chase the maximum signal to incorporate the wetter/louder behavior + //boost for more extreme effect when in use, cap it + + inputSampleL *= gain; + bridgerectifier = fabs(inputSampleL); + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + inputSampleR *= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + //here we apply the ADT2 console-on-steroids trick + + + + + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dYL[1] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dXL[1] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dWL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dVL[1] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dUL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dTL[1] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dSL[1] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dRL[1] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dQL[1] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dPL[1] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dOL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dNL[1] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dLL[1] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dKL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dJL[1] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dIL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dHL[1] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dGL[1] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dFL[1] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dEL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dDL[1] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dCL[1] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dAL[1] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dBL[1] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[5] + dZL[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = drySampleL; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[1]+dAL[2])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[1]+dBL[2])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[1]+dCL[2])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[1]+dDL[2])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[1]+dEL[2])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[1]+dFL[2])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[1]+dGL[2])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[1]+dHL[2])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[1]+dIL[2])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[1]+dJL[2])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[1]+dKL[2])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[1]+dLL[2])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1]+dML[2])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[1]+dNL[2])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[1]+dOL[2])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[1]+dPL[2])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[1]+dQL[2])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[1]+dRL[2])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[1]+dSL[2])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[1]+dTL[2])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[1]+dUL[2])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[1]+dVL[2])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[1]+dWL[2])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[1]+dXL[2])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[1]+dYL[2])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dBL[4] * dryness); + inputSampleL += (dCL[4] * dryness); + inputSampleL += dDL[4]; + inputSampleL += dEL[4]; + inputSampleL += dFL[4]; + inputSampleL += dGL[4]; + inputSampleL += dHL[4]; + inputSampleL += dIL[4]; + inputSampleL += dJL[4]; + inputSampleL += dKL[4]; + inputSampleL += dLL[4]; + inputSampleL += dML[4]; + inputSampleL += dNL[4]; + inputSampleL += dOL[4]; + inputSampleL += dPL[4]; + inputSampleL += dQL[4]; + inputSampleL += dRL[4]; + inputSampleL += dSL[4]; + inputSampleL += dTL[4]; + inputSampleL += dUL[4]; + inputSampleL += dVL[4]; + inputSampleL += dWL[4]; + inputSampleL += dXL[4]; + inputSampleL += dYL[4]; + inputSampleL += (dZL[4] * wetness); + + inputSampleL += (dBL[5] * dryness); + inputSampleL += (dCL[5] * dryness); + inputSampleL += dDL[5]; + inputSampleL += dEL[5]; + inputSampleL += dFL[5]; + inputSampleL += dGL[5]; + inputSampleL += dHL[5]; + inputSampleL += dIL[5]; + inputSampleL += dJL[5]; + inputSampleL += dKL[5]; + inputSampleL += dLL[5]; + inputSampleL += dML[5]; + inputSampleL += dNL[5]; + inputSampleL += dOL[5]; + inputSampleL += dPL[5]; + inputSampleL += dQL[5]; + inputSampleL += dRL[5]; + inputSampleL += dSL[5]; + inputSampleL += dTL[5]; + inputSampleL += dUL[5]; + inputSampleL += dVL[5]; + inputSampleL += dWL[5]; + inputSampleL += dXL[5]; + inputSampleL += dYL[5]; + inputSampleL += (dZL[5] * wetness); + + inputSampleL /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dZL[3])/3.0; //add feedback + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dCL[1] + dAL[5] + dAL[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dYR[1] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dXR[1] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dWR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dVR[1] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dUR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dTR[1] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dSR[1] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dRR[1] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dQR[1] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dPR[1] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dOR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dNR[1] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dLR[1] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dKR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dJR[1] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dIR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dHR[1] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dGR[1] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dFR[1] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dER[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dDR[1] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dCR[1] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dAR[1] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dBR[1] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[5] + dZR[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = drySampleR; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[1]+dAR[2])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[1]+dBR[2])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[1]+dCR[2])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[1]+dDR[2])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[1]+dER[2])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[1]+dFR[2])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[1]+dGR[2])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[1]+dHR[2])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[1]+dIR[2])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[1]+dJR[2])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[1]+dKR[2])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[1]+dLR[2])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1]+dMR[2])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[1]+dNR[2])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[1]+dOR[2])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[1]+dPR[2])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[1]+dQR[2])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[1]+dRR[2])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[1]+dSR[2])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[1]+dTR[2])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[1]+dUR[2])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[1]+dVR[2])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[1]+dWR[2])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[1]+dXR[2])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[1]+dYR[2])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dBR[4] * dryness); + inputSampleR += (dCR[4] * dryness); + inputSampleR += dDR[4]; + inputSampleR += dER[4]; + inputSampleR += dFR[4]; + inputSampleR += dGR[4]; + inputSampleR += dHR[4]; + inputSampleR += dIR[4]; + inputSampleR += dJR[4]; + inputSampleR += dKR[4]; + inputSampleR += dLR[4]; + inputSampleR += dMR[4]; + inputSampleR += dNR[4]; + inputSampleR += dOR[4]; + inputSampleR += dPR[4]; + inputSampleR += dQR[4]; + inputSampleR += dRR[4]; + inputSampleR += dSR[4]; + inputSampleR += dTR[4]; + inputSampleR += dUR[4]; + inputSampleR += dVR[4]; + inputSampleR += dWR[4]; + inputSampleR += dXR[4]; + inputSampleR += dYR[4]; + inputSampleR += (dZR[4] * wetness); + + inputSampleR += (dBR[5] * dryness); + inputSampleR += (dCR[5] * dryness); + inputSampleR += dDR[5]; + inputSampleR += dER[5]; + inputSampleR += dFR[5]; + inputSampleR += dGR[5]; + inputSampleR += dHR[5]; + inputSampleR += dIR[5]; + inputSampleR += dJR[5]; + inputSampleR += dKR[5]; + inputSampleR += dLR[5]; + inputSampleR += dMR[5]; + inputSampleR += dNR[5]; + inputSampleR += dOR[5]; + inputSampleR += dPR[5]; + inputSampleR += dQR[5]; + inputSampleR += dRR[5]; + inputSampleR += dSR[5]; + inputSampleR += dTR[5]; + inputSampleR += dUR[5]; + inputSampleR += dVR[5]; + inputSampleR += dWR[5]; + inputSampleR += dXR[5]; + inputSampleR += dYR[5]; + inputSampleR += (dZR[5] * wetness); + + inputSampleR /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dZR[3])/3.0; //add feedback + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dCR[1] + dAR[5] + dAR[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + + bridgerectifier = fabs(inputSampleL); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleL > 0) inputSampleL -= bridgerectifier; + else inputSampleL += bridgerectifier; + inputSampleL /= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleR > 0) inputSampleR -= bridgerectifier; + else inputSampleR += bridgerectifier; + inputSampleR /= gain; + //here we apply the ADT2 'console on steroids' trick + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakL; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleL *= (1.0-wetness); + inputSampleL *= wetness; + inputSampleL += drySampleL; + //here we combine the tanks with the dry signal + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakR; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleR *= (1.0-wetness); + inputSampleR *= wetness; + inputSampleR += drySampleR; + //here we combine the tanks with the dry signal + + //begin 32 bit stereo floating point dither + int expon; frexpf((float)inputSampleL, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleL += ((double(fpd)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + frexpf((float)inputSampleR, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleR += ((double(fpd)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + //end 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} + +void PocketVerbs::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + int verbtype = (VstInt32)( A * 5.999 )+1; + + double roomsize = (pow(B,2)*1.9)+0.1; + + double release = 0.00008 * pow(C,3); + if (release == 0.0) {peakL = 1.0; peakR = 1.0;} + double wetnesstarget = D; + double dryness = (1.0 - wetnesstarget); + //verbs use base wetness value internally + double wetness = wetnesstarget; + double constallpass = 0.618033988749894848204586; //golden ratio! + int allpasstemp; + int count; + int max = 70; //biggest divisor to test primes against + double bridgerectifier; + double gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive + //used as an aux, saturates when fed high levels + + //remap values to primes input number in question is 'i' + //max is the largest prime we care about- HF interactions more interesting than the big numbers + //pushing values larger and larger until we have a result + //for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}} + + if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAL; count < 15149; count++) {aAL[count] = 0.0;} + for(count = outAL; count < 15149; count++) {oAL[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBL; count < 14617; count++) {aBL[count] = 0.0;} + for(count = outBL; count < 14617; count++) {oBL[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCL; count < 14357; count++) {aCL[count] = 0.0;} + for(count = outCL; count < 14357; count++) {oCL[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDL; count < 13817; count++) {aDL[count] = 0.0;} + for(count = outDL; count < 13817; count++) {oDL[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpEL; count < 13561; count++) {aEL[count] = 0.0;} + for(count = outEL; count < 13561; count++) {oEL[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFL; count < 13045; count++) {aFL[count] = 0.0;} + for(count = outFL; count < 13045; count++) {oFL[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGL; count < 11965; count++) {aGL[count] = 0.0;} + for(count = outGL; count < 11965; count++) {oGL[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHL; count < 11129; count++) {aHL[count] = 0.0;} + for(count = outHL; count < 11129; count++) {oHL[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIL; count < 10597; count++) {aIL[count] = 0.0;} + for(count = outIL; count < 10597; count++) {oIL[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJL; count < 9809; count++) {aJL[count] = 0.0;} + for(count = outJL; count < 9809; count++) {oJL[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKL; count < 9521; count++) {aKL[count] = 0.0;} + for(count = outKL; count < 9521; count++) {oKL[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLL; count < 8981; count++) {aLL[count] = 0.0;} + for(count = outLL; count < 8981; count++) {oLL[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpML; count < 8785; count++) {aML[count] = 0.0;} + for(count = outML; count < 8785; count++) {oML[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNL; count < 8461; count++) {aNL[count] = 0.0;} + for(count = outNL; count < 8461; count++) {oNL[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOL; count < 8309; count++) {aOL[count] = 0.0;} + for(count = outOL; count < 8309; count++) {oOL[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPL; count < 7981; count++) {aPL[count] = 0.0;} + for(count = outPL; count < 7981; count++) {oPL[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQL; count < 7321; count++) {aQL[count] = 0.0;} + for(count = outQL; count < 7321; count++) {oQL[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRL; count < 6817; count++) {aRL[count] = 0.0;} + for(count = outRL; count < 6817; count++) {oRL[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSL; count < 6505; count++) {aSL[count] = 0.0;} + for(count = outSL; count < 6505; count++) {oSL[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTL; count < 6001; count++) {aTL[count] = 0.0;} + for(count = outTL; count < 6001; count++) {oTL[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUL; count < 5837; count++) {aUL[count] = 0.0;} + for(count = outUL; count < 5837; count++) {oUL[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVL; count < 5501; count++) {aVL[count] = 0.0;} + for(count = outVL; count < 5501; count++) {oVL[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWL; count < 5009; count++) {aWL[count] = 0.0;} + for(count = outWL; count < 5009; count++) {oWL[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXL; count < 4849; count++) {aXL[count] = 0.0;} + for(count = outXL; count < 4849; count++) {oXL[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYL; count < 4295; count++) {aYL[count] = 0.0;} + for(count = outYL; count < 4295; count++) {oYL[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZL; count < 4179; count++) {aZL[count] = 0.0;} + for(count = outZL; count < 4179; count++) {oZL[count] = 0.0;} + break; + } //end of switch statement + //countdown--; we are doing this after the second one + } + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAR; count < 15149; count++) {aAR[count] = 0.0;} + for(count = outAR; count < 15149; count++) {oAR[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBR; count < 14617; count++) {aBR[count] = 0.0;} + for(count = outBR; count < 14617; count++) {oBR[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCR; count < 14357; count++) {aCR[count] = 0.0;} + for(count = outCR; count < 14357; count++) {oCR[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDR; count < 13817; count++) {aDR[count] = 0.0;} + for(count = outDR; count < 13817; count++) {oDR[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpER; count < 13561; count++) {aER[count] = 0.0;} + for(count = outER; count < 13561; count++) {oER[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFR; count < 13045; count++) {aFR[count] = 0.0;} + for(count = outFR; count < 13045; count++) {oFR[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGR; count < 11965; count++) {aGR[count] = 0.0;} + for(count = outGR; count < 11965; count++) {oGR[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHR; count < 11129; count++) {aHR[count] = 0.0;} + for(count = outHR; count < 11129; count++) {oHR[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIR; count < 10597; count++) {aIR[count] = 0.0;} + for(count = outIR; count < 10597; count++) {oIR[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJR; count < 9809; count++) {aJR[count] = 0.0;} + for(count = outJR; count < 9809; count++) {oJR[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKR; count < 9521; count++) {aKR[count] = 0.0;} + for(count = outKR; count < 9521; count++) {oKR[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLR; count < 8981; count++) {aLR[count] = 0.0;} + for(count = outLR; count < 8981; count++) {oLR[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpMR; count < 8785; count++) {aMR[count] = 0.0;} + for(count = outMR; count < 8785; count++) {oMR[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNR; count < 8461; count++) {aNR[count] = 0.0;} + for(count = outNR; count < 8461; count++) {oNR[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOR; count < 8309; count++) {aOR[count] = 0.0;} + for(count = outOR; count < 8309; count++) {oOR[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPR; count < 7981; count++) {aPR[count] = 0.0;} + for(count = outPR; count < 7981; count++) {oPR[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQR; count < 7321; count++) {aQR[count] = 0.0;} + for(count = outQR; count < 7321; count++) {oQR[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRR; count < 6817; count++) {aRR[count] = 0.0;} + for(count = outRR; count < 6817; count++) {oRR[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSR; count < 6505; count++) {aSR[count] = 0.0;} + for(count = outSR; count < 6505; count++) {oSR[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTR; count < 6001; count++) {aTR[count] = 0.0;} + for(count = outTR; count < 6001; count++) {oTR[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUR; count < 5837; count++) {aUR[count] = 0.0;} + for(count = outUR; count < 5837; count++) {oUR[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVR; count < 5501; count++) {aVR[count] = 0.0;} + for(count = outVR; count < 5501; count++) {oVR[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWR; count < 5009; count++) {aWR[count] = 0.0;} + for(count = outWR; count < 5009; count++) {oWR[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXR; count < 4849; count++) {aXR[count] = 0.0;} + for(count = outXR; count < 4849; count++) {oXR[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYR; count < 4295; count++) {aYR[count] = 0.0;} + for(count = outYR; count < 4295; count++) {oYR[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZR; count < 4179; count++) {aZR[count] = 0.0;} + for(count = outZR; count < 4179; count++) {oZR[count] = 0.0;} + break; + } //end of switch statement + countdown--; //every buffer we'll do one of the recalculations for prime buffer sizes + } + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + + if (fabs(inputSampleL)<1.18e-43) inputSampleL = fpd * 1.18e-43; + if (fabs(inputSampleR)<1.18e-43) inputSampleR = fpd * 1.18e-43; + + long double drySampleL = inputSampleL; + long double drySampleR = inputSampleR; + + peakL -= release; + if (peakL < fabs(inputSampleL*2.0)) peakL = fabs(inputSampleL*2.0); + if (peakL > 1.0) peakL = 1.0; + peakR -= release; + if (peakR < fabs(inputSampleR*2.0)) peakR = fabs(inputSampleR*2.0); + if (peakR > 1.0) peakR = 1.0; + //chase the maximum signal to incorporate the wetter/louder behavior + //boost for more extreme effect when in use, cap it + + inputSampleL *= gain; + bridgerectifier = fabs(inputSampleL); + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + inputSampleR *= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + //here we apply the ADT2 console-on-steroids trick + + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dYL[1] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dXL[1] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dWL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dVL[1] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dUL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dTL[1] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dSL[1] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dRL[1] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dQL[1] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dPL[1] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dOL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dNL[1] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dLL[1] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dKL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dJL[1] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dIL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dHL[1] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dGL[1] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dFL[1] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dEL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dDL[1] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dCL[1] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dAL[1] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dBL[1] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[5] + dZL[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = drySampleL; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[1]+dAL[2])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[1]+dBL[2])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[1]+dCL[2])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[1]+dDL[2])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[1]+dEL[2])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[1]+dFL[2])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[1]+dGL[2])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[1]+dHL[2])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[1]+dIL[2])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[1]+dJL[2])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[1]+dKL[2])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[1]+dLL[2])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1]+dML[2])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[1]+dNL[2])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[1]+dOL[2])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[1]+dPL[2])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[1]+dQL[2])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[1]+dRL[2])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[1]+dSL[2])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[1]+dTL[2])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[1]+dUL[2])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[1]+dVL[2])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[1]+dWL[2])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[1]+dXL[2])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[1]+dYL[2])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dBL[4] * dryness); + inputSampleL += (dCL[4] * dryness); + inputSampleL += dDL[4]; + inputSampleL += dEL[4]; + inputSampleL += dFL[4]; + inputSampleL += dGL[4]; + inputSampleL += dHL[4]; + inputSampleL += dIL[4]; + inputSampleL += dJL[4]; + inputSampleL += dKL[4]; + inputSampleL += dLL[4]; + inputSampleL += dML[4]; + inputSampleL += dNL[4]; + inputSampleL += dOL[4]; + inputSampleL += dPL[4]; + inputSampleL += dQL[4]; + inputSampleL += dRL[4]; + inputSampleL += dSL[4]; + inputSampleL += dTL[4]; + inputSampleL += dUL[4]; + inputSampleL += dVL[4]; + inputSampleL += dWL[4]; + inputSampleL += dXL[4]; + inputSampleL += dYL[4]; + inputSampleL += (dZL[4] * wetness); + + inputSampleL += (dBL[5] * dryness); + inputSampleL += (dCL[5] * dryness); + inputSampleL += dDL[5]; + inputSampleL += dEL[5]; + inputSampleL += dFL[5]; + inputSampleL += dGL[5]; + inputSampleL += dHL[5]; + inputSampleL += dIL[5]; + inputSampleL += dJL[5]; + inputSampleL += dKL[5]; + inputSampleL += dLL[5]; + inputSampleL += dML[5]; + inputSampleL += dNL[5]; + inputSampleL += dOL[5]; + inputSampleL += dPL[5]; + inputSampleL += dQL[5]; + inputSampleL += dRL[5]; + inputSampleL += dSL[5]; + inputSampleL += dTL[5]; + inputSampleL += dUL[5]; + inputSampleL += dVL[5]; + inputSampleL += dWL[5]; + inputSampleL += dXL[5]; + inputSampleL += dYL[5]; + inputSampleL += (dZL[5] * wetness); + + inputSampleL /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dZL[3])/3.0; //add feedback + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dCL[1] + dAL[5] + dAL[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dYR[1] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dXR[1] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dWR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dVR[1] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dUR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dTR[1] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dSR[1] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dRR[1] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dQR[1] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dPR[1] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dOR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dNR[1] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dLR[1] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dKR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dJR[1] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dIR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dHR[1] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dGR[1] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dFR[1] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dER[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dDR[1] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dCR[1] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dAR[1] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dBR[1] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[5] + dZR[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = drySampleR; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[1]+dAR[2])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[1]+dBR[2])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[1]+dCR[2])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[1]+dDR[2])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[1]+dER[2])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[1]+dFR[2])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[1]+dGR[2])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[1]+dHR[2])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[1]+dIR[2])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[1]+dJR[2])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[1]+dKR[2])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[1]+dLR[2])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1]+dMR[2])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[1]+dNR[2])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[1]+dOR[2])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[1]+dPR[2])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[1]+dQR[2])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[1]+dRR[2])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[1]+dSR[2])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[1]+dTR[2])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[1]+dUR[2])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[1]+dVR[2])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[1]+dWR[2])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[1]+dXR[2])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[1]+dYR[2])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dBR[4] * dryness); + inputSampleR += (dCR[4] * dryness); + inputSampleR += dDR[4]; + inputSampleR += dER[4]; + inputSampleR += dFR[4]; + inputSampleR += dGR[4]; + inputSampleR += dHR[4]; + inputSampleR += dIR[4]; + inputSampleR += dJR[4]; + inputSampleR += dKR[4]; + inputSampleR += dLR[4]; + inputSampleR += dMR[4]; + inputSampleR += dNR[4]; + inputSampleR += dOR[4]; + inputSampleR += dPR[4]; + inputSampleR += dQR[4]; + inputSampleR += dRR[4]; + inputSampleR += dSR[4]; + inputSampleR += dTR[4]; + inputSampleR += dUR[4]; + inputSampleR += dVR[4]; + inputSampleR += dWR[4]; + inputSampleR += dXR[4]; + inputSampleR += dYR[4]; + inputSampleR += (dZR[4] * wetness); + + inputSampleR += (dBR[5] * dryness); + inputSampleR += (dCR[5] * dryness); + inputSampleR += dDR[5]; + inputSampleR += dER[5]; + inputSampleR += dFR[5]; + inputSampleR += dGR[5]; + inputSampleR += dHR[5]; + inputSampleR += dIR[5]; + inputSampleR += dJR[5]; + inputSampleR += dKR[5]; + inputSampleR += dLR[5]; + inputSampleR += dMR[5]; + inputSampleR += dNR[5]; + inputSampleR += dOR[5]; + inputSampleR += dPR[5]; + inputSampleR += dQR[5]; + inputSampleR += dRR[5]; + inputSampleR += dSR[5]; + inputSampleR += dTR[5]; + inputSampleR += dUR[5]; + inputSampleR += dVR[5]; + inputSampleR += dWR[5]; + inputSampleR += dXR[5]; + inputSampleR += dYR[5]; + inputSampleR += (dZR[5] * wetness); + + inputSampleR /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dZR[3])/3.0; //add feedback + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dCR[1] + dAR[5] + dAR[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + bridgerectifier = fabs(inputSampleL); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleL > 0) inputSampleL -= bridgerectifier; + else inputSampleL += bridgerectifier; + inputSampleL /= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleR > 0) inputSampleR -= bridgerectifier; + else inputSampleR += bridgerectifier; + inputSampleR /= gain; + //here we apply the ADT2 'console on steroids' trick + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakL; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleL *= (1.0-wetness); + inputSampleL *= wetness; + inputSampleL += drySampleL; + //here we combine the tanks with the dry signal + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakR; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleR *= (1.0-wetness); + inputSampleR *= wetness; + inputSampleR += drySampleR; + //here we combine the tanks with the dry signal + + //begin 64 bit stereo floating point dither + int expon; frexp((double)inputSampleL, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleL += ((double(fpd)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + frexp((double)inputSampleR, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleR += ((double(fpd)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //end 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} diff --git a/plugins/WinVST/PocketVerbs/.vs/Console4Channel64/v14/.suo b/plugins/WinVST/PocketVerbs/.vs/Console4Channel64/v14/.suo new file mode 100755 index 0000000..777b846 Binary files /dev/null and b/plugins/WinVST/PocketVerbs/.vs/Console4Channel64/v14/.suo differ diff --git a/plugins/WinVST/PocketVerbs/.vs/VSTProject/v14/.suo b/plugins/WinVST/PocketVerbs/.vs/VSTProject/v14/.suo new file mode 100755 index 0000000..9bbdfac Binary files /dev/null and b/plugins/WinVST/PocketVerbs/.vs/VSTProject/v14/.suo differ diff --git a/plugins/WinVST/PocketVerbs/PocketVerbs.cpp b/plugins/WinVST/PocketVerbs/PocketVerbs.cpp new file mode 100755 index 0000000..4426e4b --- /dev/null +++ b/plugins/WinVST/PocketVerbs/PocketVerbs.cpp @@ -0,0 +1,325 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#include "PocketVerbs.h" +#endif + +AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new PocketVerbs(audioMaster);} + +PocketVerbs::PocketVerbs(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 0.0; + B = 0.5; + C = 0.0; + D = 0.5; + + for(count = 0; count < 6; count++) {dAL[count] = 0.0; dBL[count] = 0.0; dCL[count] = 0.0; dDL[count] = 0.0; dEL[count] = 0.0; + dFL[count] = 0.0; dGL[count] = 0.0; dHL[count] = 0.0; dIL[count] = 0.0; dJL[count] = 0.0; dKL[count] = 0.0; dLL[count] = 0.0; + dML[count] = 0.0; dNL[count] = 0.0; dOL[count] = 0.0; dPL[count] = 0.0; dQL[count] = 0.0; dRL[count] = 0.0; dSL[count] = 0.0; + dTL[count] = 0.0; dUL[count] = 0.0; dVL[count] = 0.0; dWL[count] = 0.0; dXL[count] = 0.0; dYL[count] = 0.0; dZL[count] = 0.0;} + + for(count = 0; count < 15149; count++) {aAL[count] = 0.0;} + for(count = 0; count < 15149; count++) {oAL[count] = 0.0;} + for(count = 0; count < 14617; count++) {aBL[count] = 0.0;} + for(count = 0; count < 14617; count++) {oBL[count] = 0.0;} + for(count = 0; count < 14357; count++) {aCL[count] = 0.0;} + for(count = 0; count < 14357; count++) {oCL[count] = 0.0;} + for(count = 0; count < 13817; count++) {aDL[count] = 0.0;} + for(count = 0; count < 13817; count++) {oDL[count] = 0.0;} + for(count = 0; count < 13561; count++) {aEL[count] = 0.0;} + for(count = 0; count < 13561; count++) {oEL[count] = 0.0;} + for(count = 0; count < 13045; count++) {aFL[count] = 0.0;} + for(count = 0; count < 13045; count++) {oFL[count] = 0.0;} + for(count = 0; count < 11965; count++) {aGL[count] = 0.0;} + for(count = 0; count < 11965; count++) {oGL[count] = 0.0;} + for(count = 0; count < 11129; count++) {aHL[count] = 0.0;} + for(count = 0; count < 11129; count++) {oHL[count] = 0.0;} + for(count = 0; count < 10597; count++) {aIL[count] = 0.0;} + for(count = 0; count < 10597; count++) {oIL[count] = 0.0;} + for(count = 0; count < 9809; count++) {aJL[count] = 0.0;} + for(count = 0; count < 9809; count++) {oJL[count] = 0.0;} + for(count = 0; count < 9521; count++) {aKL[count] = 0.0;} + for(count = 0; count < 9521; count++) {oKL[count] = 0.0;} + for(count = 0; count < 8981; count++) {aLL[count] = 0.0;} + for(count = 0; count < 8981; count++) {oLL[count] = 0.0;} + for(count = 0; count < 8785; count++) {aML[count] = 0.0;} + for(count = 0; count < 8785; count++) {oML[count] = 0.0;} + for(count = 0; count < 8461; count++) {aNL[count] = 0.0;} + for(count = 0; count < 8461; count++) {oNL[count] = 0.0;} + for(count = 0; count < 8309; count++) {aOL[count] = 0.0;} + for(count = 0; count < 8309; count++) {oOL[count] = 0.0;} + for(count = 0; count < 7981; count++) {aPL[count] = 0.0;} + for(count = 0; count < 7981; count++) {oPL[count] = 0.0;} + for(count = 0; count < 7321; count++) {aQL[count] = 0.0;} + for(count = 0; count < 7321; count++) {oQL[count] = 0.0;} + for(count = 0; count < 6817; count++) {aRL[count] = 0.0;} + for(count = 0; count < 6817; count++) {oRL[count] = 0.0;} + for(count = 0; count < 6505; count++) {aSL[count] = 0.0;} + for(count = 0; count < 6505; count++) {oSL[count] = 0.0;} + for(count = 0; count < 6001; count++) {aTL[count] = 0.0;} + for(count = 0; count < 6001; count++) {oTL[count] = 0.0;} + for(count = 0; count < 5837; count++) {aUL[count] = 0.0;} + for(count = 0; count < 5837; count++) {oUL[count] = 0.0;} + for(count = 0; count < 5501; count++) {aVL[count] = 0.0;} + for(count = 0; count < 5501; count++) {oVL[count] = 0.0;} + for(count = 0; count < 5009; count++) {aWL[count] = 0.0;} + for(count = 0; count < 5009; count++) {oWL[count] = 0.0;} + for(count = 0; count < 4849; count++) {aXL[count] = 0.0;} + for(count = 0; count < 4849; count++) {oXL[count] = 0.0;} + for(count = 0; count < 4295; count++) {aYL[count] = 0.0;} + for(count = 0; count < 4295; count++) {oYL[count] = 0.0;} + for(count = 0; count < 4179; count++) {aZL[count] = 0.0;} + for(count = 0; count < 4179; count++) {oZL[count] = 0.0;} + + for(count = 0; count < 6; count++) {dAR[count] = 0.0; dBR[count] = 0.0; dCR[count] = 0.0; dDR[count] = 0.0; dER[count] = 0.0; + dFR[count] = 0.0; dGR[count] = 0.0; dHR[count] = 0.0; dIR[count] = 0.0; dJR[count] = 0.0; dKR[count] = 0.0; dLR[count] = 0.0; + dMR[count] = 0.0; dNR[count] = 0.0; dOR[count] = 0.0; dPR[count] = 0.0; dQR[count] = 0.0; dRR[count] = 0.0; dSR[count] = 0.0; + dTR[count] = 0.0; dUR[count] = 0.0; dVR[count] = 0.0; dWR[count] = 0.0; dXR[count] = 0.0; dYR[count] = 0.0; dZR[count] = 0.0;} + + for(count = 0; count < 15149; count++) {aAR[count] = 0.0;} + for(count = 0; count < 15149; count++) {oAR[count] = 0.0;} + for(count = 0; count < 14617; count++) {aBR[count] = 0.0;} + for(count = 0; count < 14617; count++) {oBR[count] = 0.0;} + for(count = 0; count < 14357; count++) {aCR[count] = 0.0;} + for(count = 0; count < 14357; count++) {oCR[count] = 0.0;} + for(count = 0; count < 13817; count++) {aDR[count] = 0.0;} + for(count = 0; count < 13817; count++) {oDR[count] = 0.0;} + for(count = 0; count < 13561; count++) {aER[count] = 0.0;} + for(count = 0; count < 13561; count++) {oER[count] = 0.0;} + for(count = 0; count < 13045; count++) {aFR[count] = 0.0;} + for(count = 0; count < 13045; count++) {oFR[count] = 0.0;} + for(count = 0; count < 11965; count++) {aGR[count] = 0.0;} + for(count = 0; count < 11965; count++) {oGR[count] = 0.0;} + for(count = 0; count < 11129; count++) {aHR[count] = 0.0;} + for(count = 0; count < 11129; count++) {oHR[count] = 0.0;} + for(count = 0; count < 10597; count++) {aIR[count] = 0.0;} + for(count = 0; count < 10597; count++) {oIR[count] = 0.0;} + for(count = 0; count < 9809; count++) {aJR[count] = 0.0;} + for(count = 0; count < 9809; count++) {oJR[count] = 0.0;} + for(count = 0; count < 9521; count++) {aKR[count] = 0.0;} + for(count = 0; count < 9521; count++) {oKR[count] = 0.0;} + for(count = 0; count < 8981; count++) {aLR[count] = 0.0;} + for(count = 0; count < 8981; count++) {oLR[count] = 0.0;} + for(count = 0; count < 8785; count++) {aMR[count] = 0.0;} + for(count = 0; count < 8785; count++) {oMR[count] = 0.0;} + for(count = 0; count < 8461; count++) {aNR[count] = 0.0;} + for(count = 0; count < 8461; count++) {oNR[count] = 0.0;} + for(count = 0; count < 8309; count++) {aOR[count] = 0.0;} + for(count = 0; count < 8309; count++) {oOR[count] = 0.0;} + for(count = 0; count < 7981; count++) {aPR[count] = 0.0;} + for(count = 0; count < 7981; count++) {oPR[count] = 0.0;} + for(count = 0; count < 7321; count++) {aQR[count] = 0.0;} + for(count = 0; count < 7321; count++) {oQR[count] = 0.0;} + for(count = 0; count < 6817; count++) {aRR[count] = 0.0;} + for(count = 0; count < 6817; count++) {oRR[count] = 0.0;} + for(count = 0; count < 6505; count++) {aSR[count] = 0.0;} + for(count = 0; count < 6505; count++) {oSR[count] = 0.0;} + for(count = 0; count < 6001; count++) {aTR[count] = 0.0;} + for(count = 0; count < 6001; count++) {oTR[count] = 0.0;} + for(count = 0; count < 5837; count++) {aUR[count] = 0.0;} + for(count = 0; count < 5837; count++) {oUR[count] = 0.0;} + for(count = 0; count < 5501; count++) {aVR[count] = 0.0;} + for(count = 0; count < 5501; count++) {oVR[count] = 0.0;} + for(count = 0; count < 5009; count++) {aWR[count] = 0.0;} + for(count = 0; count < 5009; count++) {oWR[count] = 0.0;} + for(count = 0; count < 4849; count++) {aXR[count] = 0.0;} + for(count = 0; count < 4849; count++) {oXR[count] = 0.0;} + for(count = 0; count < 4295; count++) {aYR[count] = 0.0;} + for(count = 0; count < 4295; count++) {oYR[count] = 0.0;} + for(count = 0; count < 4179; count++) {aZR[count] = 0.0;} + for(count = 0; count < 4179; count++) {oZR[count] = 0.0;} + + outAL = 1; alpAL = 1; + outBL = 1; alpBL = 1; + outCL = 1; alpCL = 1; + outDL = 1; alpDL = 1; + outEL = 1; alpEL = 1; + outFL = 1; alpFL = 1; + outGL = 1; alpGL = 1; + outHL = 1; alpHL = 1; + outIL = 1; alpIL = 1; + outJL = 1; alpJL = 1; + outKL = 1; alpKL = 1; + outLL = 1; alpLL = 1; + outML = 1; alpML = 1; + outNL = 1; alpNL = 1; + outOL = 1; alpOL = 1; + outPL = 1; alpPL = 1; + outQL = 1; alpQL = 1; + outRL = 1; alpRL = 1; + outSL = 1; alpSL = 1; + outTL = 1; alpTL = 1; + outUL = 1; alpUL = 1; + outVL = 1; alpVL = 1; + outWL = 1; alpWL = 1; + outXL = 1; alpXL = 1; + outYL = 1; alpYL = 1; + outZL = 1; alpZL = 1; + + outAR = 1; alpAR = 1; delayA = 4; maxdelayA = 7573; + outBR = 1; alpBR = 1; delayB = 4; maxdelayB = 7307; + outCR = 1; alpCR = 1; delayC = 4; maxdelayC = 7177; + outDR = 1; alpDR = 1; delayD = 4; maxdelayD = 6907; + outER = 1; alpER = 1; delayE = 4; maxdelayE = 6779; + outFR = 1; alpFR = 1; delayF = 4; maxdelayF = 6521; + outGR = 1; alpGR = 1; delayG = 4; maxdelayG = 5981; + outHR = 1; alpHR = 1; delayH = 4; maxdelayH = 5563; + outIR = 1; alpIR = 1; delayI = 4; maxdelayI = 5297; + outJR = 1; alpJR = 1; delayJ = 4; maxdelayJ = 4903; + outKR = 1; alpKR = 1; delayK = 4; maxdelayK = 4759; + outLR = 1; alpLR = 1; delayL = 4; maxdelayL = 4489; + outMR = 1; alpMR = 1; delayM = 4; maxdelayM = 4391; + outNR = 1; alpNR = 1; delayN = 4; maxdelayN = 4229; + outOR = 1; alpOR = 1; delayO = 4; maxdelayO = 4153; + outPR = 1; alpPR = 1; delayP = 4; maxdelayP = 3989; + outQR = 1; alpQR = 1; delayQ = 4; maxdelayQ = 3659; + outRR = 1; alpRR = 1; delayR = 4; maxdelayR = 3407; + outSR = 1; alpSR = 1; delayS = 4; maxdelayS = 3251; + outTR = 1; alpTR = 1; delayT = 4; maxdelayT = 2999; + outUR = 1; alpUR = 1; delayU = 4; maxdelayU = 2917; + outVR = 1; alpVR = 1; delayV = 4; maxdelayV = 2749; + outWR = 1; alpWR = 1; delayW = 4; maxdelayW = 2503; + outXR = 1; alpXR = 1; delayX = 4; maxdelayX = 2423; + outYR = 1; alpYR = 1; delayY = 4; maxdelayY = 2146; + outZR = 1; alpZR = 1; delayZ = 4; maxdelayZ = 2088; + + savedRoomsize = -1.0; //force update to begin + countdown = -1; + peakL = 1.0; + peakR = 1.0; + fpd = 17; + //this is reset: values being initialized only once. Startup values, whatever they are. + + _canDo.insert("plugAsChannelInsert"); // plug-in can be used as a channel insert effect. + _canDo.insert("plugAsSend"); // plug-in can be used as a send effect. + _canDo.insert("x2in2out"); + setNumInputs(kNumInputs); + setNumOutputs(kNumOutputs); + setUniqueID(kUniqueId); + canProcessReplacing(); // supports output replacing + canDoubleReplacing(); // supports double precision processing + programsAreChunks(true); + vst_strncpy (_programName, "Default", kVstMaxProgNameLen); // default program name +} + +PocketVerbs::~PocketVerbs() {} +VstInt32 PocketVerbs::getVendorVersion () {return 1000;} +void PocketVerbs::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void PocketVerbs::getProgramName(char *name) {vst_strncpy (name, _programName, kVstMaxProgNameLen);} +//airwindows likes to ignore this stuff. Make your own programs, and make a different plugin rather than +//trying to do versioning and preventing people from using older versions. Maybe they like the old one! + +static float pinParameter(float data) +{ + if (data < 0.0f) return 0.0f; + if (data > 1.0f) return 1.0f; + return data; +} + +VstInt32 PocketVerbs::getChunk (void** data, bool isPreset) +{ + float *chunkData = (float *)calloc(kNumParameters, sizeof(float)); + chunkData[0] = A; + chunkData[1] = B; + chunkData[2] = C; + chunkData[3] = D; + /* Note: The way this is set up, it will break if you manage to save settings on an Intel + machine and load them on a PPC Mac. However, it's fine if you stick to the machine you + started with. */ + + *data = chunkData; + return kNumParameters * sizeof(float); +} + +VstInt32 PocketVerbs::setChunk (void* data, VstInt32 byteSize, bool isPreset) +{ + float *chunkData = (float *)data; + A = pinParameter(chunkData[0]); + B = pinParameter(chunkData[1]); + C = pinParameter(chunkData[2]); + D = pinParameter(chunkData[3]); + /* We're ignoring byteSize as we found it to be a filthy liar */ + + /* calculate any other fields you need here - you could copy in + code from setParameter() here. */ + return 0; +} + +void PocketVerbs::setParameter(VstInt32 index, float value) { + switch (index) { + case kParamA: A = value; break; + case kParamB: B = value; break; + case kParamC: C = value; break; + case kParamD: D = value; break; + default: throw; // unknown parameter, shouldn't happen! + } +} + +float PocketVerbs::getParameter(VstInt32 index) { + switch (index) { + case kParamA: return A; break; + case kParamB: return B; break; + case kParamC: return C; break; + case kParamD: return D; break; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void PocketVerbs::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Type", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Size", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "Gating", kVstMaxParamStrLen); break; + case kParamD: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this is our labels for displaying in the VST host +} + +void PocketVerbs::getParameterDisplay(VstInt32 index, char *text) { + switch (index) { + case kParamA: switch((VstInt32)( A * 5.999 )) //0 to almost edge of # of params + { case 0: vst_strncpy (text, "Chamber", kVstMaxParamStrLen); break; + case 1: vst_strncpy (text, "Spring", kVstMaxParamStrLen); break; + case 2: vst_strncpy (text, "Tiled", kVstMaxParamStrLen); break; + case 3: vst_strncpy (text, "Room", kVstMaxParamStrLen); break; + case 4: vst_strncpy (text, "Stretch", kVstMaxParamStrLen); break; + case 5: vst_strncpy (text, "Zarathu", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } break; + case kParamB: float2string (B, text, kVstMaxParamStrLen); break; + case kParamC: float2string (C, text, kVstMaxParamStrLen); break; + case kParamD: float2string (D, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void PocketVerbs::getParameterLabel(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 PocketVerbs::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool PocketVerbs::getEffectName(char* name) { + vst_strncpy(name, "PocketVerbs", kVstMaxProductStrLen); return true; +} + +VstPlugCategory PocketVerbs::getPlugCategory() {return kPlugCategEffect;} + +bool PocketVerbs::getProductString(char* text) { + vst_strncpy (text, "airwindows PocketVerbs", kVstMaxProductStrLen); return true; +} + +bool PocketVerbs::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} diff --git a/plugins/WinVST/PocketVerbs/PocketVerbs.h b/plugins/WinVST/PocketVerbs/PocketVerbs.h new file mode 100755 index 0000000..7feaf8e --- /dev/null +++ b/plugins/WinVST/PocketVerbs/PocketVerbs.h @@ -0,0 +1,295 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) 2011 __MyCompanyName__, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#define __PocketVerbs_H + +#ifndef __audioeffect__ +#include "audioeffectx.h" +#endif + +#include +#include +#include + +enum { + kParamA = 0, + kParamB = 1, + kParamC = 2, + kParamD = 3, + kNumParameters = 4 +}; // + +const int kNumPrograms = 0; +const int kNumInputs = 2; +const int kNumOutputs = 2; +const unsigned long kUniqueId = 'pkvb'; //Change this to what the AU identity is! + +class PocketVerbs : + public AudioEffectX +{ +public: + PocketVerbs(audioMasterCallback audioMaster); + ~PocketVerbs(); + virtual bool getEffectName(char* name); // The plug-in name + virtual VstPlugCategory getPlugCategory(); // The general category for the plug-in + virtual bool getProductString(char* text); // This is a unique plug-in string provided by Steinberg + virtual bool getVendorString(char* text); // Vendor info + virtual VstInt32 getVendorVersion(); // Version number + virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames); + virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames); + virtual void getProgramName(char *name); // read the name from the host + virtual void setProgramName(char *name); // changes the name of the preset displayed in the host + virtual VstInt32 getChunk (void** data, bool isPreset); + virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset); + virtual float getParameter(VstInt32 index); // get the parameter value at the specified index + virtual void setParameter(VstInt32 index, float value); // set the parameter at index to value + virtual void getParameterLabel(VstInt32 index, char *text); // label for the parameter (eg dB) + virtual void getParameterName(VstInt32 index, char *text); // name of the parameter + virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value + virtual VstInt32 canDo(char *text); +private: + char _programName[kVstMaxProgNameLen + 1]; + std::set< std::string > _canDo; + + int count; + + + + double dAR[7]; + double dBR[7]; + double dCR[7]; + double dDR[7]; + double dER[7]; + double dFR[7]; + double dGR[7]; + double dHR[7]; + double dIR[7]; + double dJR[7]; + double dKR[7]; + double dLR[7]; + double dMR[7]; + double dNR[7]; + double dOR[7]; + double dPR[7]; + double dQR[7]; + double dRR[7]; + double dSR[7]; + double dTR[7]; + double dUR[7]; + double dVR[7]; + double dWR[7]; + double dXR[7]; + double dYR[7]; + double dZR[7]; + + double aAR[15150]; + double aBR[14618]; + double aCR[14358]; + double aDR[13818]; + double aER[13562]; + double aFR[13046]; + double aGR[11966]; + double aHR[11130]; + double aIR[10598]; + double aJR[9810]; + double aKR[9522]; + double aLR[8982]; + double aMR[8786]; + double aNR[8462]; + double aOR[8310]; + double aPR[7982]; + double aQR[7322]; + double aRR[6818]; + double aSR[6506]; + double aTR[6002]; + double aUR[5838]; + double aVR[5502]; + double aWR[5010]; + double aXR[4850]; + double aYR[4296]; + double aZR[4180]; + + double oAR[15150]; + double oBR[14618]; + double oCR[14358]; + double oDR[13818]; + double oER[13562]; + double oFR[13046]; + double oGR[11966]; + double oHR[11130]; + double oIR[10598]; + double oJR[9810]; + double oKR[9522]; + double oLR[8982]; + double oMR[8786]; + double oNR[8462]; + double oOR[8310]; + double oPR[7982]; + double oQR[7322]; + double oRR[6818]; + double oSR[6506]; + double oTR[6002]; + double oUR[5838]; + double oVR[5502]; + double oWR[5010]; + double oXR[4850]; + double oYR[4296]; + double oZR[4180]; + + double dAL[7]; + double dBL[7]; + double dCL[7]; + double dDL[7]; + double dEL[7]; + double dFL[7]; + double dGL[7]; + double dHL[7]; + double dIL[7]; + double dJL[7]; + double dKL[7]; + double dLL[7]; + double dML[7]; + double dNL[7]; + double dOL[7]; + double dPL[7]; + double dQL[7]; + double dRL[7]; + double dSL[7]; + double dTL[7]; + double dUL[7]; + double dVL[7]; + double dWL[7]; + double dXL[7]; + double dYL[7]; + double dZL[7]; + + double aAL[15150]; + double aBL[14618]; + double aCL[14358]; + double aDL[13818]; + double aEL[13562]; + double aFL[13046]; + double aGL[11966]; + double aHL[11130]; + double aIL[10598]; + double aJL[9810]; + double aKL[9522]; + double aLL[8982]; + double aML[8786]; + double aNL[8462]; + double aOL[8310]; + double aPL[7982]; + double aQL[7322]; + double aRL[6818]; + double aSL[6506]; + double aTL[6002]; + double aUL[5838]; + double aVL[5502]; + double aWL[5010]; + double aXL[4850]; + double aYL[4296]; + double aZL[4180]; + + double oAL[15150]; + double oBL[14618]; + double oCL[14358]; + double oDL[13818]; + double oEL[13562]; + double oFL[13046]; + double oGL[11966]; + double oHL[11130]; + double oIL[10598]; + double oJL[9810]; + double oKL[9522]; + double oLL[8982]; + double oML[8786]; + double oNL[8462]; + double oOL[8310]; + double oPL[7982]; + double oQL[7322]; + double oRL[6818]; + double oSL[6506]; + double oTL[6002]; + double oUL[5838]; + double oVL[5502]; + double oWL[5010]; + double oXL[4850]; + double oYL[4296]; + double oZL[4180]; + + + + int outAL, alpAL; + int outBL, alpBL; + int outCL, alpCL; + int outDL, alpDL; + int outEL, alpEL; + int outFL, alpFL; + int outGL, alpGL; + int outHL, alpHL; + int outIL, alpIL; + int outJL, alpJL; + int outKL, alpKL; + int outLL, alpLL; + int outML, alpML; + int outNL, alpNL; + int outOL, alpOL; + int outPL, alpPL; + int outQL, alpQL; + int outRL, alpRL; + int outSL, alpSL; + int outTL, alpTL; + int outUL, alpUL; + int outVL, alpVL; + int outWL, alpWL; + int outXL, alpXL; + int outYL, alpYL; + int outZL, alpZL; + + int outAR, alpAR, maxdelayA, delayA; + int outBR, alpBR, maxdelayB, delayB; + int outCR, alpCR, maxdelayC, delayC; + int outDR, alpDR, maxdelayD, delayD; + int outER, alpER, maxdelayE, delayE; + int outFR, alpFR, maxdelayF, delayF; + int outGR, alpGR, maxdelayG, delayG; + int outHR, alpHR, maxdelayH, delayH; + int outIR, alpIR, maxdelayI, delayI; + int outJR, alpJR, maxdelayJ, delayJ; + int outKR, alpKR, maxdelayK, delayK; + int outLR, alpLR, maxdelayL, delayL; + int outMR, alpMR, maxdelayM, delayM; + int outNR, alpNR, maxdelayN, delayN; + int outOR, alpOR, maxdelayO, delayO; + int outPR, alpPR, maxdelayP, delayP; + int outQR, alpQR, maxdelayQ, delayQ; + int outRR, alpRR, maxdelayR, delayR; + int outSR, alpSR, maxdelayS, delayS; + int outTR, alpTR, maxdelayT, delayT; + int outUR, alpUR, maxdelayU, delayU; + int outVR, alpVR, maxdelayV, delayV; + int outWR, alpWR, maxdelayW, delayW; + int outXR, alpXR, maxdelayX, delayX; + int outYR, alpYR, maxdelayY, delayY; + int outZR, alpZR, maxdelayZ, delayZ; + + double savedRoomsize; + int countdown; + double peakL; + double peakR; + + uint32_t fpd; + //default stuff + + float A; + float B; + float C; + float D; + +}; + +#endif diff --git a/plugins/WinVST/PocketVerbs/PocketVerbsProc.cpp b/plugins/WinVST/PocketVerbs/PocketVerbsProc.cpp new file mode 100755 index 0000000..4ea8f51 --- /dev/null +++ b/plugins/WinVST/PocketVerbs/PocketVerbsProc.cpp @@ -0,0 +1,18358 @@ +/* ======================================== + * PocketVerbs - PocketVerbs.h + * Copyright (c) 2016 airwindows, All rights reserved + * ======================================== */ + +#ifndef __PocketVerbs_H +#include "PocketVerbs.h" +#endif + +void PocketVerbs::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + int verbtype = (VstInt32)( A * 5.999 )+1; + + double roomsize = (pow(B,2)*1.9)+0.1; + + double release = 0.00008 * pow(C,3); + if (release == 0.0) {peakL = 1.0; peakR = 1.0;} + double wetnesstarget = D; + double dryness = (1.0 - wetnesstarget); + //verbs use base wetness value internally + double wetness = wetnesstarget; + double constallpass = 0.618033988749894848204586; //golden ratio! + int allpasstemp; + int count; + int max = 70; //biggest divisor to test primes against + double bridgerectifier; + double gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive + //used as an aux, saturates when fed high levels + + //remap values to primes input number in question is 'i' + //max is the largest prime we care about- HF interactions more interesting than the big numbers + //pushing values larger and larger until we have a result + //for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}} + + if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAL; count < 15149; count++) {aAL[count] = 0.0;} + for(count = outAL; count < 15149; count++) {oAL[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBL; count < 14617; count++) {aBL[count] = 0.0;} + for(count = outBL; count < 14617; count++) {oBL[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCL; count < 14357; count++) {aCL[count] = 0.0;} + for(count = outCL; count < 14357; count++) {oCL[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDL; count < 13817; count++) {aDL[count] = 0.0;} + for(count = outDL; count < 13817; count++) {oDL[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpEL; count < 13561; count++) {aEL[count] = 0.0;} + for(count = outEL; count < 13561; count++) {oEL[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFL; count < 13045; count++) {aFL[count] = 0.0;} + for(count = outFL; count < 13045; count++) {oFL[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGL; count < 11965; count++) {aGL[count] = 0.0;} + for(count = outGL; count < 11965; count++) {oGL[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHL; count < 11129; count++) {aHL[count] = 0.0;} + for(count = outHL; count < 11129; count++) {oHL[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIL; count < 10597; count++) {aIL[count] = 0.0;} + for(count = outIL; count < 10597; count++) {oIL[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJL; count < 9809; count++) {aJL[count] = 0.0;} + for(count = outJL; count < 9809; count++) {oJL[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKL; count < 9521; count++) {aKL[count] = 0.0;} + for(count = outKL; count < 9521; count++) {oKL[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLL; count < 8981; count++) {aLL[count] = 0.0;} + for(count = outLL; count < 8981; count++) {oLL[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpML; count < 8785; count++) {aML[count] = 0.0;} + for(count = outML; count < 8785; count++) {oML[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNL; count < 8461; count++) {aNL[count] = 0.0;} + for(count = outNL; count < 8461; count++) {oNL[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOL; count < 8309; count++) {aOL[count] = 0.0;} + for(count = outOL; count < 8309; count++) {oOL[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPL; count < 7981; count++) {aPL[count] = 0.0;} + for(count = outPL; count < 7981; count++) {oPL[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQL; count < 7321; count++) {aQL[count] = 0.0;} + for(count = outQL; count < 7321; count++) {oQL[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRL; count < 6817; count++) {aRL[count] = 0.0;} + for(count = outRL; count < 6817; count++) {oRL[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSL; count < 6505; count++) {aSL[count] = 0.0;} + for(count = outSL; count < 6505; count++) {oSL[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTL; count < 6001; count++) {aTL[count] = 0.0;} + for(count = outTL; count < 6001; count++) {oTL[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUL; count < 5837; count++) {aUL[count] = 0.0;} + for(count = outUL; count < 5837; count++) {oUL[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVL; count < 5501; count++) {aVL[count] = 0.0;} + for(count = outVL; count < 5501; count++) {oVL[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWL; count < 5009; count++) {aWL[count] = 0.0;} + for(count = outWL; count < 5009; count++) {oWL[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXL; count < 4849; count++) {aXL[count] = 0.0;} + for(count = outXL; count < 4849; count++) {oXL[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYL; count < 4295; count++) {aYL[count] = 0.0;} + for(count = outYL; count < 4295; count++) {oYL[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZL; count < 4179; count++) {aZL[count] = 0.0;} + for(count = outZL; count < 4179; count++) {oZL[count] = 0.0;} + break; + } //end of switch statement + //countdown--; we are doing this after the second one + } + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAR; count < 15149; count++) {aAR[count] = 0.0;} + for(count = outAR; count < 15149; count++) {oAR[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBR; count < 14617; count++) {aBR[count] = 0.0;} + for(count = outBR; count < 14617; count++) {oBR[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCR; count < 14357; count++) {aCR[count] = 0.0;} + for(count = outCR; count < 14357; count++) {oCR[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDR; count < 13817; count++) {aDR[count] = 0.0;} + for(count = outDR; count < 13817; count++) {oDR[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpER; count < 13561; count++) {aER[count] = 0.0;} + for(count = outER; count < 13561; count++) {oER[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFR; count < 13045; count++) {aFR[count] = 0.0;} + for(count = outFR; count < 13045; count++) {oFR[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGR; count < 11965; count++) {aGR[count] = 0.0;} + for(count = outGR; count < 11965; count++) {oGR[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHR; count < 11129; count++) {aHR[count] = 0.0;} + for(count = outHR; count < 11129; count++) {oHR[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIR; count < 10597; count++) {aIR[count] = 0.0;} + for(count = outIR; count < 10597; count++) {oIR[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJR; count < 9809; count++) {aJR[count] = 0.0;} + for(count = outJR; count < 9809; count++) {oJR[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKR; count < 9521; count++) {aKR[count] = 0.0;} + for(count = outKR; count < 9521; count++) {oKR[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLR; count < 8981; count++) {aLR[count] = 0.0;} + for(count = outLR; count < 8981; count++) {oLR[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpMR; count < 8785; count++) {aMR[count] = 0.0;} + for(count = outMR; count < 8785; count++) {oMR[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNR; count < 8461; count++) {aNR[count] = 0.0;} + for(count = outNR; count < 8461; count++) {oNR[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOR; count < 8309; count++) {aOR[count] = 0.0;} + for(count = outOR; count < 8309; count++) {oOR[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPR; count < 7981; count++) {aPR[count] = 0.0;} + for(count = outPR; count < 7981; count++) {oPR[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQR; count < 7321; count++) {aQR[count] = 0.0;} + for(count = outQR; count < 7321; count++) {oQR[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRR; count < 6817; count++) {aRR[count] = 0.0;} + for(count = outRR; count < 6817; count++) {oRR[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSR; count < 6505; count++) {aSR[count] = 0.0;} + for(count = outSR; count < 6505; count++) {oSR[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTR; count < 6001; count++) {aTR[count] = 0.0;} + for(count = outTR; count < 6001; count++) {oTR[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUR; count < 5837; count++) {aUR[count] = 0.0;} + for(count = outUR; count < 5837; count++) {oUR[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVR; count < 5501; count++) {aVR[count] = 0.0;} + for(count = outVR; count < 5501; count++) {oVR[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWR; count < 5009; count++) {aWR[count] = 0.0;} + for(count = outWR; count < 5009; count++) {oWR[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXR; count < 4849; count++) {aXR[count] = 0.0;} + for(count = outXR; count < 4849; count++) {oXR[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYR; count < 4295; count++) {aYR[count] = 0.0;} + for(count = outYR; count < 4295; count++) {oYR[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZR; count < 4179; count++) {aZR[count] = 0.0;} + for(count = outZR; count < 4179; count++) {oZR[count] = 0.0;} + break; + } //end of switch statement + countdown--; //every buffer we'll do one of the recalculations for prime buffer sizes + } + + + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + + if (fabs(inputSampleL)<1.18e-37) inputSampleL = fpd * 1.18e-37; + if (fabs(inputSampleR)<1.18e-37) inputSampleR = fpd * 1.18e-37; + + long double drySampleL = inputSampleL; + long double drySampleR = inputSampleR; + + peakL -= release; + if (peakL < fabs(inputSampleL*2.0)) peakL = fabs(inputSampleL*2.0); + if (peakL > 1.0) peakL = 1.0; + peakR -= release; + if (peakR < fabs(inputSampleR*2.0)) peakR = fabs(inputSampleR*2.0); + if (peakR > 1.0) peakR = 1.0; + //chase the maximum signal to incorporate the wetter/louder behavior + //boost for more extreme effect when in use, cap it + + inputSampleL *= gain; + bridgerectifier = fabs(inputSampleL); + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + inputSampleR *= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + //here we apply the ADT2 console-on-steroids trick + + + + + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dYL[1] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dXL[1] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dWL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dVL[1] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dUL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dTL[1] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dSL[1] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dRL[1] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dQL[1] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dPL[1] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dOL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dNL[1] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dLL[1] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dKL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dJL[1] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dIL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dHL[1] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dGL[1] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dFL[1] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dEL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dDL[1] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dCL[1] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dAL[1] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dBL[1] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[5] + dZL[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = drySampleL; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[1]+dAL[2])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[1]+dBL[2])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[1]+dCL[2])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[1]+dDL[2])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[1]+dEL[2])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[1]+dFL[2])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[1]+dGL[2])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[1]+dHL[2])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[1]+dIL[2])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[1]+dJL[2])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[1]+dKL[2])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[1]+dLL[2])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1]+dML[2])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[1]+dNL[2])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[1]+dOL[2])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[1]+dPL[2])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[1]+dQL[2])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[1]+dRL[2])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[1]+dSL[2])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[1]+dTL[2])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[1]+dUL[2])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[1]+dVL[2])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[1]+dWL[2])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[1]+dXL[2])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[1]+dYL[2])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dBL[4] * dryness); + inputSampleL += (dCL[4] * dryness); + inputSampleL += dDL[4]; + inputSampleL += dEL[4]; + inputSampleL += dFL[4]; + inputSampleL += dGL[4]; + inputSampleL += dHL[4]; + inputSampleL += dIL[4]; + inputSampleL += dJL[4]; + inputSampleL += dKL[4]; + inputSampleL += dLL[4]; + inputSampleL += dML[4]; + inputSampleL += dNL[4]; + inputSampleL += dOL[4]; + inputSampleL += dPL[4]; + inputSampleL += dQL[4]; + inputSampleL += dRL[4]; + inputSampleL += dSL[4]; + inputSampleL += dTL[4]; + inputSampleL += dUL[4]; + inputSampleL += dVL[4]; + inputSampleL += dWL[4]; + inputSampleL += dXL[4]; + inputSampleL += dYL[4]; + inputSampleL += (dZL[4] * wetness); + + inputSampleL += (dBL[5] * dryness); + inputSampleL += (dCL[5] * dryness); + inputSampleL += dDL[5]; + inputSampleL += dEL[5]; + inputSampleL += dFL[5]; + inputSampleL += dGL[5]; + inputSampleL += dHL[5]; + inputSampleL += dIL[5]; + inputSampleL += dJL[5]; + inputSampleL += dKL[5]; + inputSampleL += dLL[5]; + inputSampleL += dML[5]; + inputSampleL += dNL[5]; + inputSampleL += dOL[5]; + inputSampleL += dPL[5]; + inputSampleL += dQL[5]; + inputSampleL += dRL[5]; + inputSampleL += dSL[5]; + inputSampleL += dTL[5]; + inputSampleL += dUL[5]; + inputSampleL += dVL[5]; + inputSampleL += dWL[5]; + inputSampleL += dXL[5]; + inputSampleL += dYL[5]; + inputSampleL += (dZL[5] * wetness); + + inputSampleL /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dZL[3])/3.0; //add feedback + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dCL[1] + dAL[5] + dAL[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dYR[1] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dXR[1] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dWR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dVR[1] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dUR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dTR[1] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dSR[1] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dRR[1] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dQR[1] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dPR[1] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dOR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dNR[1] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dLR[1] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dKR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dJR[1] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dIR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dHR[1] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dGR[1] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dFR[1] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dER[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dDR[1] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dCR[1] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dAR[1] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dBR[1] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[5] + dZR[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = drySampleR; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[1]+dAR[2])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[1]+dBR[2])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[1]+dCR[2])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[1]+dDR[2])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[1]+dER[2])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[1]+dFR[2])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[1]+dGR[2])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[1]+dHR[2])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[1]+dIR[2])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[1]+dJR[2])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[1]+dKR[2])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[1]+dLR[2])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1]+dMR[2])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[1]+dNR[2])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[1]+dOR[2])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[1]+dPR[2])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[1]+dQR[2])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[1]+dRR[2])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[1]+dSR[2])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[1]+dTR[2])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[1]+dUR[2])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[1]+dVR[2])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[1]+dWR[2])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[1]+dXR[2])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[1]+dYR[2])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dBR[4] * dryness); + inputSampleR += (dCR[4] * dryness); + inputSampleR += dDR[4]; + inputSampleR += dER[4]; + inputSampleR += dFR[4]; + inputSampleR += dGR[4]; + inputSampleR += dHR[4]; + inputSampleR += dIR[4]; + inputSampleR += dJR[4]; + inputSampleR += dKR[4]; + inputSampleR += dLR[4]; + inputSampleR += dMR[4]; + inputSampleR += dNR[4]; + inputSampleR += dOR[4]; + inputSampleR += dPR[4]; + inputSampleR += dQR[4]; + inputSampleR += dRR[4]; + inputSampleR += dSR[4]; + inputSampleR += dTR[4]; + inputSampleR += dUR[4]; + inputSampleR += dVR[4]; + inputSampleR += dWR[4]; + inputSampleR += dXR[4]; + inputSampleR += dYR[4]; + inputSampleR += (dZR[4] * wetness); + + inputSampleR += (dBR[5] * dryness); + inputSampleR += (dCR[5] * dryness); + inputSampleR += dDR[5]; + inputSampleR += dER[5]; + inputSampleR += dFR[5]; + inputSampleR += dGR[5]; + inputSampleR += dHR[5]; + inputSampleR += dIR[5]; + inputSampleR += dJR[5]; + inputSampleR += dKR[5]; + inputSampleR += dLR[5]; + inputSampleR += dMR[5]; + inputSampleR += dNR[5]; + inputSampleR += dOR[5]; + inputSampleR += dPR[5]; + inputSampleR += dQR[5]; + inputSampleR += dRR[5]; + inputSampleR += dSR[5]; + inputSampleR += dTR[5]; + inputSampleR += dUR[5]; + inputSampleR += dVR[5]; + inputSampleR += dWR[5]; + inputSampleR += dXR[5]; + inputSampleR += dYR[5]; + inputSampleR += (dZR[5] * wetness); + + inputSampleR /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dZR[3])/3.0; //add feedback + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dCR[1] + dAR[5] + dAR[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + + bridgerectifier = fabs(inputSampleL); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleL > 0) inputSampleL -= bridgerectifier; + else inputSampleL += bridgerectifier; + inputSampleL /= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleR > 0) inputSampleR -= bridgerectifier; + else inputSampleR += bridgerectifier; + inputSampleR /= gain; + //here we apply the ADT2 'console on steroids' trick + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakL; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleL *= (1.0-wetness); + inputSampleL *= wetness; + inputSampleL += drySampleL; + //here we combine the tanks with the dry signal + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakR; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleR *= (1.0-wetness); + inputSampleR *= wetness; + inputSampleR += drySampleR; + //here we combine the tanks with the dry signal + + //begin 32 bit stereo floating point dither + int expon; frexpf((float)inputSampleL, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleL += ((double(fpd)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + frexpf((float)inputSampleR, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleR += ((double(fpd)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + //end 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} + +void PocketVerbs::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + int verbtype = (VstInt32)( A * 5.999 )+1; + + double roomsize = (pow(B,2)*1.9)+0.1; + + double release = 0.00008 * pow(C,3); + if (release == 0.0) {peakL = 1.0; peakR = 1.0;} + double wetnesstarget = D; + double dryness = (1.0 - wetnesstarget); + //verbs use base wetness value internally + double wetness = wetnesstarget; + double constallpass = 0.618033988749894848204586; //golden ratio! + int allpasstemp; + int count; + int max = 70; //biggest divisor to test primes against + double bridgerectifier; + double gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive + //used as an aux, saturates when fed high levels + + //remap values to primes input number in question is 'i' + //max is the largest prime we care about- HF interactions more interesting than the big numbers + //pushing values larger and larger until we have a result + //for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}} + + if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAL; count < 15149; count++) {aAL[count] = 0.0;} + for(count = outAL; count < 15149; count++) {oAL[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBL; count < 14617; count++) {aBL[count] = 0.0;} + for(count = outBL; count < 14617; count++) {oBL[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCL; count < 14357; count++) {aCL[count] = 0.0;} + for(count = outCL; count < 14357; count++) {oCL[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDL; count < 13817; count++) {aDL[count] = 0.0;} + for(count = outDL; count < 13817; count++) {oDL[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpEL; count < 13561; count++) {aEL[count] = 0.0;} + for(count = outEL; count < 13561; count++) {oEL[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFL; count < 13045; count++) {aFL[count] = 0.0;} + for(count = outFL; count < 13045; count++) {oFL[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGL; count < 11965; count++) {aGL[count] = 0.0;} + for(count = outGL; count < 11965; count++) {oGL[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHL; count < 11129; count++) {aHL[count] = 0.0;} + for(count = outHL; count < 11129; count++) {oHL[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIL; count < 10597; count++) {aIL[count] = 0.0;} + for(count = outIL; count < 10597; count++) {oIL[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJL; count < 9809; count++) {aJL[count] = 0.0;} + for(count = outJL; count < 9809; count++) {oJL[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKL; count < 9521; count++) {aKL[count] = 0.0;} + for(count = outKL; count < 9521; count++) {oKL[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLL; count < 8981; count++) {aLL[count] = 0.0;} + for(count = outLL; count < 8981; count++) {oLL[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpML; count < 8785; count++) {aML[count] = 0.0;} + for(count = outML; count < 8785; count++) {oML[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNL; count < 8461; count++) {aNL[count] = 0.0;} + for(count = outNL; count < 8461; count++) {oNL[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOL; count < 8309; count++) {aOL[count] = 0.0;} + for(count = outOL; count < 8309; count++) {oOL[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPL; count < 7981; count++) {aPL[count] = 0.0;} + for(count = outPL; count < 7981; count++) {oPL[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQL; count < 7321; count++) {aQL[count] = 0.0;} + for(count = outQL; count < 7321; count++) {oQL[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRL; count < 6817; count++) {aRL[count] = 0.0;} + for(count = outRL; count < 6817; count++) {oRL[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSL; count < 6505; count++) {aSL[count] = 0.0;} + for(count = outSL; count < 6505; count++) {oSL[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTL; count < 6001; count++) {aTL[count] = 0.0;} + for(count = outTL; count < 6001; count++) {oTL[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUL; count < 5837; count++) {aUL[count] = 0.0;} + for(count = outUL; count < 5837; count++) {oUL[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVL; count < 5501; count++) {aVL[count] = 0.0;} + for(count = outVL; count < 5501; count++) {oVL[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWL; count < 5009; count++) {aWL[count] = 0.0;} + for(count = outWL; count < 5009; count++) {oWL[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXL; count < 4849; count++) {aXL[count] = 0.0;} + for(count = outXL; count < 4849; count++) {oXL[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYL; count < 4295; count++) {aYL[count] = 0.0;} + for(count = outYL; count < 4295; count++) {oYL[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZL; count < 4179; count++) {aZL[count] = 0.0;} + for(count = outZL; count < 4179; count++) {oZL[count] = 0.0;} + break; + } //end of switch statement + //countdown--; we are doing this after the second one + } + + if (countdown > 0) {switch (countdown) + { + case 1: + delayA = (int(maxdelayA * roomsize)); + for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As + if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck + for(count = alpAR; count < 15149; count++) {aAR[count] = 0.0;} + for(count = outAR; count < 15149; count++) {oAR[count] = 0.0;} + break; + + case 2: + delayB = (int(maxdelayB * roomsize)); + for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs + if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck + for(count = alpBR; count < 14617; count++) {aBR[count] = 0.0;} + for(count = outBR; count < 14617; count++) {oBR[count] = 0.0;} + break; + + case 3: + delayC = (int(maxdelayC * roomsize)); + for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs + if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck + for(count = alpCR; count < 14357; count++) {aCR[count] = 0.0;} + for(count = outCR; count < 14357; count++) {oCR[count] = 0.0;} + break; + + case 4: + delayD = (int(maxdelayD * roomsize)); + for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds + if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck + for(count = alpDR; count < 13817; count++) {aDR[count] = 0.0;} + for(count = outDR; count < 13817; count++) {oDR[count] = 0.0;} + break; + + case 5: + delayE = (int(maxdelayE * roomsize)); + for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es + if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck + for(count = alpER; count < 13561; count++) {aER[count] = 0.0;} + for(count = outER; count < 13561; count++) {oER[count] = 0.0;} + break; + + case 6: + delayF = (int(maxdelayF * roomsize)); + for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs + if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck + for(count = alpFR; count < 13045; count++) {aFR[count] = 0.0;} + for(count = outFR; count < 13045; count++) {oFR[count] = 0.0;} + break; + + case 7: + delayG = (int(maxdelayG * roomsize)); + for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs + if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck + for(count = alpGR; count < 11965; count++) {aGR[count] = 0.0;} + for(count = outGR; count < 11965; count++) {oGR[count] = 0.0;} + break; + + case 8: + delayH = (int(maxdelayH * roomsize)); + for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs + if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck + for(count = alpHR; count < 11129; count++) {aHR[count] = 0.0;} + for(count = outHR; count < 11129; count++) {oHR[count] = 0.0;} + break; + + case 9: + delayI = (int(maxdelayI * roomsize)); + for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is + if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck + for(count = alpIR; count < 10597; count++) {aIR[count] = 0.0;} + for(count = outIR; count < 10597; count++) {oIR[count] = 0.0;} + break; + + case 10: + delayJ = (int(maxdelayJ * roomsize)); + for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js + if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck + for(count = alpJR; count < 9809; count++) {aJR[count] = 0.0;} + for(count = outJR; count < 9809; count++) {oJR[count] = 0.0;} + break; + + case 11: + delayK = (int(maxdelayK * roomsize)); + for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks + if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck + for(count = alpKR; count < 9521; count++) {aKR[count] = 0.0;} + for(count = outKR; count < 9521; count++) {oKR[count] = 0.0;} + break; + + case 12: + delayL = (int(maxdelayL * roomsize)); + for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls + if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck + for(count = alpLR; count < 8981; count++) {aLR[count] = 0.0;} + for(count = outLR; count < 8981; count++) {oLR[count] = 0.0;} + break; + + case 13: + delayM = (int(maxdelayM * roomsize)); + for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms + if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck + for(count = alpMR; count < 8785; count++) {aMR[count] = 0.0;} + for(count = outMR; count < 8785; count++) {oMR[count] = 0.0;} + break; + + case 14: + delayN = (int(maxdelayN * roomsize)); + for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns + if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck + for(count = alpNR; count < 8461; count++) {aNR[count] = 0.0;} + for(count = outNR; count < 8461; count++) {oNR[count] = 0.0;} + break; + + case 15: + delayO = (int(maxdelayO * roomsize)); + for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os + if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck + for(count = alpOR; count < 8309; count++) {aOR[count] = 0.0;} + for(count = outOR; count < 8309; count++) {oOR[count] = 0.0;} + break; + + case 16: + delayP = (int(maxdelayP * roomsize)); + for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps + if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck + for(count = alpPR; count < 7981; count++) {aPR[count] = 0.0;} + for(count = outPR; count < 7981; count++) {oPR[count] = 0.0;} + break; + + case 17: + delayQ = (int(maxdelayQ * roomsize)); + for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs + if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck + for(count = alpQR; count < 7321; count++) {aQR[count] = 0.0;} + for(count = outQR; count < 7321; count++) {oQR[count] = 0.0;} + break; + + case 18: + delayR = (int(maxdelayR * roomsize)); + for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs + if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck + for(count = alpRR; count < 6817; count++) {aRR[count] = 0.0;} + for(count = outRR; count < 6817; count++) {oRR[count] = 0.0;} + break; + + case 19: + delayS = (int(maxdelayS * roomsize)); + for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss + if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck + for(count = alpSR; count < 6505; count++) {aSR[count] = 0.0;} + for(count = outSR; count < 6505; count++) {oSR[count] = 0.0;} + break; + + case 20: + delayT = (int(maxdelayT * roomsize)); + for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts + if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck + for(count = alpTR; count < 6001; count++) {aTR[count] = 0.0;} + for(count = outTR; count < 6001; count++) {oTR[count] = 0.0;} + break; + + case 21: + delayU = (int(maxdelayU * roomsize)); + for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us + if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck + for(count = alpUR; count < 5837; count++) {aUR[count] = 0.0;} + for(count = outUR; count < 5837; count++) {oUR[count] = 0.0;} + break; + + case 22: + delayV = (int(maxdelayV * roomsize)); + for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs + if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck + for(count = alpVR; count < 5501; count++) {aVR[count] = 0.0;} + for(count = outVR; count < 5501; count++) {oVR[count] = 0.0;} + break; + + case 23: + delayW = (int(maxdelayW * roomsize)); + for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws + if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck + for(count = alpWR; count < 5009; count++) {aWR[count] = 0.0;} + for(count = outWR; count < 5009; count++) {oWR[count] = 0.0;} + break; + + case 24: + delayX = (int(maxdelayX * roomsize)); + for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs + if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck + for(count = alpXR; count < 4849; count++) {aXR[count] = 0.0;} + for(count = outXR; count < 4849; count++) {oXR[count] = 0.0;} + break; + + case 25: + delayY = (int(maxdelayY * roomsize)); + for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys + if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck + for(count = alpYR; count < 4295; count++) {aYR[count] = 0.0;} + for(count = outYR; count < 4295; count++) {oYR[count] = 0.0;} + break; + + case 26: + delayZ = (int(maxdelayZ * roomsize)); + for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs + if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck + for(count = alpZR; count < 4179; count++) {aZR[count] = 0.0;} + for(count = outZR; count < 4179; count++) {oZR[count] = 0.0;} + break; + } //end of switch statement + countdown--; //every buffer we'll do one of the recalculations for prime buffer sizes + } + + while (--sampleFrames >= 0) + { + long double inputSampleL = *in1; + long double inputSampleR = *in2; + + if (fabs(inputSampleL)<1.18e-43) inputSampleL = fpd * 1.18e-43; + if (fabs(inputSampleR)<1.18e-43) inputSampleR = fpd * 1.18e-43; + + long double drySampleL = inputSampleL; + long double drySampleR = inputSampleR; + + peakL -= release; + if (peakL < fabs(inputSampleL*2.0)) peakL = fabs(inputSampleL*2.0); + if (peakL > 1.0) peakL = 1.0; + peakR -= release; + if (peakR < fabs(inputSampleR*2.0)) peakR = fabs(inputSampleR*2.0); + if (peakR > 1.0) peakR = 1.0; + //chase the maximum signal to incorporate the wetter/louder behavior + //boost for more extreme effect when in use, cap it + + inputSampleL *= gain; + bridgerectifier = fabs(inputSampleL); + bridgerectifier = sin(bridgerectifier); + if (inputSampleL > 0) inputSampleL = bridgerectifier; + else inputSampleL = -bridgerectifier; + inputSampleR *= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = sin(bridgerectifier); + if (inputSampleR > 0) inputSampleR = bridgerectifier; + else inputSampleR = -bridgerectifier; + //here we apply the ADT2 console-on-steroids trick + + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dYL[1] + dAL[5] + dAL[6])/3.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dXL[1] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dWL[1] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dVL[1] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dUL[1] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dTL[1] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dSL[1] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dRL[1] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dQL[1] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dPL[1] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dOL[1] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dNL[1] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dLL[1] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dKL[1] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dJL[1] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dIL[1] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dHL[1] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dGL[1] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dFL[1] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dEL[1] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dDL[1] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dCL[1] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dAL[1] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dBL[1] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[5] + dZL[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dAL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dAL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dAL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dAL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dAL[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dAL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dAL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dAL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dAL[1] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dAL[1] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dAL[1] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dAL[1] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dAL[1] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dAL[1] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = drySampleL; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = drySampleL; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[1]+dAL[2])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[1]+dBL[2])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[1]+dCL[2])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[1]+dDL[2])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[1]+dEL[2])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[1]+dFL[2])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[1]+dGL[2])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[1]+dHL[2])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[1]+dIL[2])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[1]+dJL[2])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[1]+dKL[2])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[1]+dLL[2])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[1]+dML[2])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[1]+dNL[2])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[1]+dOL[2])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[1]+dPL[2])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[1]+dQL[2])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[1]+dRL[2])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[1]+dSL[2])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[1]+dTL[2])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[1]+dUL[2])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[1]+dVL[2])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[1]+dWL[2])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[1]+dXL[2])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[1]+dYL[2])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dBL[4] * dryness); + inputSampleL += (dCL[4] * dryness); + inputSampleL += dDL[4]; + inputSampleL += dEL[4]; + inputSampleL += dFL[4]; + inputSampleL += dGL[4]; + inputSampleL += dHL[4]; + inputSampleL += dIL[4]; + inputSampleL += dJL[4]; + inputSampleL += dKL[4]; + inputSampleL += dLL[4]; + inputSampleL += dML[4]; + inputSampleL += dNL[4]; + inputSampleL += dOL[4]; + inputSampleL += dPL[4]; + inputSampleL += dQL[4]; + inputSampleL += dRL[4]; + inputSampleL += dSL[4]; + inputSampleL += dTL[4]; + inputSampleL += dUL[4]; + inputSampleL += dVL[4]; + inputSampleL += dWL[4]; + inputSampleL += dXL[4]; + inputSampleL += dYL[4]; + inputSampleL += (dZL[4] * wetness); + + inputSampleL += (dBL[5] * dryness); + inputSampleL += (dCL[5] * dryness); + inputSampleL += dDL[5]; + inputSampleL += dEL[5]; + inputSampleL += dFL[5]; + inputSampleL += dGL[5]; + inputSampleL += dHL[5]; + inputSampleL += dIL[5]; + inputSampleL += dJL[5]; + inputSampleL += dKL[5]; + inputSampleL += dLL[5]; + inputSampleL += dML[5]; + inputSampleL += dNL[5]; + inputSampleL += dOL[5]; + inputSampleL += dPL[5]; + inputSampleL += dQL[5]; + inputSampleL += dRL[5]; + inputSampleL += dSL[5]; + inputSampleL += dTL[5]; + inputSampleL += dUL[5]; + inputSampleL += dVL[5]; + inputSampleL += dWL[5]; + inputSampleL += dXL[5]; + inputSampleL += dYL[5]; + inputSampleL += (dZL[5] * wetness); + + inputSampleL /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2])/2.0; + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2])/2.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2])/2.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2])/2.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2])/2.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2])/2.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2])/2.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2])/2.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2])/2.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2])/2.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2])/2.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2])/2.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2])/2.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2])/2.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2])/2.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2])/2.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2])/2.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2])/2.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2])/2.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2])/2.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2])/2.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2])/2.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2])/2.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2])/2.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2])/2.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dAL[4] + dAL[5])/2.0; + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5])/2.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5])/2.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5])/2.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5])/2.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5])/2.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5])/2.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5])/2.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5])/2.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5])/2.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5])/2.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5])/2.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5])/2.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5])/2.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5])/2.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5])/2.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5])/2.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5])/2.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5])/2.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5])/2.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5])/2.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5])/2.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5])/2.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5])/2.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5])/2.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= aAL[allpasstemp]*constallpass; + aAL[alpAL] = inputSampleL; + inputSampleL *= constallpass; + alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;} + inputSampleL += (aAL[alpAL]); + //allpass filter A + + dAL[3] = dAL[2]; + dAL[2] = dAL[1]; + dAL[1] = inputSampleL; + inputSampleL = (dAL[1] + dAL[2] + dZL[3])/3.0; //add feedback + + allpasstemp = alpBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= aBL[allpasstemp]*constallpass; + aBL[alpBL] = inputSampleL; + inputSampleL *= constallpass; + alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;} + inputSampleL += (aBL[alpBL]); + //allpass filter B + + dBL[3] = dBL[2]; + dBL[2] = dBL[1]; + dBL[1] = inputSampleL; + inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0; + + allpasstemp = alpCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= aCL[allpasstemp]*constallpass; + aCL[alpCL] = inputSampleL; + inputSampleL *= constallpass; + alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;} + inputSampleL += (aCL[alpCL]); + //allpass filter C + + dCL[3] = dCL[2]; + dCL[2] = dCL[1]; + dCL[1] = inputSampleL; + inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0; + + allpasstemp = alpDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= aDL[allpasstemp]*constallpass; + aDL[alpDL] = inputSampleL; + inputSampleL *= constallpass; + alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;} + inputSampleL += (aDL[alpDL]); + //allpass filter D + + dDL[3] = dDL[2]; + dDL[2] = dDL[1]; + dDL[1] = inputSampleL; + inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0; + + allpasstemp = alpEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= aEL[allpasstemp]*constallpass; + aEL[alpEL] = inputSampleL; + inputSampleL *= constallpass; + alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;} + inputSampleL += (aEL[alpEL]); + //allpass filter E + + dEL[3] = dEL[2]; + dEL[2] = dEL[1]; + dEL[1] = inputSampleL; + inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0; + + allpasstemp = alpFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= aFL[allpasstemp]*constallpass; + aFL[alpFL] = inputSampleL; + inputSampleL *= constallpass; + alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;} + inputSampleL += (aFL[alpFL]); + //allpass filter F + + dFL[3] = dFL[2]; + dFL[2] = dFL[1]; + dFL[1] = inputSampleL; + inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0; + + allpasstemp = alpGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= aGL[allpasstemp]*constallpass; + aGL[alpGL] = inputSampleL; + inputSampleL *= constallpass; + alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;} + inputSampleL += (aGL[alpGL]); + //allpass filter G + + dGL[3] = dGL[2]; + dGL[2] = dGL[1]; + dGL[1] = inputSampleL; + inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0; + + allpasstemp = alpHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= aHL[allpasstemp]*constallpass; + aHL[alpHL] = inputSampleL; + inputSampleL *= constallpass; + alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;} + inputSampleL += (aHL[alpHL]); + //allpass filter H + + dHL[3] = dHL[2]; + dHL[2] = dHL[1]; + dHL[1] = inputSampleL; + inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0; + + allpasstemp = alpIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= aIL[allpasstemp]*constallpass; + aIL[alpIL] = inputSampleL; + inputSampleL *= constallpass; + alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;} + inputSampleL += (aIL[alpIL]); + //allpass filter I + + dIL[3] = dIL[2]; + dIL[2] = dIL[1]; + dIL[1] = inputSampleL; + inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0; + + allpasstemp = alpJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= aJL[allpasstemp]*constallpass; + aJL[alpJL] = inputSampleL; + inputSampleL *= constallpass; + alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;} + inputSampleL += (aJL[alpJL]); + //allpass filter J + + dJL[3] = dJL[2]; + dJL[2] = dJL[1]; + dJL[1] = inputSampleL; + inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0; + + allpasstemp = alpKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= aKL[allpasstemp]*constallpass; + aKL[alpKL] = inputSampleL; + inputSampleL *= constallpass; + alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;} + inputSampleL += (aKL[alpKL]); + //allpass filter K + + dKL[3] = dKL[2]; + dKL[2] = dKL[1]; + dKL[1] = inputSampleL; + inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0; + + allpasstemp = alpLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= aLL[allpasstemp]*constallpass; + aLL[alpLL] = inputSampleL; + inputSampleL *= constallpass; + alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;} + inputSampleL += (aLL[alpLL]); + //allpass filter L + + dLL[3] = dLL[2]; + dLL[2] = dLL[1]; + dLL[1] = inputSampleL; + inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0; + + allpasstemp = alpML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= aML[allpasstemp]*constallpass; + aML[alpML] = inputSampleL; + inputSampleL *= constallpass; + alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;} + inputSampleL += (aML[alpML]); + //allpass filter M + + dML[3] = dML[2]; + dML[2] = dML[1]; + dML[1] = inputSampleL; + inputSampleL = (dML[1] + dML[2] + dML[3])/3.0; + + allpasstemp = alpNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= aNL[allpasstemp]*constallpass; + aNL[alpNL] = inputSampleL; + inputSampleL *= constallpass; + alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;} + inputSampleL += (aNL[alpNL]); + //allpass filter N + + dNL[3] = dNL[2]; + dNL[2] = dNL[1]; + dNL[1] = inputSampleL; + inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0; + + allpasstemp = alpOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= aOL[allpasstemp]*constallpass; + aOL[alpOL] = inputSampleL; + inputSampleL *= constallpass; + alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;} + inputSampleL += (aOL[alpOL]); + //allpass filter O + + dOL[3] = dOL[2]; + dOL[2] = dOL[1]; + dOL[1] = inputSampleL; + inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0; + + allpasstemp = alpPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= aPL[allpasstemp]*constallpass; + aPL[alpPL] = inputSampleL; + inputSampleL *= constallpass; + alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;} + inputSampleL += (aPL[alpPL]); + //allpass filter P + + dPL[3] = dPL[2]; + dPL[2] = dPL[1]; + dPL[1] = inputSampleL; + inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0; + + allpasstemp = alpQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= aQL[allpasstemp]*constallpass; + aQL[alpQL] = inputSampleL; + inputSampleL *= constallpass; + alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;} + inputSampleL += (aQL[alpQL]); + //allpass filter Q + + dQL[3] = dQL[2]; + dQL[2] = dQL[1]; + dQL[1] = inputSampleL; + inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0; + + allpasstemp = alpRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= aRL[allpasstemp]*constallpass; + aRL[alpRL] = inputSampleL; + inputSampleL *= constallpass; + alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;} + inputSampleL += (aRL[alpRL]); + //allpass filter R + + dRL[3] = dRL[2]; + dRL[2] = dRL[1]; + dRL[1] = inputSampleL; + inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0; + + allpasstemp = alpSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= aSL[allpasstemp]*constallpass; + aSL[alpSL] = inputSampleL; + inputSampleL *= constallpass; + alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;} + inputSampleL += (aSL[alpSL]); + //allpass filter S + + dSL[3] = dSL[2]; + dSL[2] = dSL[1]; + dSL[1] = inputSampleL; + inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0; + + allpasstemp = alpTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= aTL[allpasstemp]*constallpass; + aTL[alpTL] = inputSampleL; + inputSampleL *= constallpass; + alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;} + inputSampleL += (aTL[alpTL]); + //allpass filter T + + dTL[3] = dTL[2]; + dTL[2] = dTL[1]; + dTL[1] = inputSampleL; + inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0; + + allpasstemp = alpUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= aUL[allpasstemp]*constallpass; + aUL[alpUL] = inputSampleL; + inputSampleL *= constallpass; + alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;} + inputSampleL += (aUL[alpUL]); + //allpass filter U + + dUL[3] = dUL[2]; + dUL[2] = dUL[1]; + dUL[1] = inputSampleL; + inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0; + + allpasstemp = alpVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= aVL[allpasstemp]*constallpass; + aVL[alpVL] = inputSampleL; + inputSampleL *= constallpass; + alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;} + inputSampleL += (aVL[alpVL]); + //allpass filter V + + dVL[3] = dVL[2]; + dVL[2] = dVL[1]; + dVL[1] = inputSampleL; + inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0; + + allpasstemp = alpWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= aWL[allpasstemp]*constallpass; + aWL[alpWL] = inputSampleL; + inputSampleL *= constallpass; + alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;} + inputSampleL += (aWL[alpWL]); + //allpass filter W + + dWL[3] = dWL[2]; + dWL[2] = dWL[1]; + dWL[1] = inputSampleL; + inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0; + + allpasstemp = alpXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= aXL[allpasstemp]*constallpass; + aXL[alpXL] = inputSampleL; + inputSampleL *= constallpass; + alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;} + inputSampleL += (aXL[alpXL]); + //allpass filter X + + dXL[3] = dXL[2]; + dXL[2] = dXL[1]; + dXL[1] = inputSampleL; + inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0; + + allpasstemp = alpYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= aYL[allpasstemp]*constallpass; + aYL[alpYL] = inputSampleL; + inputSampleL *= constallpass; + alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;} + inputSampleL += (aYL[alpYL]); + //allpass filter Y + + dYL[3] = dYL[2]; + dYL[2] = dYL[1]; + dYL[1] = inputSampleL; + inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0; + + allpasstemp = alpZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= aZL[allpasstemp]*constallpass; + aZL[alpZL] = inputSampleL; + inputSampleL *= constallpass; + alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;} + inputSampleL += (aZL[alpZL]); + //allpass filter Z + + dZL[3] = dZL[2]; + dZL[2] = dZL[1]; + dZL[1] = inputSampleL; + inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAL - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleL -= oAL[allpasstemp]*constallpass; + oAL[outAL] = inputSampleL; + inputSampleL *= constallpass; + outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;} + inputSampleL += (oAL[outAL]); + //allpass filter A + + dAL[6] = dAL[5]; + dAL[5] = dAL[4]; + dAL[4] = inputSampleL; + inputSampleL = (dCL[1] + dAL[5] + dAL[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBL - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleL -= oBL[allpasstemp]*constallpass; + oBL[outBL] = inputSampleL; + inputSampleL *= constallpass; + outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;} + inputSampleL += (oBL[outBL]); + //allpass filter B + + dBL[6] = dBL[5]; + dBL[5] = dBL[4]; + dBL[4] = inputSampleL; + inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0; + + allpasstemp = outCL - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleL -= oCL[allpasstemp]*constallpass; + oCL[outCL] = inputSampleL; + inputSampleL *= constallpass; + outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;} + inputSampleL += (oCL[outCL]); + //allpass filter C + + dCL[6] = dCL[5]; + dCL[5] = dCL[4]; + dCL[4] = inputSampleL; + inputSampleL = (dCL[4] + dCL[5] + dCL[6])/3.0; + + allpasstemp = outDL - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleL -= oDL[allpasstemp]*constallpass; + oDL[outDL] = inputSampleL; + inputSampleL *= constallpass; + outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;} + inputSampleL += (oDL[outDL]); + //allpass filter D + + dDL[6] = dDL[5]; + dDL[5] = dDL[4]; + dDL[4] = inputSampleL; + inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0; + + allpasstemp = outEL - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleL -= oEL[allpasstemp]*constallpass; + oEL[outEL] = inputSampleL; + inputSampleL *= constallpass; + outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;} + inputSampleL += (oEL[outEL]); + //allpass filter E + + dEL[6] = dEL[5]; + dEL[5] = dEL[4]; + dEL[4] = inputSampleL; + inputSampleL = (dEL[4] + dEL[5] + dEL[6])/3.0; + + allpasstemp = outFL - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleL -= oFL[allpasstemp]*constallpass; + oFL[outFL] = inputSampleL; + inputSampleL *= constallpass; + outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;} + inputSampleL += (oFL[outFL]); + //allpass filter F + + dFL[6] = dFL[5]; + dFL[5] = dFL[4]; + dFL[4] = inputSampleL; + inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0; + + allpasstemp = outGL - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleL -= oGL[allpasstemp]*constallpass; + oGL[outGL] = inputSampleL; + inputSampleL *= constallpass; + outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;} + inputSampleL += (oGL[outGL]); + //allpass filter G + + dGL[6] = dGL[5]; + dGL[5] = dGL[4]; + dGL[4] = inputSampleL; + inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0; + + allpasstemp = outHL - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleL -= oHL[allpasstemp]*constallpass; + oHL[outHL] = inputSampleL; + inputSampleL *= constallpass; + outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;} + inputSampleL += (oHL[outHL]); + //allpass filter H + + dHL[6] = dHL[5]; + dHL[5] = dHL[4]; + dHL[4] = inputSampleL; + inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0; + + allpasstemp = outIL - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleL -= oIL[allpasstemp]*constallpass; + oIL[outIL] = inputSampleL; + inputSampleL *= constallpass; + outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;} + inputSampleL += (oIL[outIL]); + //allpass filter I + + dIL[6] = dIL[5]; + dIL[5] = dIL[4]; + dIL[4] = inputSampleL; + inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0; + + allpasstemp = outJL - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleL -= oJL[allpasstemp]*constallpass; + oJL[outJL] = inputSampleL; + inputSampleL *= constallpass; + outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;} + inputSampleL += (oJL[outJL]); + //allpass filter J + + dJL[6] = dJL[5]; + dJL[5] = dJL[4]; + dJL[4] = inputSampleL; + inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0; + + allpasstemp = outKL - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleL -= oKL[allpasstemp]*constallpass; + oKL[outKL] = inputSampleL; + inputSampleL *= constallpass; + outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;} + inputSampleL += (oKL[outKL]); + //allpass filter K + + dKL[6] = dKL[5]; + dKL[5] = dKL[4]; + dKL[4] = inputSampleL; + inputSampleL = (dKL[4] + dKL[5] + dKL[6])/3.0; + + allpasstemp = outLL - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleL -= oLL[allpasstemp]*constallpass; + oLL[outLL] = inputSampleL; + inputSampleL *= constallpass; + outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;} + inputSampleL += (oLL[outLL]); + //allpass filter L + + dLL[6] = dLL[5]; + dLL[5] = dLL[4]; + dLL[4] = inputSampleL; + inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0; + + allpasstemp = outML - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleL -= oML[allpasstemp]*constallpass; + oML[outML] = inputSampleL; + inputSampleL *= constallpass; + outML--; if (outML < 0 || outML > delayM) {outML = delayM;} + inputSampleL += (oML[outML]); + //allpass filter M + + dML[6] = dML[5]; + dML[5] = dML[4]; + dML[4] = inputSampleL; + inputSampleL = (dML[4] + dML[5] + dML[6])/3.0; + + allpasstemp = outNL - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleL -= oNL[allpasstemp]*constallpass; + oNL[outNL] = inputSampleL; + inputSampleL *= constallpass; + outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;} + inputSampleL += (oNL[outNL]); + //allpass filter N + + dNL[6] = dNL[5]; + dNL[5] = dNL[4]; + dNL[4] = inputSampleL; + inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0; + + allpasstemp = outOL - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleL -= oOL[allpasstemp]*constallpass; + oOL[outOL] = inputSampleL; + inputSampleL *= constallpass; + outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;} + inputSampleL += (oOL[outOL]); + //allpass filter O + + dOL[6] = dOL[5]; + dOL[5] = dOL[4]; + dOL[4] = inputSampleL; + inputSampleL = (dOL[4] + dOL[5] + dOL[6])/3.0; + + allpasstemp = outPL - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleL -= oPL[allpasstemp]*constallpass; + oPL[outPL] = inputSampleL; + inputSampleL *= constallpass; + outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;} + inputSampleL += (oPL[outPL]); + //allpass filter P + + dPL[6] = dPL[5]; + dPL[5] = dPL[4]; + dPL[4] = inputSampleL; + inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0; + + allpasstemp = outQL - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleL -= oQL[allpasstemp]*constallpass; + oQL[outQL] = inputSampleL; + inputSampleL *= constallpass; + outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;} + inputSampleL += (oQL[outQL]); + //allpass filter Q + + dQL[6] = dQL[5]; + dQL[5] = dQL[4]; + dQL[4] = inputSampleL; + inputSampleL = (dQL[4] + dQL[5] + dQL[6])/3.0; + + allpasstemp = outRL - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleL -= oRL[allpasstemp]*constallpass; + oRL[outRL] = inputSampleL; + inputSampleL *= constallpass; + outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;} + inputSampleL += (oRL[outRL]); + //allpass filter R + + dRL[6] = dRL[5]; + dRL[5] = dRL[4]; + dRL[4] = inputSampleL; + inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0; + + allpasstemp = outSL - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleL -= oSL[allpasstemp]*constallpass; + oSL[outSL] = inputSampleL; + inputSampleL *= constallpass; + outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;} + inputSampleL += (oSL[outSL]); + //allpass filter S + + dSL[6] = dSL[5]; + dSL[5] = dSL[4]; + dSL[4] = inputSampleL; + inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0; + + allpasstemp = outTL - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleL -= oTL[allpasstemp]*constallpass; + oTL[outTL] = inputSampleL; + inputSampleL *= constallpass; + outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;} + inputSampleL += (oTL[outTL]); + //allpass filter T + + dTL[6] = dTL[5]; + dTL[5] = dTL[4]; + dTL[4] = inputSampleL; + inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0; + + allpasstemp = outUL - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleL -= oUL[allpasstemp]*constallpass; + oUL[outUL] = inputSampleL; + inputSampleL *= constallpass; + outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;} + inputSampleL += (oUL[outUL]); + //allpass filter U + + dUL[6] = dUL[5]; + dUL[5] = dUL[4]; + dUL[4] = inputSampleL; + inputSampleL = (dUL[4] + dUL[5] + dUL[6])/3.0; + + allpasstemp = outVL - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleL -= oVL[allpasstemp]*constallpass; + oVL[outVL] = inputSampleL; + inputSampleL *= constallpass; + outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;} + inputSampleL += (oVL[outVL]); + //allpass filter V + + dVL[6] = dVL[5]; + dVL[5] = dVL[4]; + dVL[4] = inputSampleL; + inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0; + + allpasstemp = outWL - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleL -= oWL[allpasstemp]*constallpass; + oWL[outWL] = inputSampleL; + inputSampleL *= constallpass; + outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;} + inputSampleL += (oWL[outWL]); + //allpass filter W + + dWL[6] = dWL[5]; + dWL[5] = dWL[4]; + dWL[4] = inputSampleL; + inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0; + + allpasstemp = outXL - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleL -= oXL[allpasstemp]*constallpass; + oXL[outXL] = inputSampleL; + inputSampleL *= constallpass; + outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;} + inputSampleL += (oXL[outXL]); + //allpass filter X + + dXL[6] = dXL[5]; + dXL[5] = dXL[4]; + dXL[4] = inputSampleL; + inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0; + + allpasstemp = outYL - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleL -= oYL[allpasstemp]*constallpass; + oYL[outYL] = inputSampleL; + inputSampleL *= constallpass; + outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;} + inputSampleL += (oYL[outYL]); + //allpass filter Y + + dYL[6] = dYL[5]; + dYL[5] = dYL[4]; + dYL[4] = inputSampleL; + inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0; + + allpasstemp = outZL - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleL -= oZL[allpasstemp]*constallpass; + oZL[outZL] = inputSampleL; + inputSampleL *= constallpass; + outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;} + inputSampleL += (oZL[outZL]); + //allpass filter Z + + dZL[6] = dZL[5]; + dZL[5] = dZL[4]; + dZL[4] = inputSampleL; + inputSampleL = (dZL[4] + dZL[5] + dZL[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + switch (verbtype) + { + + + case 1://Chamber + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Chamber + break; + + + + + + case 2: //Spring + + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dYR[1] + dAR[5] + dAR[6])/3.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dXR[1] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dWR[1] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dVR[1] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dUR[1] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dTR[1] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dSR[1] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dRR[1] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dQR[1] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dPR[1] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dOR[1] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dNR[1] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dLR[1] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dKR[1] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dJR[1] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dIR[1] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dHR[1] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dGR[1] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dFR[1] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dER[1] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dDR[1] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dCR[1] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dAR[1] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dBR[1] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[5] + dZR[6]); + //output Spring + break; + + + case 3: //Tiled + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dAR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dAR[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dAR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dAR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dAR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dAR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dAR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dAR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dAR[1] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dAR[1] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dAR[1] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dAR[1] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dAR[1] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dAR[1] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5]); + //output Tiled + break; + + + case 4://Room + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = drySampleR; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = drySampleR; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[1]+dAR[2])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[1]+dBR[2])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[1]+dCR[2])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[1]+dDR[2])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[1]+dER[2])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[1]+dFR[2])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[1]+dGR[2])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[1]+dHR[2])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[1]+dIR[2])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[1]+dJR[2])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[1]+dKR[2])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[1]+dLR[2])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[1]+dMR[2])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[1]+dNR[2])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[1]+dOR[2])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[1]+dPR[2])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[1]+dQR[2])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[1]+dRR[2])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[1]+dSR[2])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[1]+dTR[2])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[1]+dUR[2])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[1]+dVR[2])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[1]+dWR[2])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[1]+dXR[2])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[1]+dYR[2])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dBR[4] * dryness); + inputSampleR += (dCR[4] * dryness); + inputSampleR += dDR[4]; + inputSampleR += dER[4]; + inputSampleR += dFR[4]; + inputSampleR += dGR[4]; + inputSampleR += dHR[4]; + inputSampleR += dIR[4]; + inputSampleR += dJR[4]; + inputSampleR += dKR[4]; + inputSampleR += dLR[4]; + inputSampleR += dMR[4]; + inputSampleR += dNR[4]; + inputSampleR += dOR[4]; + inputSampleR += dPR[4]; + inputSampleR += dQR[4]; + inputSampleR += dRR[4]; + inputSampleR += dSR[4]; + inputSampleR += dTR[4]; + inputSampleR += dUR[4]; + inputSampleR += dVR[4]; + inputSampleR += dWR[4]; + inputSampleR += dXR[4]; + inputSampleR += dYR[4]; + inputSampleR += (dZR[4] * wetness); + + inputSampleR += (dBR[5] * dryness); + inputSampleR += (dCR[5] * dryness); + inputSampleR += dDR[5]; + inputSampleR += dER[5]; + inputSampleR += dFR[5]; + inputSampleR += dGR[5]; + inputSampleR += dHR[5]; + inputSampleR += dIR[5]; + inputSampleR += dJR[5]; + inputSampleR += dKR[5]; + inputSampleR += dLR[5]; + inputSampleR += dMR[5]; + inputSampleR += dNR[5]; + inputSampleR += dOR[5]; + inputSampleR += dPR[5]; + inputSampleR += dQR[5]; + inputSampleR += dRR[5]; + inputSampleR += dSR[5]; + inputSampleR += dTR[5]; + inputSampleR += dUR[5]; + inputSampleR += dVR[5]; + inputSampleR += dWR[5]; + inputSampleR += dXR[5]; + inputSampleR += dYR[5]; + inputSampleR += (dZR[5] * wetness); + + inputSampleR /= (26.0 + (wetness * 4.0)); + //output Room effect + break; + + + + + + + case 5: //Stretch + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2])/2.0; + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2])/2.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2])/2.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2])/2.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2])/2.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2])/2.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2])/2.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2])/2.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2])/2.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2])/2.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2])/2.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2])/2.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2])/2.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2])/2.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2])/2.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2])/2.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2])/2.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2])/2.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2])/2.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2])/2.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2])/2.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2])/2.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2])/2.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2])/2.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2])/2.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2])/2.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dAR[4] + dAR[5])/2.0; + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5])/2.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5])/2.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5])/2.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5])/2.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5])/2.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5])/2.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5])/2.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5])/2.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5])/2.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5])/2.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5])/2.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5])/2.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5])/2.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5])/2.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5])/2.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5])/2.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5])/2.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5])/2.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5])/2.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5])/2.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5])/2.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5])/2.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5])/2.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5])/2.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5])/2.0; + //output Stretch unrealistic but smooth fake Paulstretch + break; + + + case 6: //Zarathustra + allpasstemp = alpAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= aAR[allpasstemp]*constallpass; + aAR[alpAR] = inputSampleR; + inputSampleR *= constallpass; + alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;} + inputSampleR += (aAR[alpAR]); + //allpass filter A + + dAR[3] = dAR[2]; + dAR[2] = dAR[1]; + dAR[1] = inputSampleR; + inputSampleR = (dAR[1] + dAR[2] + dZR[3])/3.0; //add feedback + + allpasstemp = alpBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= aBR[allpasstemp]*constallpass; + aBR[alpBR] = inputSampleR; + inputSampleR *= constallpass; + alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;} + inputSampleR += (aBR[alpBR]); + //allpass filter B + + dBR[3] = dBR[2]; + dBR[2] = dBR[1]; + dBR[1] = inputSampleR; + inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0; + + allpasstemp = alpCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= aCR[allpasstemp]*constallpass; + aCR[alpCR] = inputSampleR; + inputSampleR *= constallpass; + alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;} + inputSampleR += (aCR[alpCR]); + //allpass filter C + + dCR[3] = dCR[2]; + dCR[2] = dCR[1]; + dCR[1] = inputSampleR; + inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0; + + allpasstemp = alpDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= aDR[allpasstemp]*constallpass; + aDR[alpDR] = inputSampleR; + inputSampleR *= constallpass; + alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;} + inputSampleR += (aDR[alpDR]); + //allpass filter D + + dDR[3] = dDR[2]; + dDR[2] = dDR[1]; + dDR[1] = inputSampleR; + inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0; + + allpasstemp = alpER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= aER[allpasstemp]*constallpass; + aER[alpER] = inputSampleR; + inputSampleR *= constallpass; + alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;} + inputSampleR += (aER[alpER]); + //allpass filter E + + dER[3] = dER[2]; + dER[2] = dER[1]; + dER[1] = inputSampleR; + inputSampleR = (dER[1] + dER[2] + dER[3])/3.0; + + allpasstemp = alpFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= aFR[allpasstemp]*constallpass; + aFR[alpFR] = inputSampleR; + inputSampleR *= constallpass; + alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;} + inputSampleR += (aFR[alpFR]); + //allpass filter F + + dFR[3] = dFR[2]; + dFR[2] = dFR[1]; + dFR[1] = inputSampleR; + inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0; + + allpasstemp = alpGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= aGR[allpasstemp]*constallpass; + aGR[alpGR] = inputSampleR; + inputSampleR *= constallpass; + alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;} + inputSampleR += (aGR[alpGR]); + //allpass filter G + + dGR[3] = dGR[2]; + dGR[2] = dGR[1]; + dGR[1] = inputSampleR; + inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0; + + allpasstemp = alpHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= aHR[allpasstemp]*constallpass; + aHR[alpHR] = inputSampleR; + inputSampleR *= constallpass; + alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;} + inputSampleR += (aHR[alpHR]); + //allpass filter H + + dHR[3] = dHR[2]; + dHR[2] = dHR[1]; + dHR[1] = inputSampleR; + inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0; + + allpasstemp = alpIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= aIR[allpasstemp]*constallpass; + aIR[alpIR] = inputSampleR; + inputSampleR *= constallpass; + alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;} + inputSampleR += (aIR[alpIR]); + //allpass filter I + + dIR[3] = dIR[2]; + dIR[2] = dIR[1]; + dIR[1] = inputSampleR; + inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0; + + allpasstemp = alpJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= aJR[allpasstemp]*constallpass; + aJR[alpJR] = inputSampleR; + inputSampleR *= constallpass; + alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;} + inputSampleR += (aJR[alpJR]); + //allpass filter J + + dJR[3] = dJR[2]; + dJR[2] = dJR[1]; + dJR[1] = inputSampleR; + inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0; + + allpasstemp = alpKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= aKR[allpasstemp]*constallpass; + aKR[alpKR] = inputSampleR; + inputSampleR *= constallpass; + alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;} + inputSampleR += (aKR[alpKR]); + //allpass filter K + + dKR[3] = dKR[2]; + dKR[2] = dKR[1]; + dKR[1] = inputSampleR; + inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0; + + allpasstemp = alpLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= aLR[allpasstemp]*constallpass; + aLR[alpLR] = inputSampleR; + inputSampleR *= constallpass; + alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;} + inputSampleR += (aLR[alpLR]); + //allpass filter L + + dLR[3] = dLR[2]; + dLR[2] = dLR[1]; + dLR[1] = inputSampleR; + inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0; + + allpasstemp = alpMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= aMR[allpasstemp]*constallpass; + aMR[alpMR] = inputSampleR; + inputSampleR *= constallpass; + alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;} + inputSampleR += (aMR[alpMR]); + //allpass filter M + + dMR[3] = dMR[2]; + dMR[2] = dMR[1]; + dMR[1] = inputSampleR; + inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0; + + allpasstemp = alpNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= aNR[allpasstemp]*constallpass; + aNR[alpNR] = inputSampleR; + inputSampleR *= constallpass; + alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;} + inputSampleR += (aNR[alpNR]); + //allpass filter N + + dNR[3] = dNR[2]; + dNR[2] = dNR[1]; + dNR[1] = inputSampleR; + inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0; + + allpasstemp = alpOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= aOR[allpasstemp]*constallpass; + aOR[alpOR] = inputSampleR; + inputSampleR *= constallpass; + alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;} + inputSampleR += (aOR[alpOR]); + //allpass filter O + + dOR[3] = dOR[2]; + dOR[2] = dOR[1]; + dOR[1] = inputSampleR; + inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0; + + allpasstemp = alpPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= aPR[allpasstemp]*constallpass; + aPR[alpPR] = inputSampleR; + inputSampleR *= constallpass; + alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;} + inputSampleR += (aPR[alpPR]); + //allpass filter P + + dPR[3] = dPR[2]; + dPR[2] = dPR[1]; + dPR[1] = inputSampleR; + inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0; + + allpasstemp = alpQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= aQR[allpasstemp]*constallpass; + aQR[alpQR] = inputSampleR; + inputSampleR *= constallpass; + alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;} + inputSampleR += (aQR[alpQR]); + //allpass filter Q + + dQR[3] = dQR[2]; + dQR[2] = dQR[1]; + dQR[1] = inputSampleR; + inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0; + + allpasstemp = alpRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= aRR[allpasstemp]*constallpass; + aRR[alpRR] = inputSampleR; + inputSampleR *= constallpass; + alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;} + inputSampleR += (aRR[alpRR]); + //allpass filter R + + dRR[3] = dRR[2]; + dRR[2] = dRR[1]; + dRR[1] = inputSampleR; + inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0; + + allpasstemp = alpSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= aSR[allpasstemp]*constallpass; + aSR[alpSR] = inputSampleR; + inputSampleR *= constallpass; + alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;} + inputSampleR += (aSR[alpSR]); + //allpass filter S + + dSR[3] = dSR[2]; + dSR[2] = dSR[1]; + dSR[1] = inputSampleR; + inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0; + + allpasstemp = alpTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= aTR[allpasstemp]*constallpass; + aTR[alpTR] = inputSampleR; + inputSampleR *= constallpass; + alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;} + inputSampleR += (aTR[alpTR]); + //allpass filter T + + dTR[3] = dTR[2]; + dTR[2] = dTR[1]; + dTR[1] = inputSampleR; + inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0; + + allpasstemp = alpUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= aUR[allpasstemp]*constallpass; + aUR[alpUR] = inputSampleR; + inputSampleR *= constallpass; + alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;} + inputSampleR += (aUR[alpUR]); + //allpass filter U + + dUR[3] = dUR[2]; + dUR[2] = dUR[1]; + dUR[1] = inputSampleR; + inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0; + + allpasstemp = alpVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= aVR[allpasstemp]*constallpass; + aVR[alpVR] = inputSampleR; + inputSampleR *= constallpass; + alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;} + inputSampleR += (aVR[alpVR]); + //allpass filter V + + dVR[3] = dVR[2]; + dVR[2] = dVR[1]; + dVR[1] = inputSampleR; + inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0; + + allpasstemp = alpWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= aWR[allpasstemp]*constallpass; + aWR[alpWR] = inputSampleR; + inputSampleR *= constallpass; + alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;} + inputSampleR += (aWR[alpWR]); + //allpass filter W + + dWR[3] = dWR[2]; + dWR[2] = dWR[1]; + dWR[1] = inputSampleR; + inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0; + + allpasstemp = alpXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= aXR[allpasstemp]*constallpass; + aXR[alpXR] = inputSampleR; + inputSampleR *= constallpass; + alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;} + inputSampleR += (aXR[alpXR]); + //allpass filter X + + dXR[3] = dXR[2]; + dXR[2] = dXR[1]; + dXR[1] = inputSampleR; + inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0; + + allpasstemp = alpYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= aYR[allpasstemp]*constallpass; + aYR[alpYR] = inputSampleR; + inputSampleR *= constallpass; + alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;} + inputSampleR += (aYR[alpYR]); + //allpass filter Y + + dYR[3] = dYR[2]; + dYR[2] = dYR[1]; + dYR[1] = inputSampleR; + inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0; + + allpasstemp = alpZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= aZR[allpasstemp]*constallpass; + aZR[alpZR] = inputSampleR; + inputSampleR *= constallpass; + alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;} + inputSampleR += (aZR[alpZR]); + //allpass filter Z + + dZR[3] = dZR[2]; + dZR[2] = dZR[1]; + dZR[1] = inputSampleR; + inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0; + + // now the second stage using the 'out' bank of allpasses + + allpasstemp = outAR - 1; + if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;} + inputSampleR -= oAR[allpasstemp]*constallpass; + oAR[outAR] = inputSampleR; + inputSampleR *= constallpass; + outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;} + inputSampleR += (oAR[outAR]); + //allpass filter A + + dAR[6] = dAR[5]; + dAR[5] = dAR[4]; + dAR[4] = inputSampleR; + inputSampleR = (dCR[1] + dAR[5] + dAR[6])/3.0; //note, feeding in dry again for a little more clarity! + + allpasstemp = outBR - 1; + if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;} + inputSampleR -= oBR[allpasstemp]*constallpass; + oBR[outBR] = inputSampleR; + inputSampleR *= constallpass; + outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;} + inputSampleR += (oBR[outBR]); + //allpass filter B + + dBR[6] = dBR[5]; + dBR[5] = dBR[4]; + dBR[4] = inputSampleR; + inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0; + + allpasstemp = outCR - 1; + if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;} + inputSampleR -= oCR[allpasstemp]*constallpass; + oCR[outCR] = inputSampleR; + inputSampleR *= constallpass; + outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;} + inputSampleR += (oCR[outCR]); + //allpass filter C + + dCR[6] = dCR[5]; + dCR[5] = dCR[4]; + dCR[4] = inputSampleR; + inputSampleR = (dCR[4] + dCR[5] + dCR[6])/3.0; + + allpasstemp = outDR - 1; + if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;} + inputSampleR -= oDR[allpasstemp]*constallpass; + oDR[outDR] = inputSampleR; + inputSampleR *= constallpass; + outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;} + inputSampleR += (oDR[outDR]); + //allpass filter D + + dDR[6] = dDR[5]; + dDR[5] = dDR[4]; + dDR[4] = inputSampleR; + inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0; + + allpasstemp = outER - 1; + if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;} + inputSampleR -= oER[allpasstemp]*constallpass; + oER[outER] = inputSampleR; + inputSampleR *= constallpass; + outER--; if (outER < 0 || outER > delayE) {outER = delayE;} + inputSampleR += (oER[outER]); + //allpass filter E + + dER[6] = dER[5]; + dER[5] = dER[4]; + dER[4] = inputSampleR; + inputSampleR = (dER[4] + dER[5] + dER[6])/3.0; + + allpasstemp = outFR - 1; + if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;} + inputSampleR -= oFR[allpasstemp]*constallpass; + oFR[outFR] = inputSampleR; + inputSampleR *= constallpass; + outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;} + inputSampleR += (oFR[outFR]); + //allpass filter F + + dFR[6] = dFR[5]; + dFR[5] = dFR[4]; + dFR[4] = inputSampleR; + inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0; + + allpasstemp = outGR - 1; + if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;} + inputSampleR -= oGR[allpasstemp]*constallpass; + oGR[outGR] = inputSampleR; + inputSampleR *= constallpass; + outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;} + inputSampleR += (oGR[outGR]); + //allpass filter G + + dGR[6] = dGR[5]; + dGR[5] = dGR[4]; + dGR[4] = inputSampleR; + inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0; + + allpasstemp = outHR - 1; + if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;} + inputSampleR -= oHR[allpasstemp]*constallpass; + oHR[outHR] = inputSampleR; + inputSampleR *= constallpass; + outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;} + inputSampleR += (oHR[outHR]); + //allpass filter H + + dHR[6] = dHR[5]; + dHR[5] = dHR[4]; + dHR[4] = inputSampleR; + inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0; + + allpasstemp = outIR - 1; + if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;} + inputSampleR -= oIR[allpasstemp]*constallpass; + oIR[outIR] = inputSampleR; + inputSampleR *= constallpass; + outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;} + inputSampleR += (oIR[outIR]); + //allpass filter I + + dIR[6] = dIR[5]; + dIR[5] = dIR[4]; + dIR[4] = inputSampleR; + inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0; + + allpasstemp = outJR - 1; + if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;} + inputSampleR -= oJR[allpasstemp]*constallpass; + oJR[outJR] = inputSampleR; + inputSampleR *= constallpass; + outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;} + inputSampleR += (oJR[outJR]); + //allpass filter J + + dJR[6] = dJR[5]; + dJR[5] = dJR[4]; + dJR[4] = inputSampleR; + inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0; + + allpasstemp = outKR - 1; + if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;} + inputSampleR -= oKR[allpasstemp]*constallpass; + oKR[outKR] = inputSampleR; + inputSampleR *= constallpass; + outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;} + inputSampleR += (oKR[outKR]); + //allpass filter K + + dKR[6] = dKR[5]; + dKR[5] = dKR[4]; + dKR[4] = inputSampleR; + inputSampleR = (dKR[4] + dKR[5] + dKR[6])/3.0; + + allpasstemp = outLR - 1; + if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;} + inputSampleR -= oLR[allpasstemp]*constallpass; + oLR[outLR] = inputSampleR; + inputSampleR *= constallpass; + outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;} + inputSampleR += (oLR[outLR]); + //allpass filter L + + dLR[6] = dLR[5]; + dLR[5] = dLR[4]; + dLR[4] = inputSampleR; + inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0; + + allpasstemp = outMR - 1; + if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;} + inputSampleR -= oMR[allpasstemp]*constallpass; + oMR[outMR] = inputSampleR; + inputSampleR *= constallpass; + outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;} + inputSampleR += (oMR[outMR]); + //allpass filter M + + dMR[6] = dMR[5]; + dMR[5] = dMR[4]; + dMR[4] = inputSampleR; + inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0; + + allpasstemp = outNR - 1; + if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;} + inputSampleR -= oNR[allpasstemp]*constallpass; + oNR[outNR] = inputSampleR; + inputSampleR *= constallpass; + outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;} + inputSampleR += (oNR[outNR]); + //allpass filter N + + dNR[6] = dNR[5]; + dNR[5] = dNR[4]; + dNR[4] = inputSampleR; + inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0; + + allpasstemp = outOR - 1; + if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;} + inputSampleR -= oOR[allpasstemp]*constallpass; + oOR[outOR] = inputSampleR; + inputSampleR *= constallpass; + outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;} + inputSampleR += (oOR[outOR]); + //allpass filter O + + dOR[6] = dOR[5]; + dOR[5] = dOR[4]; + dOR[4] = inputSampleR; + inputSampleR = (dOR[4] + dOR[5] + dOR[6])/3.0; + + allpasstemp = outPR - 1; + if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;} + inputSampleR -= oPR[allpasstemp]*constallpass; + oPR[outPR] = inputSampleR; + inputSampleR *= constallpass; + outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;} + inputSampleR += (oPR[outPR]); + //allpass filter P + + dPR[6] = dPR[5]; + dPR[5] = dPR[4]; + dPR[4] = inputSampleR; + inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0; + + allpasstemp = outQR - 1; + if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;} + inputSampleR -= oQR[allpasstemp]*constallpass; + oQR[outQR] = inputSampleR; + inputSampleR *= constallpass; + outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;} + inputSampleR += (oQR[outQR]); + //allpass filter Q + + dQR[6] = dQR[5]; + dQR[5] = dQR[4]; + dQR[4] = inputSampleR; + inputSampleR = (dQR[4] + dQR[5] + dQR[6])/3.0; + + allpasstemp = outRR - 1; + if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;} + inputSampleR -= oRR[allpasstemp]*constallpass; + oRR[outRR] = inputSampleR; + inputSampleR *= constallpass; + outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;} + inputSampleR += (oRR[outRR]); + //allpass filter R + + dRR[6] = dRR[5]; + dRR[5] = dRR[4]; + dRR[4] = inputSampleR; + inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0; + + allpasstemp = outSR - 1; + if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;} + inputSampleR -= oSR[allpasstemp]*constallpass; + oSR[outSR] = inputSampleR; + inputSampleR *= constallpass; + outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;} + inputSampleR += (oSR[outSR]); + //allpass filter S + + dSR[6] = dSR[5]; + dSR[5] = dSR[4]; + dSR[4] = inputSampleR; + inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0; + + allpasstemp = outTR - 1; + if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;} + inputSampleR -= oTR[allpasstemp]*constallpass; + oTR[outTR] = inputSampleR; + inputSampleR *= constallpass; + outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;} + inputSampleR += (oTR[outTR]); + //allpass filter T + + dTR[6] = dTR[5]; + dTR[5] = dTR[4]; + dTR[4] = inputSampleR; + inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0; + + allpasstemp = outUR - 1; + if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;} + inputSampleR -= oUR[allpasstemp]*constallpass; + oUR[outUR] = inputSampleR; + inputSampleR *= constallpass; + outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;} + inputSampleR += (oUR[outUR]); + //allpass filter U + + dUR[6] = dUR[5]; + dUR[5] = dUR[4]; + dUR[4] = inputSampleR; + inputSampleR = (dUR[4] + dUR[5] + dUR[6])/3.0; + + allpasstemp = outVR - 1; + if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;} + inputSampleR -= oVR[allpasstemp]*constallpass; + oVR[outVR] = inputSampleR; + inputSampleR *= constallpass; + outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;} + inputSampleR += (oVR[outVR]); + //allpass filter V + + dVR[6] = dVR[5]; + dVR[5] = dVR[4]; + dVR[4] = inputSampleR; + inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0; + + allpasstemp = outWR - 1; + if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;} + inputSampleR -= oWR[allpasstemp]*constallpass; + oWR[outWR] = inputSampleR; + inputSampleR *= constallpass; + outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;} + inputSampleR += (oWR[outWR]); + //allpass filter W + + dWR[6] = dWR[5]; + dWR[5] = dWR[4]; + dWR[4] = inputSampleR; + inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0; + + allpasstemp = outXR - 1; + if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;} + inputSampleR -= oXR[allpasstemp]*constallpass; + oXR[outXR] = inputSampleR; + inputSampleR *= constallpass; + outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;} + inputSampleR += (oXR[outXR]); + //allpass filter X + + dXR[6] = dXR[5]; + dXR[5] = dXR[4]; + dXR[4] = inputSampleR; + inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0; + + allpasstemp = outYR - 1; + if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;} + inputSampleR -= oYR[allpasstemp]*constallpass; + oYR[outYR] = inputSampleR; + inputSampleR *= constallpass; + outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;} + inputSampleR += (oYR[outYR]); + //allpass filter Y + + dYR[6] = dYR[5]; + dYR[5] = dYR[4]; + dYR[4] = inputSampleR; + inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0; + + allpasstemp = outZR - 1; + if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;} + inputSampleR -= oZR[allpasstemp]*constallpass; + oZR[outZR] = inputSampleR; + inputSampleR *= constallpass; + outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;} + inputSampleR += (oZR[outZR]); + //allpass filter Z + + dZR[6] = dZR[5]; + dZR[5] = dZR[4]; + dZR[4] = inputSampleR; + inputSampleR = (dZR[4] + dZR[5] + dZR[6]); + //output Zarathustra infinite space verb + break; + + } + //end big switch for verb type + + bridgerectifier = fabs(inputSampleL); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleL > 0) inputSampleL -= bridgerectifier; + else inputSampleL += bridgerectifier; + inputSampleL /= gain; + bridgerectifier = fabs(inputSampleR); + bridgerectifier = 1.0-cos(bridgerectifier); + if (inputSampleR > 0) inputSampleR -= bridgerectifier; + else inputSampleR += bridgerectifier; + inputSampleR /= gain; + //here we apply the ADT2 'console on steroids' trick + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakL; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleL *= (1.0-wetness); + inputSampleL *= wetness; + inputSampleL += drySampleL; + //here we combine the tanks with the dry signal + + wetness = wetnesstarget; + //setting up verb wetness to be manipulated by gate and peak + + wetness *= peakR; + //but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want + + drySampleR *= (1.0-wetness); + inputSampleR *= wetness; + inputSampleR += drySampleR; + //here we combine the tanks with the dry signal + + //begin 64 bit stereo floating point dither + int expon; frexp((double)inputSampleL, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleL += ((double(fpd)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + frexp((double)inputSampleR, &expon); + fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5; + inputSampleR += ((double(fpd)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //end 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + *in1++; + *in2++; + *out1++; + *out2++; + } +} diff --git a/plugins/WinVST/PocketVerbs/VSTProject.sln b/plugins/WinVST/PocketVerbs/VSTProject.sln new file mode 100755 index 0000000..694b424 --- /dev/null +++ b/plugins/WinVST/PocketVerbs/VSTProject.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 14 +VisualStudioVersion = 14.0.25420.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VSTProject", "VSTProject.vcxproj", "{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x64.ActiveCfg = Debug|x64 + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x64.Build.0 = Debug|x64 + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x86.ActiveCfg = Debug|Win32 + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x86.Build.0 = Debug|Win32 + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x64.ActiveCfg = Release|x64 + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x64.Build.0 = Release|x64 + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x86.ActiveCfg = Release|Win32 + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/plugins/WinVST/PocketVerbs/VSTProject.vcxproj b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj new file mode 100755 index 0000000..5b73613 --- /dev/null +++ b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj @@ -0,0 +1,183 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + + + + + + + + + + + + + + {16F7AB3C-1AE0-4574-B60C-7B4DED82938C} + VSTProject + 8.1 + PocketVerbs64 + + + + DynamicLibrary + true + v140 + NotSet + + + DynamicLibrary + false + v140 + false + NotSet + + + DynamicLibrary + true + v140 + NotSet + + + DynamicLibrary + false + v140 + false + NotSet + + + + + + + + + + + + + + + + + + + + + .dll + + + $(SolutionDir)$(Configuration)\ + $(Configuration)\ + $(VC_ExecutablePath_x64);$(WindowsSDK_ExecutablePath);$(VS_ExecutablePath);$(MSBuild_ExecutablePath);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH) + + + $(SolutionDir)$(Configuration)\ + $(Configuration)\ + $(VC_ExecutablePath_x64);$(WindowsSDK_ExecutablePath);$(VS_ExecutablePath);$(MSBuild_ExecutablePath);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH) + + + + Level3 + MaxSpeed + true + C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories) + WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions) + MultiThreadedDebug + Speed + false + Default + false + None + + + vstplug.def + libcmt.dll;libcmtd.dll;msvcrt.lib;%(IgnoreSpecificDefaultLibraries) + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies) + + + + + Level3 + MaxSpeed + true + C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories) + Speed + WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions) + false + MultiThreadedDebug + Default + false + None + + + kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies) + libcmt.dll;libcmtd.dll;msvcrt.lib;%(IgnoreSpecificDefaultLibraries) + vstplug.def + + + + + Level3 + MaxSpeed + false + false + true + MultiThreaded + C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories) + None + Speed + WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions) + + + true + true + libcmt.dll;libcmtd.dll;msvcrt.lib;libc.lib;libcd.lib;libcmt.lib;msvcrtd.lib;%(IgnoreSpecificDefaultLibraries) + libcmt.lib;uuid.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies) + vstplug.def + + + + + Level3 + MaxSpeed + false + false + true + C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories) + None + Speed + WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions) + MultiThreaded + + + true + true + libcmt.dll;libcmtd.dll;msvcrt.lib;libc.lib;libcd.lib;libcmt.lib;msvcrtd.lib;%(IgnoreSpecificDefaultLibraries) + libcmt.lib;uuid.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies) + vstplug.def + + + + + + \ No newline at end of file diff --git a/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.filters b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.filters new file mode 100755 index 0000000..55debca --- /dev/null +++ b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.filters @@ -0,0 +1,48 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + \ No newline at end of file diff --git a/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.user b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.user new file mode 100755 index 0000000..2216267 --- /dev/null +++ b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.user @@ -0,0 +1,19 @@ + + + + {ADEFF70D-84BF-47A1-91C3-FF6B0FC71218} + WindowsLocalDebugger + + + {ADEFF70D-84BF-47A1-91C3-FF6B0FC71218} + WindowsLocalDebugger + + + {ADEFF70D-84BF-47A1-91C3-FF6B0FC71218} + WindowsLocalDebugger + + + {ADEFF70D-84BF-47A1-91C3-FF6B0FC71218} + WindowsLocalDebugger + + \ No newline at end of file diff --git a/plugins/WinVST/PocketVerbs/vstplug.def b/plugins/WinVST/PocketVerbs/vstplug.def new file mode 100755 index 0000000..5bf499a --- /dev/null +++ b/plugins/WinVST/PocketVerbs/vstplug.def @@ -0,0 +1,3 @@ +EXPORTS + VSTPluginMain + main=VSTPluginMain \ No newline at end of file -- cgit v1.2.3