github-starred/airwindows
2
0
Fork 0
mirror of https://github.com/airwindows/airwindows.git synced 2026-05-21 06:46:21 -06:00
Code Issues 33 Projects Packages Wiki Activity Actions

MatrixVerb

Browse source
This commit is contained in:
Chris Johnson 2021-01-03 19:58:52 -05:00
parent b155145346
commit 57dea44c96
44 changed files with 13786 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

132
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/christopherjohnson.pbxuser Executable file
View file

@ -0,0 +1,132 @@
// !$*UTF8*$!
{
089C1669FE841209C02AAC07 /* Project object */ = {
activeBuildConfigurationName = Release;
activeTarget = 8D01CCC60486CAD60068D4B7 /* MatrixVerb */;
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 = 631158209;
PBXWorkspaceStateSaveDate = 631158209;
};
perUserProjectItems = {
8BE20B73259EB6BA00009ECB /* PBXTextBookmark */ = 8BE20B73259EB6BA00009ECB /* PBXTextBookmark */;
8BE20B74259EB6BA00009ECB /* PBXTextBookmark */ = 8BE20B74259EB6BA00009ECB /* PBXTextBookmark */;
};
sourceControlManager = 8B02375E1D42B1C400E1E8C8 /* Source Control */;
userBuildSettings = {
};
};
2407DEB6089929BA00EB68BF /* MatrixVerb.cpp */ = {
uiCtxt = {
sepNavIntBoundsRect = "{{0, 0}, {948, 4338}}";
sepNavSelRange = "{460, 2475}";
sepNavVisRange = "{4854, 1273}";
sepNavWindowFrame = "{{547, 47}, {895, 831}}";
};
};
245463B80991757100464AD3 /* MatrixVerb.h */ = {
uiCtxt = {
sepNavIntBoundsRect = "{{0, 0}, {1110, 2502}}";
sepNavSelRange = "{2475, 1516}";
sepNavVisRange = "{1820, 1221}";
sepNavWindowFrame = "{{26, 47}, {895, 831}}";
};
};
24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */ = {
uiCtxt = {
sepNavIntBoundsRect = "{{0, 0}, {859, 20267}}";
sepNavSelRange = "{10616, 0}";
sepNavVisRange = "{9653, 2414}";
sepNavWindowFrame = "{{15, 42}, {895, 831}}";
};
};
24D8286F09A914000093AEF8 /* MatrixVerbProc.cpp */ = {
uiCtxt = {
sepNavIntBoundsRect = "{{0, 0}, {714, 14526}}";
sepNavSelRange = "{19195, 0}";
sepNavVisRange = "{19552, 42}";
sepNavWindowFrame = "{{386, 42}, {990, 836}}";
};
};
8B02375E1D42B1C400E1E8C8 /* Source Control */ = {
isa = PBXSourceControlManager;
fallbackIsa = XCSourceControlManager;
isSCMEnabled = 0;
scmConfiguration = {
repositoryNamesForRoots = {
"" = "";
};
};
};
8B02375F1D42B1C400E1E8C8 /* Code sense */ = {
isa = PBXCodeSenseManager;
indexTemplatePath = "";
};
8BE20B73259EB6BA00009ECB /* PBXTextBookmark */ = {
isa = PBXTextBookmark;
fRef = 24D8286F09A914000093AEF8 /* MatrixVerbProc.cpp */;
name = "MatrixVerbProc.cpp: 460";
rLen = 0;
rLoc = 19195;
rType = 0;
vrLen = 109;
vrLoc = 19878;
};
8BE20B74259EB6BA00009ECB /* PBXTextBookmark */ = {
isa = PBXTextBookmark;
fRef = 24D8286F09A914000093AEF8 /* MatrixVerbProc.cpp */;
name = "MatrixVerbProc.cpp: 443";
rLen = 0;
rLoc = 19195;
rType = 0;
vrLen = 42;
vrLoc = 19552;
};
8D01CCC60486CAD60068D4B7 /* MatrixVerb */ = {
activeExec = 0;
};
}

1510
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/christopherjohnson.perspectivev3 Executable file
View file

File diff suppressed because it is too large Load diff

2201
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/project.pbxproj Executable file
View file

File diff suppressed because it is too large Load diff

7
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/project.xcworkspace/contents.xcworkspacedata generated Executable file
View file

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<Workspace
version = "1.0">
<FileRef
location = "self:Sample.xcodeproj">
</FileRef>
</Workspace>

BIN
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/project.xcworkspace/xcuserdata/christopherjohnson.xcuserdatad/UserInterfaceState.xcuserstate generated Executable file
View file

Binary file not shown.

BIN
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/project.xcworkspace/xcuserdata/spiadmin.xcuserdatad/UserInterfaceState.xcuserstate generated Executable file
View file

Binary file not shown.

1372
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/spiadmin.mode1v3 Executable file
View file

File diff suppressed because it is too large Load diff

143
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/spiadmin.pbxuser Executable file
View file

@ -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 = "";
};
}

80
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/Gain.xcscheme Executable file
View file

@ -0,0 +1,80 @@
<?xml version="1.0" encoding="UTF-8"?>
<Scheme
LastUpgradeVersion = "0720"
version = "1.3">
<BuildAction
parallelizeBuildables = "YES"
buildImplicitDependencies = "YES">
<BuildActionEntries>
<BuildActionEntry
buildForTesting = "YES"
buildForRunning = "YES"
buildForProfiling = "YES"
buildForArchiving = "YES"
buildForAnalyzing = "YES">
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
BuildableName = "Gain.vst"
BlueprintName = "Gain"
ReferencedContainer = "container:Gain.xcodeproj">
</BuildableReference>
</BuildActionEntry>
</BuildActionEntries>
</BuildAction>
<TestAction
buildConfiguration = "Debug"
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
shouldUseLaunchSchemeArgsEnv = "YES">
<Testables>
</Testables>
<AdditionalOptions>
</AdditionalOptions>
</TestAction>
<LaunchAction
buildConfiguration = "Debug"
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
launchStyle = "0"
useCustomWorkingDirectory = "NO"
ignoresPersistentStateOnLaunch = "NO"
debugDocumentVersioning = "YES"
debugServiceExtension = "internal"
allowLocationSimulation = "YES">
<MacroExpansion>
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
BuildableName = "Gain.vst"
BlueprintName = "Gain"
ReferencedContainer = "container:Gain.xcodeproj">
</BuildableReference>
</MacroExpansion>
<AdditionalOptions>
</AdditionalOptions>
</LaunchAction>
<ProfileAction
buildConfiguration = "Release"
shouldUseLaunchSchemeArgsEnv = "YES"
savedToolIdentifier = ""
useCustomWorkingDirectory = "NO"
debugDocumentVersioning = "YES">
<MacroExpansion>
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
BuildableName = "Gain.vst"
BlueprintName = "Gain"
ReferencedContainer = "container:Gain.xcodeproj">
</BuildableReference>
</MacroExpansion>
</ProfileAction>
<AnalyzeAction
buildConfiguration = "Debug">
</AnalyzeAction>
<ArchiveAction
buildConfiguration = "Release"
revealArchiveInOrganizer = "YES">
</ArchiveAction>
</Scheme>

22
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/xcschememanagement.plist Executable file
View file

@ -0,0 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>SchemeUserState</key>
<dict>
<key>Gain.xcscheme</key>
<dict>
<key>orderHint</key>
<integer>8</integer>
</dict>
</dict>
<key>SuppressBuildableAutocreation</key>
<dict>
<key>8D01CCC60486CAD60068D4B7</key>
<dict>
<key>primary</key>
<true/>
</dict>
</dict>
</dict>
</plist>

22
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/xcschememanagement.plist Executable file
View file

@ -0,0 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>SchemeUserState</key>
<dict>
<key>«PROJECTNAME».xcscheme</key>
<dict>
<key>orderHint</key>
<integer>0</integer>
</dict>
</dict>
<key>SuppressBuildableAutocreation</key>
<dict>
<key>8D01CCC60486CAD60068D4B7</key>
<dict>
<key>primary</key>
<true/>
</dict>
</dict>
</dict>
</plist>

57
plugins/MacVST/MatrixVerb/MatrixVerb.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/«PROJECTNAME».xcscheme Executable file
View file

@ -0,0 +1,57 @@
<?xml version="1.0" encoding="UTF-8"?>
<Scheme
version = "1.3">
<BuildAction
parallelizeBuildables = "YES"
buildImplicitDependencies = "YES">
<BuildActionEntries>
<BuildActionEntry
buildForTesting = "YES"
buildForRunning = "YES"
buildForProfiling = "YES"
buildForArchiving = "YES"
buildForAnalyzing = "YES">
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
BuildableName = "&#171;PROJECTNAME&#187;.vst"
BlueprintName = "&#171;PROJECTNAME&#187;"
ReferencedContainer = "container:Sample.xcodeproj">
</BuildableReference>
</BuildActionEntry>
</BuildActionEntries>
</BuildAction>
<TestAction
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.GDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.GDB"
shouldUseLaunchSchemeArgsEnv = "YES"
buildConfiguration = "Debug">
<Testables>
</Testables>
</TestAction>
<LaunchAction
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.GDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.GDB"
launchStyle = "0"
useCustomWorkingDirectory = "NO"
buildConfiguration = "Debug"
debugDocumentVersioning = "YES"
allowLocationSimulation = "YES">
<AdditionalOptions>
</AdditionalOptions>
</LaunchAction>
<ProfileAction
shouldUseLaunchSchemeArgsEnv = "YES"
savedToolIdentifier = ""
useCustomWorkingDirectory = "NO"
buildConfiguration = "Release"
debugDocumentVersioning = "YES">
</ProfileAction>
<AnalyzeAction
buildConfiguration = "Debug">
</AnalyzeAction>
<ArchiveAction
buildConfiguration = "Release"
revealArchiveInOrganizer = "YES">
</ArchiveAction>
</Scheme>

24
plugins/MacVST/MatrixVerb/mac/Info.plist Executable file
View file

@ -0,0 +1,24 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>CFBundleDevelopmentRegion</key>
<string>English</string>
<key>CFBundleExecutable</key>
<string>MatrixVerb</string>
<key>CFBundleIconFile</key>
<string></string>
<key>CFBundleIdentifier</key>
<string>com.airwindows.MatrixVerb</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundlePackageType</key>
<string>BNDL</string>
<key>CFBundleSignature</key>
<string>Dthr</string>
<key>CFBundleVersion</key>
<string>1.0</string>
<key>CSResourcesFileMapped</key>
<true/>
</dict>
</plist>

1
plugins/MacVST/MatrixVerb/mac/PkgInfo Executable file
View file

@ -0,0 +1 @@
BNDL????

17
plugins/MacVST/MatrixVerb/mac/xcode_vst_prefix.h Executable file
View file

@ -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 <AvailabilityMacros.h>

240
plugins/MacVST/MatrixVerb/source/MatrixVerb.cpp Executable file
View file

@ -0,0 +1,240 @@
/* ========================================
* MatrixVerb - MatrixVerb.h
* Copyright (c) 2016 airwindows, All rights reserved
* ======================================== */
#ifndef __MatrixVerb_H
#include "MatrixVerb.h"
#endif
AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new MatrixVerb(audioMaster);}
MatrixVerb::MatrixVerb(audioMasterCallback audioMaster) :
AudioEffectX(audioMaster, kNumPrograms, kNumParameters)
{
for (int x = 0; x < 11; x++) {biquadA[x] = 0.0;biquadB[x] = 0.0;biquadC[x] = 0.0;}
feedbackAL = feedbackAR = 0.0;
feedbackBL = feedbackBR = 0.0;
feedbackCL = feedbackCR = 0.0;
feedbackDL = feedbackDR = 0.0;
feedbackEL = feedbackER = 0.0;
feedbackFL = feedbackFR = 0.0;
feedbackGL = feedbackGR = 0.0;
feedbackHL = feedbackHR = 0.0;
int count;
for(count = 0; count < 8110; count++) {aAL[count] = aAR[count] = 0.0;}
for(count = 0; count < 7510; count++) {aBL[count] = aBR[count] = 0.0;}
for(count = 0; count < 7310; count++) {aCL[count] = aCR[count] = 0.0;}
for(count = 0; count < 6910; count++) {aDL[count] = aDR[count] = 0.0;}
for(count = 0; count < 6310; count++) {aEL[count] = aER[count] = 0.0;}
for(count = 0; count < 6110; count++) {aFL[count] = aFR[count] = 0.0;}
for(count = 0; count < 5510; count++) {aGL[count] = aGR[count] = 0.0;}
for(count = 0; count < 4910; count++) {aHL[count] = aHR[count] = 0.0;}
//maximum value needed will be delay * 100, plus 206 (absolute max vibrato depth)
for(count = 0; count < 4510; count++) {aIL[count] = aIR[count] = 0.0;}
for(count = 0; count < 4310; count++) {aJL[count] = aJR[count] = 0.0;}
for(count = 0; count < 3910; count++) {aKL[count] = aKR[count] = 0.0;}
for(count = 0; count < 3310; count++) {aLL[count] = aLR[count] = 0.0;}
//maximum value will be delay * 100
for(count = 0; count < 3110; count++) {aML[count] = aMR[count] = 0.0;}
//maximum value will be delay * 100
countA = 1; delayA = 79;
countB = 1; delayB = 73;
countC = 1; delayC = 71;
countD = 1; delayD = 67;
countE = 1; delayE = 61;
countF = 1; delayF = 59;
countG = 1; delayG = 53;
countH = 1; delayH = 47;
//the householder matrices
countI = 1; delayI = 43;
countJ = 1; delayJ = 41;
countK = 1; delayK = 37;
countL = 1; delayL = 31;
//the allpasses
countM = 1; delayM = 29;
//the predelay
depthA = 0.003251;
depthB = 0.002999;
depthC = 0.002917;
depthD = 0.002749;
depthE = 0.002503;
depthF = 0.002423;
depthG = 0.002146;
depthH = 0.002088;
//the individual vibrato rates for the delays
vibAL = rand()*-2147483647;
vibBL = rand()*-2147483647;
vibCL = rand()*-2147483647;
vibDL = rand()*-2147483647;
vibEL = rand()*-2147483647;
vibFL = rand()*-2147483647;
vibGL = rand()*-2147483647;
vibHL = rand()*-2147483647;
vibAR = rand()*-2147483647;
vibBR = rand()*-2147483647;
vibCR = rand()*-2147483647;
vibDR = rand()*-2147483647;
vibER = rand()*-2147483647;
vibFR = rand()*-2147483647;
vibGR = rand()*-2147483647;
vibHR = rand()*-2147483647;
A = 1.0;
B = 0.0;
C = 0.0;
D = 0.0;
E = 0.5;
F = 0.5;
G = 1.0;
fpdL = 1.0; while (fpdL < 16386) fpdL = rand()*UINT32_MAX;
fpdR = 1.0; while (fpdR < 16386) fpdR = rand()*UINT32_MAX;
//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
}
MatrixVerb::~MatrixVerb() {}
VstInt32 MatrixVerb::getVendorVersion () {return 1000;}
void MatrixVerb::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);}
void MatrixVerb::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 MatrixVerb::getChunk (void** data, bool isPreset)
{
float *chunkData = (float *)calloc(kNumParameters, sizeof(float));
chunkData[0] = A;
chunkData[1] = B;
chunkData[2] = C;
chunkData[3] = D;
chunkData[4] = E;
chunkData[5] = F;
chunkData[6] = G;
/* 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 MatrixVerb::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]);
E = pinParameter(chunkData[4]);
F = pinParameter(chunkData[5]);
G = pinParameter(chunkData[6]);
/* 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 MatrixVerb::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;
case kParamE: E = value; break;
case kParamF: F = value; break;
case kParamG: G = value; break;
default: throw; // unknown parameter, shouldn't happen!
}
}
float MatrixVerb::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;
case kParamE: return E; break;
case kParamF: return F; break;
case kParamG: return G; 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 MatrixVerb::getParameterName(VstInt32 index, char *text) {
switch (index) {
case kParamA: vst_strncpy (text, "Filter", kVstMaxParamStrLen); break;
case kParamB: vst_strncpy (text, "Damping", kVstMaxParamStrLen); break;
case kParamC: vst_strncpy (text, "Speed", kVstMaxParamStrLen); break;
case kParamD: vst_strncpy (text, "Vibrato", kVstMaxParamStrLen); break;
case kParamE: vst_strncpy (text, "RmSize", kVstMaxParamStrLen); break;
case kParamF: vst_strncpy (text, "Flavor", kVstMaxParamStrLen); break;
case kParamG: 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 MatrixVerb::getParameterDisplay(VstInt32 index, char *text) {
switch (index) {
case kParamA: float2string (A, text, kVstMaxParamStrLen); break;
case kParamB: float2string (B, text, kVstMaxParamStrLen); break;
case kParamC: float2string (C, text, kVstMaxParamStrLen); break;
case kParamD: float2string (D, text, kVstMaxParamStrLen); break;
case kParamE: float2string (E, text, kVstMaxParamStrLen); break;
case kParamF: float2string (F, text, kVstMaxParamStrLen); break;
case kParamG: float2string (G, text, kVstMaxParamStrLen); break;
default: break; // unknown parameter, shouldn't happen!
} //this displays the values and handles 'popups' where it's discrete choices
}
void MatrixVerb::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;
case kParamE: vst_strncpy (text, "", kVstMaxParamStrLen); break;
case kParamF: vst_strncpy (text, "", kVstMaxParamStrLen); break;
case kParamG: vst_strncpy (text, "", kVstMaxParamStrLen); break;
default: break; // unknown parameter, shouldn't happen!
}
}
VstInt32 MatrixVerb::canDo(char *text)
{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know
bool MatrixVerb::getEffectName(char* name) {
vst_strncpy(name, "MatrixVerb", kVstMaxProductStrLen); return true;
}
VstPlugCategory MatrixVerb::getPlugCategory() {return kPlugCategEffect;}
bool MatrixVerb::getProductString(char* text) {
vst_strncpy (text, "airwindows MatrixVerb", kVstMaxProductStrLen); return true;
}
bool MatrixVerb::getVendorString(char* text) {
vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true;
}

138
plugins/MacVST/MatrixVerb/source/MatrixVerb.h Executable file
View file

@ -0,0 +1,138 @@
/* ========================================
* MatrixVerb - MatrixVerb.h
* Created 8/12/11 by SPIAdmin
* Copyright (c) 2011 __MyCompanyName__, All rights reserved
* ======================================== */
#ifndef __MatrixVerb_H
#define __MatrixVerb_H
#ifndef __audioeffect__
#include "audioeffectx.h"
#endif
#include <set>
#include <string>
#include <math.h>
enum {
kParamA = 0,
kParamB = 1,
kParamC = 2,
kParamD = 3,
kParamE = 4,
kParamF = 5,
kParamG = 6,
kNumParameters = 7
}; //
const int kNumPrograms = 0;
const int kNumInputs = 2;
const int kNumOutputs = 2;
const unsigned long kUniqueId = 'mxvb'; //Change this to what the AU identity is!
class MatrixVerb :
public AudioEffectX
{
public:
MatrixVerb(audioMasterCallback audioMaster);
~MatrixVerb();
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;
long double biquadA[11];
long double biquadB[11];
long double biquadC[11];
double aAL[8111];
double aBL[7511];
double aCL[7311];
double aDL[6911];
double aEL[6311];
double aFL[6111];
double aGL[5511];
double aHL[4911];
double aIL[4511];
double aJL[4311];
double aKL[3911];
double aLL[3311];
double aML[3111];
double aAR[8111];
double aBR[7511];
double aCR[7311];
double aDR[6911];
double aER[6311];
double aFR[6111];
double aGR[5511];
double aHR[4911];
double aIR[4511];
double aJR[4311];
double aKR[3911];
double aLR[3311];
double aMR[3111];
int countA, delayA;
int countB, delayB;
int countC, delayC;
int countD, delayD;
int countE, delayE;
int countF, delayF;
int countG, delayG;
int countH, delayH;
int countI, delayI;
int countJ, delayJ;
int countK, delayK;
int countL, delayL;
int countM, delayM;
double feedbackAL, vibAL, depthA;
double feedbackBL, vibBL, depthB;
double feedbackCL, vibCL, depthC;
double feedbackDL, vibDL, depthD;
double feedbackEL, vibEL, depthE;
double feedbackFL, vibFL, depthF;
double feedbackGL, vibGL, depthG;
double feedbackHL, vibHL, depthH;
double feedbackAR, vibAR;
double feedbackBR, vibBR;
double feedbackCR, vibCR;
double feedbackDR, vibDR;
double feedbackER, vibER;
double feedbackFR, vibFR;
double feedbackGR, vibGR;
double feedbackHR, vibHR;
uint32_t fpdL;
uint32_t fpdR;
//default stuff
float A;
float B;
float C;
float D;
float E;
float F;
float G;
};
#endif

794
plugins/MacVST/MatrixVerb/source/MatrixVerbProc.cpp Executable file
View file

@ -0,0 +1,794 @@
/* ========================================
* MatrixVerb - MatrixVerb.h
* Copyright (c) 2016 airwindows, All rights reserved
* ======================================== */
#ifndef __MatrixVerb_H
#include "MatrixVerb.h"
#endif
void MatrixVerb::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames)
{
float* in1 = inputs[0];
float* in2 = inputs[1];
float* out1 = outputs[0];
float* out2 = outputs[1];
double overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= getSampleRate();
biquadC[0] = biquadB[0] = biquadA[0] = ((A*9000.0)+1000.0) / getSampleRate();
biquadA[1] = 1.618033988749894848204586;
biquadB[1] = 0.618033988749894848204586;
biquadC[1] = 0.5;
double K = tan(M_PI * biquadA[0]); //lowpass
double norm = 1.0 / (1.0 + K / biquadA[1] + K * K);
biquadA[2] = K * K * norm;
biquadA[3] = 2.0 * biquadA[2];
biquadA[4] = biquadA[2];
biquadA[5] = 2.0 * (K * K - 1.0) * norm;
biquadA[6] = (1.0 - K / biquadA[1] + K * K) * norm;
K = tan(M_PI * biquadA[0]);
norm = 1.0 / (1.0 + K / biquadB[1] + K * K);
biquadB[2] = K * K * norm;
biquadB[3] = 2.0 * biquadB[2];
biquadB[4] = biquadB[2];
biquadB[5] = 2.0 * (K * K - 1.0) * norm;
biquadB[6] = (1.0 - K / biquadB[1] + K * K) * norm;
K = tan(M_PI * biquadC[0]);
norm = 1.0 / (1.0 + K / biquadC[1] + K * K);
biquadC[2] = K * K * norm;
biquadC[3] = 2.0 * biquadC[2];
biquadC[4] = biquadC[2];
biquadC[5] = 2.0 * (K * K - 1.0) * norm;
biquadC[6] = (1.0 - K / biquadC[1] + K * K) * norm;
double vibSpeed = 0.06+C;
double vibDepth = (0.027+pow(D,3))*100.0;
double size = (pow(E,2)*90.0)+10.0;
double depthFactor = 1.0-pow((1.0-(0.82-((B*0.5)+(size*0.002)))),4);
double blend = 0.955-(size*0.007);
double crossmod = (F-0.5)*2.0;
crossmod = pow(crossmod,3)*0.5;
double regen = depthFactor * (0.5 - (fabs(crossmod)*0.031));
double wet = G;
delayA = 79*size;
delayB = 73*size;
delayC = 71*size;
delayD = 67*size;
delayE = 61*size;
delayF = 59*size;
delayG = 53*size;
delayH = 47*size;
delayI = 43*size;
delayJ = 41*size;
delayK = 37*size;
delayL = 31*size;
delayM = (29*size)-(56*size*fabs(crossmod));
//predelay for natural spaces, gets cut back for heavily artificial spaces
while (--sampleFrames >= 0)
{
long double inputSampleL = *in1;
long double inputSampleR = *in2;
if (fabs(inputSampleL)<1.18e-37) inputSampleL = fpdL * 1.18e-37;
if (fabs(inputSampleR)<1.18e-37) inputSampleR = fpdR * 1.18e-37;
long double drySampleL = inputSampleL;
long double drySampleR = inputSampleR;
aML[countM] = inputSampleL;
aMR[countM] = inputSampleR;
countM++; if (countM < 0 || countM > delayM) {countM = 0;}
inputSampleL = aML[countM];
inputSampleR = aMR[countM];
//predelay
long double tempSampleL = (inputSampleL * biquadA[2]) + biquadA[7];
biquadA[7] = (inputSampleL * biquadA[3]) - (tempSampleL * biquadA[5]) + biquadA[8];
biquadA[8] = (inputSampleL * biquadA[4]) - (tempSampleL * biquadA[6]);
inputSampleL = tempSampleL; //like mono AU, 7 and 8 store L channel
long double tempSampleR = (inputSampleR * biquadA[2]) + biquadA[9];
biquadA[9] = (inputSampleR * biquadA[3]) - (tempSampleR * biquadA[5]) + biquadA[10];
biquadA[10] = (inputSampleR * biquadA[4]) - (tempSampleR * biquadA[6]);
inputSampleR = tempSampleR; //note: 9 and 10 store the R channel
inputSampleL *= wet;
inputSampleR *= wet;
//we're going to use this as a kind of balance since the reverb buildup can be so large
inputSampleL = sin(inputSampleL);
inputSampleR = sin(inputSampleR);
long double allpassIL = inputSampleL;
long double allpassJL = inputSampleL;
long double allpassKL = inputSampleL;
long double allpassLL = inputSampleL;
long double allpassIR = inputSampleR;
long double allpassJR = inputSampleR;
long double allpassKR = inputSampleR;
long double allpassLR = inputSampleR;
int allpasstemp = countI + 1;
if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = 0;}
allpassIL -= aIL[allpasstemp]*0.5;
aIL[countI] = allpassIL;
allpassIL *= 0.5;
allpassIR -= aIR[allpasstemp]*0.5;
aIR[countI] = allpassIR;
allpassIR *= 0.5;
countI++; if (countI < 0 || countI > delayI) {countI = 0;}
allpassIL += (aIL[countI]);
allpassIR += (aIR[countI]);
allpasstemp = countJ + 1;
if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = 0;}
allpassJL -= aJL[allpasstemp]*0.5;
aJL[countJ] = allpassJL;
allpassJL *= 0.5;
allpassJR -= aJR[allpasstemp]*0.5;
aJR[countJ] = allpassJR;
allpassJR *= 0.5;
countJ++; if (countJ < 0 || countJ > delayJ) {countJ = 0;}
allpassJL += (aJL[countJ]);
allpassJR += (aJR[countJ]);
allpasstemp = countK + 1;
if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = 0;}
allpassKL -= aKL[allpasstemp]*0.5;
aKL[countK] = allpassKL;
allpassKL *= 0.5;
allpassKR -= aKR[allpasstemp]*0.5;
aKR[countK] = allpassKR;
allpassKR *= 0.5;
countK++; if (countK < 0 || countK > delayK) {countK = 0;}
allpassKL += (aKL[countK]);
allpassKR += (aKR[countK]);
allpasstemp = countL + 1;
if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = 0;}
allpassLL -= aLL[allpasstemp]*0.5;
aLL[countL] = allpassLL;
allpassLL *= 0.5;
allpassLR -= aLR[allpasstemp]*0.5;
aLR[countL] = allpassLR;
allpassLR *= 0.5;
countL++; if (countL < 0 || countL > delayL) {countL = 0;}
allpassLL += (aLL[countL]);
allpassLR += (aLR[countL]);
//the big allpass in front of everything
aAL[countA] = allpassLL + feedbackAL;
aBL[countB] = allpassKL + feedbackBL;
aCL[countC] = allpassJL + feedbackCL;
aDL[countD] = allpassIL + feedbackDL;
aEL[countE] = allpassIL + feedbackEL;
aFL[countF] = allpassJL + feedbackFL;
aGL[countG] = allpassKL + feedbackGL;
aHL[countH] = allpassLL + feedbackHL; //L
aAR[countA] = allpassLR + feedbackAR;
aBR[countB] = allpassKR + feedbackBR;
aCR[countC] = allpassJR + feedbackCR;
aDR[countD] = allpassIR + feedbackDR;
aER[countE] = allpassIR + feedbackER;
aFR[countF] = allpassJR + feedbackFR;
aGR[countG] = allpassKR + feedbackGR;
aHR[countH] = allpassLR + feedbackHR; //R
countA++; if (countA < 0 || countA > delayA) {countA = 0;}
countB++; if (countB < 0 || countB > delayB) {countB = 0;}
countC++; if (countC < 0 || countC > delayC) {countC = 0;}
countD++; if (countD < 0 || countD > delayD) {countD = 0;}
countE++; if (countE < 0 || countE > delayE) {countE = 0;}
countF++; if (countF < 0 || countF > delayF) {countF = 0;}
countG++; if (countG < 0 || countG > delayG) {countG = 0;}
countH++; if (countH < 0 || countH > delayH) {countH = 0;}
//the Householder matrices (shared between channels, offset is stereo)
vibAL += (depthA * vibSpeed);
vibBL += (depthB * vibSpeed);
vibCL += (depthC * vibSpeed);
vibDL += (depthD * vibSpeed);
vibEL += (depthE * vibSpeed);
vibFL += (depthF * vibSpeed);
vibGL += (depthG * vibSpeed);
vibHL += (depthH * vibSpeed); //L
vibAR += (depthA * vibSpeed);
vibBR += (depthB * vibSpeed);
vibCR += (depthC * vibSpeed);
vibDR += (depthD * vibSpeed);
vibER += (depthE * vibSpeed);
vibFR += (depthF * vibSpeed);
vibGR += (depthG * vibSpeed);
vibHR += (depthH * vibSpeed); //R
//Depth is shared, but each started at a random position
double offsetAL = (sin(vibAL)+1.0)*vibDepth;
double offsetBL = (sin(vibBL)+1.0)*vibDepth;
double offsetCL = (sin(vibCL)+1.0)*vibDepth;
double offsetDL = (sin(vibDL)+1.0)*vibDepth;
double offsetEL = (sin(vibEL)+1.0)*vibDepth;
double offsetFL = (sin(vibFL)+1.0)*vibDepth;
double offsetGL = (sin(vibGL)+1.0)*vibDepth;
double offsetHL = (sin(vibHL)+1.0)*vibDepth; //L
double offsetAR = (sin(vibAR)+1.0)*vibDepth;
double offsetBR = (sin(vibBR)+1.0)*vibDepth;
double offsetCR = (sin(vibCR)+1.0)*vibDepth;
double offsetDR = (sin(vibDR)+1.0)*vibDepth;
double offsetER = (sin(vibER)+1.0)*vibDepth;
double offsetFR = (sin(vibFR)+1.0)*vibDepth;
double offsetGR = (sin(vibGR)+1.0)*vibDepth;
double offsetHR = (sin(vibHR)+1.0)*vibDepth; //R
int workingAL = countA + offsetAL;
int workingBL = countB + offsetBL;
int workingCL = countC + offsetCL;
int workingDL = countD + offsetDL;
int workingEL = countE + offsetEL;
int workingFL = countF + offsetFL;
int workingGL = countG + offsetGL;
int workingHL = countH + offsetHL; //L
int workingAR = countA + offsetAR;
int workingBR = countB + offsetBR;
int workingCR = countC + offsetCR;
int workingDR = countD + offsetDR;
int workingER = countE + offsetER;
int workingFR = countF + offsetFR;
int workingGR = countG + offsetGR;
int workingHR = countH + offsetHR; //R
double interpolAL = (aAL[workingAL-((workingAL > delayA)?delayA+1:0)] * (1-(offsetAL-floor(offsetAL))) );
interpolAL += (aAL[workingAL+1-((workingAL+1 > delayA)?delayA+1:0)] * ((offsetAL-floor(offsetAL))) );
double interpolBL = (aBL[workingBL-((workingBL > delayB)?delayB+1:0)] * (1-(offsetBL-floor(offsetBL))) );
interpolBL += (aBL[workingBL+1-((workingBL+1 > delayB)?delayB+1:0)] * ((offsetBL-floor(offsetBL))) );
double interpolCL = (aCL[workingCL-((workingCL > delayC)?delayC+1:0)] * (1-(offsetCL-floor(offsetCL))) );
interpolCL += (aCL[workingCL+1-((workingCL+1 > delayC)?delayC+1:0)] * ((offsetCL-floor(offsetCL))) );
double interpolDL = (aDL[workingDL-((workingDL > delayD)?delayD+1:0)] * (1-(offsetDL-floor(offsetDL))) );
interpolDL += (aDL[workingDL+1-((workingDL+1 > delayD)?delayD+1:0)] * ((offsetDL-floor(offsetDL))) );
double interpolEL = (aEL[workingEL-((workingEL > delayE)?delayE+1:0)] * (1-(offsetEL-floor(offsetEL))) );
interpolEL += (aEL[workingEL+1-((workingEL+1 > delayE)?delayE+1:0)] * ((offsetEL-floor(offsetEL))) );
double interpolFL = (aFL[workingFL-((workingFL > delayF)?delayF+1:0)] * (1-(offsetFL-floor(offsetFL))) );
interpolFL += (aFL[workingFL+1-((workingFL+1 > delayF)?delayF+1:0)] * ((offsetFL-floor(offsetFL))) );
double interpolGL = (aGL[workingGL-((workingGL > delayG)?delayG+1:0)] * (1-(offsetGL-floor(offsetGL))) );
interpolGL += (aGL[workingGL+1-((workingGL+1 > delayG)?delayG+1:0)] * ((offsetGL-floor(offsetGL))) );
double interpolHL = (aHL[workingHL-((workingHL > delayH)?delayH+1:0)] * (1-(offsetHL-floor(offsetHL))) );
interpolHL += (aHL[workingHL+1-((workingHL+1 > delayH)?delayH+1:0)] * ((offsetHL-floor(offsetHL))) );
//L
double interpolAR = (aAR[workingAR-((workingAR > delayA)?delayA+1:0)] * (1-(offsetAR-floor(offsetAR))) );
interpolAR += (aAR[workingAR+1-((workingAR+1 > delayA)?delayA+1:0)] * ((offsetAR-floor(offsetAR))) );
double interpolBR = (aBR[workingBR-((workingBR > delayB)?delayB+1:0)] * (1-(offsetBR-floor(offsetBR))) );
interpolBR += (aBR[workingBR+1-((workingBR+1 > delayB)?delayB+1:0)] * ((offsetBR-floor(offsetBR))) );
double interpolCR = (aCR[workingCR-((workingCR > delayC)?delayC+1:0)] * (1-(offsetCR-floor(offsetCR))) );
interpolCR += (aCR[workingCR+1-((workingCR+1 > delayC)?delayC+1:0)] * ((offsetCR-floor(offsetCR))) );
double interpolDR = (aDR[workingDR-((workingDR > delayD)?delayD+1:0)] * (1-(offsetDR-floor(offsetDR))) );
interpolDR += (aDR[workingDR+1-((workingDR+1 > delayD)?delayD+1:0)] * ((offsetDR-floor(offsetDR))) );
double interpolER = (aER[workingER-((workingER > delayE)?delayE+1:0)] * (1-(offsetER-floor(offsetER))) );
interpolER += (aER[workingER+1-((workingER+1 > delayE)?delayE+1:0)] * ((offsetER-floor(offsetER))) );
double interpolFR = (aFR[workingFR-((workingFR > delayF)?delayF+1:0)] * (1-(offsetFR-floor(offsetFR))) );
interpolFR += (aFR[workingFR+1-((workingFR+1 > delayF)?delayF+1:0)] * ((offsetFR-floor(offsetFR))) );
double interpolGR = (aGR[workingGR-((workingGR > delayG)?delayG+1:0)] * (1-(offsetGR-floor(offsetGR))) );
interpolGR += (aGR[workingGR+1-((workingGR+1 > delayG)?delayG+1:0)] * ((offsetGR-floor(offsetGR))) );
double interpolHR = (aHR[workingHR-((workingHR > delayH)?delayH+1:0)] * (1-(offsetHR-floor(offsetHR))) );
interpolHR += (aHR[workingHR+1-((workingHR+1 > delayH)?delayH+1:0)] * ((offsetHR-floor(offsetHR))) );
//R
interpolAL = ((1.0-blend)*interpolAL)+(aAL[workingAL-((workingAL > delayA)?delayA+1:0)]*blend);
interpolBL = ((1.0-blend)*interpolBL)+(aBL[workingBL-((workingBL > delayB)?delayB+1:0)]*blend);
interpolCL = ((1.0-blend)*interpolCL)+(aCL[workingCL-((workingCL > delayC)?delayC+1:0)]*blend);
interpolDL = ((1.0-blend)*interpolDL)+(aDL[workingDL-((workingDL > delayD)?delayD+1:0)]*blend);
interpolEL = ((1.0-blend)*interpolEL)+(aEL[workingEL-((workingEL > delayE)?delayE+1:0)]*blend);
interpolFL = ((1.0-blend)*interpolFL)+(aFL[workingFL-((workingFL > delayF)?delayF+1:0)]*blend);
interpolGL = ((1.0-blend)*interpolGL)+(aGL[workingGL-((workingGL > delayG)?delayG+1:0)]*blend);
interpolHL = ((1.0-blend)*interpolHL)+(aHL[workingHL-((workingHL > delayH)?delayH+1:0)]*blend); //L
interpolAR = ((1.0-blend)*interpolAR)+(aAR[workingAR-((workingAR > delayA)?delayA+1:0)]*blend);
interpolBR = ((1.0-blend)*interpolBR)+(aBR[workingBR-((workingBR > delayB)?delayB+1:0)]*blend);
interpolCR = ((1.0-blend)*interpolCR)+(aCR[workingCR-((workingCR > delayC)?delayC+1:0)]*blend);
interpolDR = ((1.0-blend)*interpolDR)+(aDR[workingDR-((workingDR > delayD)?delayD+1:0)]*blend);
interpolER = ((1.0-blend)*interpolER)+(aER[workingER-((workingER > delayE)?delayE+1:0)]*blend);
interpolFR = ((1.0-blend)*interpolFR)+(aFR[workingFR-((workingFR > delayF)?delayF+1:0)]*blend);
interpolGR = ((1.0-blend)*interpolGR)+(aGR[workingGR-((workingGR > delayG)?delayG+1:0)]*blend);
interpolHR = ((1.0-blend)*interpolHR)+(aHR[workingHR-((workingHR > delayH)?delayH+1:0)]*blend); //R
interpolAL = (interpolAL * (1.0-fabs(crossmod))) + (interpolEL * crossmod);
interpolEL = (interpolEL * (1.0-fabs(crossmod))) + (interpolAL * crossmod); //L
interpolAR = (interpolAR * (1.0-fabs(crossmod))) + (interpolER * crossmod);
interpolER = (interpolER * (1.0-fabs(crossmod))) + (interpolAR * crossmod); //R
feedbackAL = (interpolAL - (interpolBL + interpolCL + interpolDL)) * regen;
feedbackBL = (interpolBL - (interpolAL + interpolCL + interpolDL)) * regen;
feedbackCL = (interpolCL - (interpolAL + interpolBL + interpolDL)) * regen;
feedbackDL = (interpolDL - (interpolAL + interpolBL + interpolCL)) * regen; //Householder feedback matrix, L
feedbackEL = (interpolEL - (interpolFL + interpolGL + interpolHL)) * regen;
feedbackFL = (interpolFL - (interpolEL + interpolGL + interpolHL)) * regen;
feedbackGL = (interpolGL - (interpolEL + interpolFL + interpolHL)) * regen;
feedbackHL = (interpolHL - (interpolEL + interpolFL + interpolGL)) * regen; //Householder feedback matrix, L
feedbackAR = (interpolAR - (interpolBR + interpolCR + interpolDR)) * regen;
feedbackBR = (interpolBR - (interpolAR + interpolCR + interpolDR)) * regen;
feedbackCR = (interpolCR - (interpolAR + interpolBR + interpolDR)) * regen;
feedbackDR = (interpolDR - (interpolAR + interpolBR + interpolCR)) * regen; //Householder feedback matrix, R
feedbackER = (interpolER - (interpolFR + interpolGR + interpolHR)) * regen;
feedbackFR = (interpolFR - (interpolER + interpolGR + interpolHR)) * regen;
feedbackGR = (interpolGR - (interpolER + interpolFR + interpolHR)) * regen;
feedbackHR = (interpolHR - (interpolER + interpolFR + interpolGR)) * regen; //Householder feedback matrix, R
inputSampleL = (interpolAL + interpolBL + interpolCL + interpolDL + interpolEL + interpolFL + interpolGL + interpolHL)/8.0;
inputSampleR = (interpolAR + interpolBR + interpolCR + interpolDR + interpolER + interpolFR + interpolGR + interpolHR)/8.0;
tempSampleL = (inputSampleL * biquadB[2]) + biquadB[7];
biquadB[7] = (inputSampleL * biquadB[3]) - (tempSampleL * biquadB[5]) + biquadB[8];
biquadB[8] = (inputSampleL * biquadB[4]) - (tempSampleL * biquadB[6]);
inputSampleL = tempSampleL; //like mono AU, 7 and 8 store L channel
tempSampleR = (inputSampleR * biquadB[2]) + biquadB[9];
biquadB[9] = (inputSampleR * biquadB[3]) - (tempSampleR * biquadB[5]) + biquadB[10];
biquadB[10] = (inputSampleR * biquadB[4]) - (tempSampleR * biquadB[6]);
inputSampleR = tempSampleR; //note: 9 and 10 store the R channel
if (inputSampleL > 1.0) inputSampleL = 1.0;
if (inputSampleL < -1.0) inputSampleL = -1.0;
if (inputSampleR > 1.0) inputSampleR = 1.0;
if (inputSampleR < -1.0) inputSampleR = -1.0;
//without this, you can get a NaN condition where it spits out DC offset at full blast!
inputSampleL = asin(inputSampleL);
inputSampleR = asin(inputSampleR);
tempSampleL = (inputSampleL * biquadC[2]) + biquadC[7];
biquadC[7] = (inputSampleL * biquadC[3]) - (tempSampleL * biquadC[5]) + biquadC[8];
biquadC[8] = (inputSampleL * biquadC[4]) - (tempSampleL * biquadC[6]);
inputSampleL = tempSampleL; //like mono AU, 7 and 8 store L channel
tempSampleR = (inputSampleR * biquadC[2]) + biquadC[9];
biquadC[9] = (inputSampleR * biquadC[3]) - (tempSampleR * biquadC[5]) + biquadC[10];
biquadC[10] = (inputSampleR * biquadC[4]) - (tempSampleR * biquadC[6]);
inputSampleR = tempSampleR; //note: 9 and 10 store the R channel
if (wet !=1.0) {
inputSampleL += (drySampleL * (1.0-wet));
inputSampleR += (drySampleR * (1.0-wet));
}
//begin 32 bit stereo floating point dither
int expon; frexpf((float)inputSampleL, &expon);
fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5;
inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62));
frexpf((float)inputSampleR, &expon);
fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5;
inputSampleR += ((double(fpdR)-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 MatrixVerb::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames)
{
double* in1 = inputs[0];
double* in2 = inputs[1];
double* out1 = outputs[0];
double* out2 = outputs[1];
double overallscale = 1.0;
overallscale /= 44100.0;
overallscale *= getSampleRate();
biquadC[0] = biquadB[0] = biquadA[0] = ((A*9000.0)+1000.0) / getSampleRate();
biquadA[1] = 1.618033988749894848204586;
biquadB[1] = 0.618033988749894848204586;
biquadC[1] = 0.5;
double K = tan(M_PI * biquadA[0]); //lowpass
double norm = 1.0 / (1.0 + K / biquadA[1] + K * K);
biquadA[2] = K * K * norm;
biquadA[3] = 2.0 * biquadA[2];
biquadA[4] = biquadA[2];
biquadA[5] = 2.0 * (K * K - 1.0) * norm;
biquadA[6] = (1.0 - K / biquadA[1] + K * K) * norm;
K = tan(M_PI * biquadA[0]);
norm = 1.0 / (1.0 + K / biquadB[1] + K * K);
biquadB[2] = K * K * norm;
biquadB[3] = 2.0 * biquadB[2];
biquadB[4] = biquadB[2];
biquadB[5] = 2.0 * (K * K - 1.0) * norm;
biquadB[6] = (1.0 - K / biquadB[1] + K * K) * norm;
K = tan(M_PI * biquadC[0]);
norm = 1.0 / (1.0 + K / biquadC[1] + K * K);
biquadC[2] = K * K * norm;
biquadC[3] = 2.0 * biquadC[2];
biquadC[4] = biquadC[2];
biquadC[5] = 2.0 * (K * K - 1.0) * norm;
biquadC[6] = (1.0 - K / biquadC[1] + K * K) * norm;
double vibSpeed = 0.06+C;
double vibDepth = (0.027+pow(D,3))*100.0;
double size = (pow(E,2)*90.0)+10.0;
double depthFactor = 1.0-pow((1.0-(0.82-((B*0.5)+(size*0.002)))),4);
double blend = 0.955-(size*0.007);
double crossmod = (F-0.5)*2.0;
crossmod = pow(crossmod,3)*0.5;
double regen = depthFactor * (0.5 - (fabs(crossmod)*0.031));
double wet = G;
delayA = 79*size;
delayB = 73*size;
delayC = 71*size;
delayD = 67*size;
delayE = 61*size;
delayF = 59*size;
delayG = 53*size;
delayH = 47*size;
delayI = 43*size;
delayJ = 41*size;
delayK = 37*size;
delayL = 31*size;
delayM = (29*size)-(56*size*fabs(crossmod));
//predelay for natural spaces, gets cut back for heavily artificial spaces
while (--sampleFrames >= 0)
{
long double inputSampleL = *in1;
long double inputSampleR = *in2;
if (fabs(inputSampleL)<1.18e-43) inputSampleL = fpdL * 1.18e-43;
if (fabs(inputSampleR)<1.18e-43) inputSampleR = fpdR * 1.18e-43;
long double drySampleL = inputSampleL;
long double drySampleR = inputSampleR;
aML[countM] = inputSampleL;
aMR[countM] = inputSampleR;
countM++; if (countM < 0 || countM > delayM) {countM = 0;}
inputSampleL = aML[countM];
inputSampleR = aMR[countM];
//predelay
long double tempSampleL = (inputSampleL * biquadA[2]) + biquadA[7];
biquadA[7] = (inputSampleL * biquadA[3]) - (tempSampleL * biquadA[5]) + biquadA[8];
biquadA[8] = (inputSampleL * biquadA[4]) - (tempSampleL * biquadA[6]);
inputSampleL = tempSampleL; //like mono AU, 7 and 8 store L channel
long double tempSampleR = (inputSampleR * biquadA[2]) + biquadA[9];
biquadA[9] = (inputSampleR * biquadA[3]) - (tempSampleR * biquadA[5]) + biquadA[10];
biquadA[10] = (inputSampleR * biquadA[4]) - (tempSampleR * biquadA[6]);
inputSampleR = tempSampleR; //note: 9 and 10 store the R channel
inputSampleL *= wet;
inputSampleR *= wet;
//we're going to use this as a kind of balance since the reverb buildup can be so large
inputSampleL = sin(inputSampleL);
inputSampleR = sin(inputSampleR);
long double allpassIL = inputSampleL;
long double allpassJL = inputSampleL;
long double allpassKL = inputSampleL;
long double allpassLL = inputSampleL;
long double allpassIR = inputSampleR;
long double allpassJR = inputSampleR;
long double allpassKR = inputSampleR;
long double allpassLR = inputSampleR;
int allpasstemp = countI + 1;
if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = 0;}
allpassIL -= aIL[allpasstemp]*0.5;
aIL[countI] = allpassIL;
allpassIL *= 0.5;
allpassIR -= aIR[allpasstemp]*0.5;
aIR[countI] = allpassIR;
allpassIR *= 0.5;
countI++; if (countI < 0 || countI > delayI) {countI = 0;}
allpassIL += (aIL[countI]);
allpassIR += (aIR[countI]);
allpasstemp = countJ + 1;
if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = 0;}
allpassJL -= aJL[allpasstemp]*0.5;
aJL[countJ] = allpassJL;
allpassJL *= 0.5;
allpassJR -= aJR[allpasstemp]*0.5;
aJR[countJ] = allpassJR;
allpassJR *= 0.5;
countJ++; if (countJ < 0 || countJ > delayJ) {countJ = 0;}
allpassJL += (aJL[countJ]);
allpassJR += (aJR[countJ]);
allpasstemp = countK + 1;
if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = 0;}
allpassKL -= aKL[allpasstemp]*0.5;
aKL[countK] = allpassKL;
allpassKL *= 0.5;
allpassKR -= aKR[allpasstemp]*0.5;
aKR[countK] = allpassKR;
allpassKR *= 0.5;
countK++; if (countK < 0 || countK > delayK) {countK = 0;}
allpassKL += (aKL[countK]);
allpassKR += (aKR[countK]);
allpasstemp = countL + 1;
if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = 0;}
allpassLL -= aLL[allpasstemp]*0.5;
aLL[countL] = allpassLL;
allpassLL *= 0.5;
allpassLR -= aLR[allpasstemp]*0.5;
aLR[countL] = allpassLR;
allpassLR *= 0.5;
countL++; if (countL < 0 || countL > delayL) {countL = 0;}
allpassLL += (aLL[countL]);
allpassLR += (aLR[countL]);
//the big allpass in front of everything
aAL[countA] = allpassLL + feedbackAL;
aBL[countB] = allpassKL + feedbackBL;
aCL[countC] = allpassJL + feedbackCL;
aDL[countD] = allpassIL + feedbackDL;
aEL[countE] = allpassIL + feedbackEL;
aFL[countF] = allpassJL + feedbackFL;
aGL[countG] = allpassKL + feedbackGL;
aHL[countH] = allpassLL + feedbackHL; //L
aAR[countA] = allpassLR + feedbackAR;
aBR[countB] = allpassKR + feedbackBR;
aCR[countC] = allpassJR + feedbackCR;
aDR[countD] = allpassIR + feedbackDR;
aER[countE] = allpassIR + feedbackER;
aFR[countF] = allpassJR + feedbackFR;
aGR[countG] = allpassKR + feedbackGR;
aHR[countH] = allpassLR + feedbackHR; //R
countA++; if (countA < 0 || countA > delayA) {countA = 0;}
countB++; if (countB < 0 || countB > delayB) {countB = 0;}
countC++; if (countC < 0 || countC > delayC) {countC = 0;}
countD++; if (countD < 0 || countD > delayD) {countD = 0;}
countE++; if (countE < 0 || countE > delayE) {countE = 0;}
countF++; if (countF < 0 || countF > delayF) {countF = 0;}
countG++; if (countG < 0 || countG > delayG) {countG = 0;}
countH++; if (countH < 0 || countH > delayH) {countH = 0;}
//the Householder matrices (shared between channels, offset is stereo)
vibAL += (depthA * vibSpeed);
vibBL += (depthB * vibSpeed);
vibCL += (depthC * vibSpeed);
vibDL += (depthD * vibSpeed);
vibEL += (depthE * vibSpeed);
vibFL += (depthF * vibSpeed);
vibGL += (depthG * vibSpeed);
vibHL += (depthH * vibSpeed); //L
vibAR += (depthA * vibSpeed);
vibBR += (depthB * vibSpeed);
vibCR += (depthC * vibSpeed);
vibDR += (depthD * vibSpeed);
vibER += (depthE * vibSpeed);
vibFR += (depthF * vibSpeed);
vibGR += (depthG * vibSpeed);
vibHR += (depthH * vibSpeed); //R
//Depth is shared, but each started at a random position
double offsetAL = (sin(vibAL)+1.0)*vibDepth;
double offsetBL = (sin(vibBL)+1.0)*vibDepth;
double offsetCL = (sin(vibCL)+1.0)*vibDepth;
double offsetDL = (sin(vibDL)+1.0)*vibDepth;
double offsetEL = (sin(vibEL)+1.0)*vibDepth;
double offsetFL = (sin(vibFL)+1.0)*vibDepth;
double offsetGL = (sin(vibGL)+1.0)*vibDepth;
double offsetHL = (sin(vibHL)+1.0)*vibDepth; //L
double offsetAR = (sin(vibAR)+1.0)*vibDepth;
double offsetBR = (sin(vibBR)+1.0)*vibDepth;
double offsetCR = (sin(vibCR)+1.0)*vibDepth;
double offsetDR = (sin(vibDR)+1.0)*vibDepth;
double offsetER = (sin(vibER)+1.0)*vibDepth;
double offsetFR = (sin(vibFR)+1.0)*vibDepth;
double offsetGR = (sin(vibGR)+1.0)*vibDepth;
double offsetHR = (sin(vibHR)+1.0)*vibDepth; //R
int workingAL = countA + offsetAL;
int workingBL = countB + offsetBL;
int workingCL = countC + offsetCL;
int workingDL = countD + offsetDL;
int workingEL = countE + offsetEL;
int workingFL = countF + offsetFL;
int workingGL = countG + offsetGL;
int workingHL = countH + offsetHL; //L
int workingAR = countA + offsetAR;
int workingBR = countB + offsetBR;
int workingCR = countC + offsetCR;
int workingDR = countD + offsetDR;
int workingER = countE + offsetER;
int workingFR = countF + offsetFR;
int workingGR = countG + offsetGR;
int workingHR = countH + offsetHR; //R
double interpolAL = (aAL[workingAL-((workingAL > delayA)?delayA+1:0)] * (1-(offsetAL-floor(offsetAL))) );
interpolAL += (aAL[workingAL+1-((workingAL+1 > delayA)?delayA+1:0)] * ((offsetAL-floor(offsetAL))) );
double interpolBL = (aBL[workingBL-((workingBL > delayB)?delayB+1:0)] * (1-(offsetBL-floor(offsetBL))) );
interpolBL += (aBL[workingBL+1-((workingBL+1 > delayB)?delayB+1:0)] * ((offsetBL-floor(offsetBL))) );
double interpolCL = (aCL[workingCL-((workingCL > delayC)?delayC+1:0)] * (1-(offsetCL-floor(offsetCL))) );
interpolCL += (aCL[workingCL+1-((workingCL+1 > delayC)?delayC+1:0)] * ((offsetCL-floor(offsetCL))) );
double interpolDL = (aDL[workingDL-((workingDL > delayD)?delayD+1:0)] * (1-(offsetDL-floor(offsetDL))) );
interpolDL += (aDL[workingDL+1-((workingDL+1 > delayD)?delayD+1:0)] * ((offsetDL-floor(offsetDL))) );
double interpolEL = (aEL[workingEL-((workingEL > delayE)?delayE+1:0)] * (1-(offsetEL-floor(offsetEL))) );
interpolEL += (aEL[workingEL+1-((workingEL+1 > delayE)?delayE+1:0)] * ((offsetEL-floor(offsetEL))) );
double interpolFL = (aFL[workingFL-((workingFL > delayF)?delayF+1:0)] * (1-(offsetFL-floor(offsetFL))) );
interpolFL += (aFL[workingFL+1-((workingFL+1 > delayF)?delayF+1:0)] * ((offsetFL-floor(offsetFL))) );
double interpolGL = (aGL[workingGL-((workingGL > delayG)?delayG+1:0)] * (1-(offsetGL-floor(offsetGL))) );
interpolGL += (aGL[workingGL+1-((workingGL+1 > delayG)?delayG+1:0)] * ((offsetGL-floor(offsetGL))) );
double interpolHL = (aHL[workingHL-((workingHL > delayH)?delayH+1:0)] * (1-(offsetHL-floor(offsetHL))) );
interpolHL += (aHL[workingHL+1-((workingHL+1 > delayH)?delayH+1:0)] * ((offsetHL-floor(offsetHL))) );
//L
double interpolAR = (aAR[workingAR-((workingAR > delayA)?delayA+1:0)] * (1-(offsetAR-floor(offsetAR))) );
interpolAR += (aAR[workingAR+1-((workingAR+1 > delayA)?delayA+1:0)] * ((offsetAR-floor(offsetAR))) );
double interpolBR = (aBR[workingBR-((workingBR > delayB)?delayB+1:0)] * (1-(offsetBR-floor(offsetBR))) );
interpolBR += (aBR[workingBR+1-((workingBR+1 > delayB)?delayB+1:0)] * ((offsetBR-floor(offsetBR))) );
double interpolCR = (aCR[workingCR-((workingCR > delayC)?delayC+1:0)] * (1-(offsetCR-floor(offsetCR))) );
interpolCR += (aCR[workingCR+1-((workingCR+1 > delayC)?delayC+1:0)] * ((offsetCR-floor(offsetCR))) );
double interpolDR = (aDR[workingDR-((workingDR > delayD)?delayD+1:0)] * (1-(offsetDR-floor(offsetDR))) );
interpolDR += (aDR[workingDR+1-((workingDR+1 > delayD)?delayD+1:0)] * ((offsetDR-floor(offsetDR))) );
double interpolER = (aER[workingER-((workingER > delayE)?delayE+1:0)] * (1-(offsetER-floor(offsetER))) );
interpolER += (aER[workingER+1-((workingER+1 > delayE)?delayE+1:0)] * ((offsetER-floor(offsetER))) );
double interpolFR = (aFR[workingFR-((workingFR > delayF)?delayF+1:0)] * (1-(offsetFR-floor(offsetFR))) );
interpolFR += (aFR[workingFR+1-((workingFR+1 > delayF)?delayF+1:0)] * ((offsetFR-floor(offsetFR))) );
double interpolGR = (aGR[workingGR-((workingGR > delayG)?delayG+1:0)] * (1-(offsetGR-floor(offsetGR))) );
interpolGR += (aGR[workingGR+1-((workingGR+1 > delayG)?delayG+1:0)] * ((offsetGR-floor(offsetGR))) );
double interpolHR = (aHR[workingHR-((workingHR > delayH)?delayH+1:0)] * (1-(offsetHR-floor(offsetHR))) );
interpolHR += (aHR[workingHR+1-((workingHR+1 > delayH)?delayH+1:0)] * ((offsetHR-floor(offsetHR))) );
//R
interpolAL = ((1.0-blend)*interpolAL)+(aAL[workingAL-((workingAL > delayA)?delayA+1:0)]*blend);
interpolBL = ((1.0-blend)*interpolBL)+(aBL[workingBL-((workingBL > delayB)?delayB+1:0)]*blend);
interpolCL = ((1.0-blend)*interpolCL)+(aCL[workingCL-((workingCL > delayC)?delayC+1:0)]*blend);
interpolDL = ((1.0-blend)*interpolDL)+(aDL[workingDL-((workingDL > delayD)?delayD+1:0)]*blend);
interpolEL = ((1.0-blend)*interpolEL)+(aEL[workingEL-((workingEL > delayE)?delayE+1:0)]*blend);
interpolFL = ((1.0-blend)*interpolFL)+(aFL[workingFL-((workingFL > delayF)?delayF+1:0)]*blend);
interpolGL = ((1.0-blend)*interpolGL)+(aGL[workingGL-((workingGL > delayG)?delayG+1:0)]*blend);
interpolHL = ((1.0-blend)*interpolHL)+(aHL[workingHL-((workingHL > delayH)?delayH+1:0)]*blend); //L
interpolAR = ((1.0-blend)*interpolAR)+(aAR[workingAR-((workingAR > delayA)?delayA+1:0)]*blend);
interpolBR = ((1.0-blend)*interpolBR)+(aBR[workingBR-((workingBR > delayB)?delayB+1:0)]*blend);
interpolCR = ((1.0-blend)*interpolCR)+(aCR[workingCR-((workingCR > delayC)?delayC+1:0)]*blend);
interpolDR = ((1.0-blend)*interpolDR)+(aDR[workingDR-((workingDR > delayD)?delayD+1:0)]*blend);
interpolER = ((1.0-blend)*interpolER)+(aER[workingER-((workingER > delayE)?delayE+1:0)]*blend);
interpolFR = ((1.0-blend)*interpolFR)+(aFR[workingFR-((workingFR > delayF)?delayF+1:0)]*blend);
interpolGR = ((1.0-blend)*interpolGR)+(aGR[workingGR-((workingGR > delayG)?delayG+1:0)]*blend);
interpolHR = ((1.0-blend)*interpolHR)+(aHR[workingHR-((workingHR > delayH)?delayH+1:0)]*blend); //R
interpolAL = (interpolAL * (1.0-fabs(crossmod))) + (interpolEL * crossmod);
interpolEL = (interpolEL * (1.0-fabs(crossmod))) + (interpolAL * crossmod); //L
interpolAR = (interpolAR * (1.0-fabs(crossmod))) + (interpolER * crossmod);
interpolER = (interpolER * (1.0-fabs(crossmod))) + (interpolAR * crossmod); //R
feedbackAL = (interpolAL - (interpolBL + interpolCL + interpolDL)) * regen;
feedbackBL = (interpolBL - (interpolAL + interpolCL + interpolDL)) * regen;
feedbackCL = (interpolCL - (interpolAL + interpolBL + interpolDL)) * regen;
feedbackDL = (interpolDL - (interpolAL + interpolBL + interpolCL)) * regen; //Householder feedback matrix, L
feedbackEL = (interpolEL - (interpolFL + interpolGL + interpolHL)) * regen;
feedbackFL = (interpolFL - (interpolEL + interpolGL + interpolHL)) * regen;
feedbackGL = (interpolGL - (interpolEL + interpolFL + interpolHL)) * regen;
feedbackHL = (interpolHL - (interpolEL + interpolFL + interpolGL)) * regen; //Householder feedback matrix, L
feedbackAR = (interpolAR - (interpolBR + interpolCR + interpolDR)) * regen;
feedbackBR = (interpolBR - (interpolAR + interpolCR + interpolDR)) * regen;
feedbackCR = (interpolCR - (interpolAR + interpolBR + interpolDR)) * regen;
feedbackDR = (interpolDR - (interpolAR + interpolBR + interpolCR)) * regen; //Householder feedback matrix, R
feedbackER = (interpolER - (interpolFR + interpolGR + interpolHR)) * regen;
feedbackFR = (interpolFR - (interpolER + interpolGR + interpolHR)) * regen;
feedbackGR = (interpolGR - (interpolER + interpolFR + interpolHR)) * regen;
feedbackHR = (interpolHR - (interpolER + interpolFR + interpolGR)) * regen; //Householder feedback matrix, R
inputSampleL = (interpolAL + interpolBL + interpolCL + interpolDL + interpolEL + interpolFL + interpolGL + interpolHL)/8.0;
inputSampleR = (interpolAR + interpolBR + interpolCR + interpolDR + interpolER + interpolFR + interpolGR + interpolHR)/8.0;
tempSampleL = (inputSampleL * biquadB[2]) + biquadB[7];
biquadB[7] = (inputSampleL * biquadB[3]) - (tempSampleL * biquadB[5]) + biquadB[8];
biquadB[8] = (inputSampleL * biquadB[4]) - (tempSampleL * biquadB[6]);
inputSampleL = tempSampleL; //like mono AU, 7 and 8 store L channel
tempSampleR = (inputSampleR * biquadB[2]) + biquadB[9];
biquadB[9] = (inputSampleR * biquadB[3]) - (tempSampleR * biquadB[5]) + biquadB[10];
biquadB[10] = (inputSampleR * biquadB[4]) - (tempSampleR * biquadB[6]);
inputSampleR = tempSampleR; //note: 9 and 10 store the R channel
if (inputSampleL > 1.0) inputSampleL = 1.0;
if (inputSampleL < -1.0) inputSampleL = -1.0;
if (inputSampleR > 1.0) inputSampleR = 1.0;
if (inputSampleR < -1.0) inputSampleR = -1.0;
//without this, you can get a NaN condition where it spits out DC offset at full blast!
inputSampleL = asin(inputSampleL);
inputSampleR = asin(inputSampleR);
tempSampleL = (inputSampleL * biquadC[2]) + biquadC[7];
biquadC[7] = (inputSampleL * biquadC[3]) - (tempSampleL * biquadC[5]) + biquadC[8];
biquadC[8] = (inputSampleL * biquadC[4]) - (tempSampleL * biquadC[6]);
inputSampleL = tempSampleL; //like mono AU, 7 and 8 store L channel
tempSampleR = (inputSampleR * biquadC[2]) + biquadC[9];
biquadC[9] = (inputSampleR * biquadC[3]) - (tempSampleR * biquadC[5]) + biquadC[10];
biquadC[10] = (inputSampleR * biquadC[4]) - (tempSampleR * biquadC[6]);
inputSampleR = tempSampleR; //note: 9 and 10 store the R channel
if (wet !=1.0) {
inputSampleL += (drySampleL * (1.0-wet));
inputSampleR += (drySampleR * (1.0-wet));
}
//begin 64 bit stereo floating point dither
int expon; frexp((double)inputSampleL, &expon);
fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5;
inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
frexp((double)inputSampleR, &expon);
fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5;
inputSampleR += ((double(fpdR)-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++;
}
}