Laserbat spotted an interesting bug in legacy NJAD code!

21 files changed, 80 insertions, 80 deletions

diff --git a/plugins/LinuxVST/src/Ditherbox/DitherboxProc.cpp b/plugins/LinuxVST/src/Ditherbox/DitherboxProc.cpp
index 4115687..4906413 100755
--- a/plugins/LinuxVST/src/Ditherbox/DitherboxProc.cpp
+++ b/plugins/LinuxVST/src/Ditherbox/DitherboxProc.cpp
@@ -443,7 +443,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -518,7 +518,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -602,7 +602,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -683,7 +683,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -1447,7 +1447,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -1522,7 +1522,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -1606,7 +1606,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -1687,7 +1687,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
diff --git a/plugins/LinuxVST/src/NaturalizeDither/NaturalizeDitherProc.cpp b/plugins/LinuxVST/src/NaturalizeDither/NaturalizeDitherProc.cpp
index 7bd2210..e0b2d86 100755
--- a/plugins/LinuxVST/src/NaturalizeDither/NaturalizeDitherProc.cpp
+++ b/plugins/LinuxVST/src/NaturalizeDither/NaturalizeDitherProc.cpp
@@ -140,7 +140,7 @@ void NaturalizeDither::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -215,7 +215,7 @@ void NaturalizeDither::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -374,7 +374,7 @@ void NaturalizeDither::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -449,7 +449,7 @@ void NaturalizeDither::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/LinuxVST/src/NotJustAnotherCD/NotJustAnotherCDProc.cpp b/plugins/LinuxVST/src/NotJustAnotherCD/NotJustAnotherCDProc.cpp
index 28c4385..af43200 100755
--- a/plugins/LinuxVST/src/NotJustAnotherCD/NotJustAnotherCDProc.cpp
+++ b/plugins/LinuxVST/src/NotJustAnotherCD/NotJustAnotherCDProc.cpp
@@ -145,7 +145,7 @@ void NotJustAnotherCD::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -226,7 +226,7 @@ void NotJustAnotherCD::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -395,7 +395,7 @@ void NotJustAnotherCD::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -476,7 +476,7 @@ void NotJustAnotherCD::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/LinuxVST/src/NotJustAnotherDither/NotJustAnotherDitherProc.cpp b/plugins/LinuxVST/src/NotJustAnotherDither/NotJustAnotherDitherProc.cpp
index 46a073e..cbc6cc3 100755
--- a/plugins/LinuxVST/src/NotJustAnotherDither/NotJustAnotherDitherProc.cpp
+++ b/plugins/LinuxVST/src/NotJustAnotherDither/NotJustAnotherDitherProc.cpp
@@ -145,7 +145,7 @@ void NotJustAnotherDither::processReplacing(float **inputs, float **outputs, Vst
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -226,7 +226,7 @@ void NotJustAnotherDither::processReplacing(float **inputs, float **outputs, Vst
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -394,7 +394,7 @@ void NotJustAnotherDither::processDoubleReplacing(double **inputs, double **outp
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -475,7 +475,7 @@ void NotJustAnotherDither::processDoubleReplacing(double **inputs, double **outp
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/LinuxVST/src/Righteous4/Righteous4Proc.cpp b/plugins/LinuxVST/src/Righteous4/Righteous4Proc.cpp
index 630360f..feff69b 100755
--- a/plugins/LinuxVST/src/Righteous4/Righteous4Proc.cpp
+++ b/plugins/LinuxVST/src/Righteous4/Righteous4Proc.cpp
@@ -391,7 +391,7 @@ void Righteous4::processReplacing(float **inputs, float **outputs, VstInt32 samp
 			
 			totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynL[1] /= totalA;
 			bynL[2] /= totalA;
 			bynL[3] /= totalA;
@@ -472,7 +472,7 @@ void Righteous4::processReplacing(float **inputs, float **outputs, VstInt32 samp
 			
 			totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynR[1] /= totalA;
 			bynR[2] /= totalA;
 			bynR[3] /= totalA;
@@ -900,7 +900,7 @@ void Righteous4::processDoubleReplacing(double **inputs, double **outputs, VstIn
 			
 			totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynL[1] /= totalA;
 			bynL[2] /= totalA;
 			bynL[3] /= totalA;
@@ -981,7 +981,7 @@ void Righteous4::processDoubleReplacing(double **inputs, double **outputs, VstIn
 			
 			totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynR[1] /= totalA;
 			bynR[2] /= totalA;
 			bynR[3] /= totalA;
diff --git a/plugins/MacAU/Distance2/Ditherbox/Ditherbox.cpp b/plugins/MacAU/Distance2/Ditherbox/Ditherbox.cpp
index a4b1edf..41929f0 100755
--- a/plugins/MacAU/Distance2/Ditherbox/Ditherbox.cpp
+++ b/plugins/MacAU/Distance2/Ditherbox/Ditherbox.cpp
@@ -573,7 +573,7 @@ void		Ditherbox::DitherboxKernel::Process(	const Float32 	*inSourceP,
 				
 				totalA = byn[1] + byn[2] + byn[3] + byn[4] + byn[5] + byn[6] + byn[7] + byn[8] + byn[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				byn[1] /= totalA;
 				byn[2] /= totalA;
 				byn[3] /= totalA;
@@ -655,7 +655,7 @@ void		Ditherbox::DitherboxKernel::Process(	const Float32 	*inSourceP,
 				
 				totalA = byn[1] + byn[2] + byn[3] + byn[4] + byn[5] + byn[6] + byn[7] + byn[8] + byn[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				byn[1] /= totalA;
 				byn[2] /= totalA;
 				byn[3] /= totalA;
diff --git a/plugins/MacAU/Ditherbox/Ditherbox.cpp b/plugins/MacAU/Ditherbox/Ditherbox.cpp
index a4b1edf..41929f0 100755
--- a/plugins/MacAU/Ditherbox/Ditherbox.cpp
+++ b/plugins/MacAU/Ditherbox/Ditherbox.cpp
@@ -573,7 +573,7 @@ void		Ditherbox::DitherboxKernel::Process(	const Float32 	*inSourceP,
 				
 				totalA = byn[1] + byn[2] + byn[3] + byn[4] + byn[5] + byn[6] + byn[7] + byn[8] + byn[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				byn[1] /= totalA;
 				byn[2] /= totalA;
 				byn[3] /= totalA;
@@ -655,7 +655,7 @@ void		Ditherbox::DitherboxKernel::Process(	const Float32 	*inSourceP,
 				
 				totalA = byn[1] + byn[2] + byn[3] + byn[4] + byn[5] + byn[6] + byn[7] + byn[8] + byn[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				byn[1] /= totalA;
 				byn[2] /= totalA;
 				byn[3] /= totalA;
diff --git a/plugins/MacAU/NaturalizeDither/NaturalizeDither.cpp b/plugins/MacAU/NaturalizeDither/NaturalizeDither.cpp
index 0104530..76531b4 100755
--- a/plugins/MacAU/NaturalizeDither/NaturalizeDither.cpp
+++ b/plugins/MacAU/NaturalizeDither/NaturalizeDither.cpp
@@ -280,7 +280,7 @@ void		NaturalizeDither::NaturalizeDitherKernel::Process(	const Float32 	*inSourc
 		
 		totalA = byn[1] + byn[2] + byn[3] + byn[4] + byn[5] + byn[6] + byn[7] + byn[8] + byn[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		byn[1] /= totalA;
 		byn[2] /= totalA;
 		byn[3] /= totalA;
diff --git a/plugins/MacAU/NotJustAnotherCD/NotJustAnotherCD.cpp b/plugins/MacAU/NotJustAnotherCD/NotJustAnotherCD.cpp
index a7c0e6d..fe31998 100755
--- a/plugins/MacAU/NotJustAnotherCD/NotJustAnotherCD.cpp
+++ b/plugins/MacAU/NotJustAnotherCD/NotJustAnotherCD.cpp
@@ -284,7 +284,7 @@ void		NotJustAnotherCD::NotJustAnotherCDKernel::Process(	const Float32 	*inSourc
 		
 		totalA = byn[1] + byn[2] + byn[3] + byn[4] + byn[5] + byn[6] + byn[7] + byn[8] + byn[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		byn[1] /= totalA;
 		byn[2] /= totalA;
 		byn[3] /= totalA;
diff --git a/plugins/MacAU/NotJustAnotherDither/NotJustAnotherDither.cpp b/plugins/MacAU/NotJustAnotherDither/NotJustAnotherDither.cpp
index 3eee651..2ca3c6f 100755
--- a/plugins/MacAU/NotJustAnotherDither/NotJustAnotherDither.cpp
+++ b/plugins/MacAU/NotJustAnotherDither/NotJustAnotherDither.cpp
@@ -286,7 +286,7 @@ void		NotJustAnotherDither::NotJustAnotherDitherKernel::Process(	const Float32
 		
 		totalA = byn[1] + byn[2] + byn[3] + byn[4] + byn[5] + byn[6] + byn[7] + byn[8] + byn[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		byn[1] /= totalA;
 		byn[2] /= totalA;
 		byn[3] /= totalA;
diff --git a/plugins/MacAU/Righteous4/Righteous4.cpp b/plugins/MacAU/Righteous4/Righteous4.cpp
index be1a1f6..d906edb 100755
--- a/plugins/MacAU/Righteous4/Righteous4.cpp
+++ b/plugins/MacAU/Righteous4/Righteous4.cpp
@@ -491,7 +491,7 @@ void		Righteous4::Righteous4Kernel::Process(	const Float32 	*inSourceP,
 			
 			totalA = byn[1] + byn[2] + byn[3] + byn[4] + byn[5] + byn[6] + byn[7] + byn[8] + byn[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			byn[1] /= totalA;
 			byn[2] /= totalA;
 			byn[3] /= totalA;
diff --git a/plugins/MacVST/Ditherbox/source/DitherboxProc.cpp b/plugins/MacVST/Ditherbox/source/DitherboxProc.cpp
index 4115687..4906413 100755
--- a/plugins/MacVST/Ditherbox/source/DitherboxProc.cpp
+++ b/plugins/MacVST/Ditherbox/source/DitherboxProc.cpp
@@ -443,7 +443,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -518,7 +518,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -602,7 +602,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -683,7 +683,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -1447,7 +1447,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -1522,7 +1522,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -1606,7 +1606,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -1687,7 +1687,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
diff --git a/plugins/MacVST/NaturalizeDither/source/NaturalizeDitherProc.cpp b/plugins/MacVST/NaturalizeDither/source/NaturalizeDitherProc.cpp
index 7bd2210..e0b2d86 100755
--- a/plugins/MacVST/NaturalizeDither/source/NaturalizeDitherProc.cpp
+++ b/plugins/MacVST/NaturalizeDither/source/NaturalizeDitherProc.cpp
@@ -140,7 +140,7 @@ void NaturalizeDither::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -215,7 +215,7 @@ void NaturalizeDither::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -374,7 +374,7 @@ void NaturalizeDither::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -449,7 +449,7 @@ void NaturalizeDither::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/MacVST/NotJustAnotherCD/source/NotJustAnotherCDProc.cpp b/plugins/MacVST/NotJustAnotherCD/source/NotJustAnotherCDProc.cpp
index 28c4385..af43200 100755
--- a/plugins/MacVST/NotJustAnotherCD/source/NotJustAnotherCDProc.cpp
+++ b/plugins/MacVST/NotJustAnotherCD/source/NotJustAnotherCDProc.cpp
@@ -145,7 +145,7 @@ void NotJustAnotherCD::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -226,7 +226,7 @@ void NotJustAnotherCD::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -395,7 +395,7 @@ void NotJustAnotherCD::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -476,7 +476,7 @@ void NotJustAnotherCD::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/MacVST/NotJustAnotherDither/source/NotJustAnotherDitherProc.cpp b/plugins/MacVST/NotJustAnotherDither/source/NotJustAnotherDitherProc.cpp
index 46a073e..cbc6cc3 100755
--- a/plugins/MacVST/NotJustAnotherDither/source/NotJustAnotherDitherProc.cpp
+++ b/plugins/MacVST/NotJustAnotherDither/source/NotJustAnotherDitherProc.cpp
@@ -145,7 +145,7 @@ void NotJustAnotherDither::processReplacing(float **inputs, float **outputs, Vst
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -226,7 +226,7 @@ void NotJustAnotherDither::processReplacing(float **inputs, float **outputs, Vst
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -394,7 +394,7 @@ void NotJustAnotherDither::processDoubleReplacing(double **inputs, double **outp
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -475,7 +475,7 @@ void NotJustAnotherDither::processDoubleReplacing(double **inputs, double **outp
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/MacVST/Righteous4/source/Righteous4Proc.cpp b/plugins/MacVST/Righteous4/source/Righteous4Proc.cpp
index 630360f..feff69b 100755
--- a/plugins/MacVST/Righteous4/source/Righteous4Proc.cpp
+++ b/plugins/MacVST/Righteous4/source/Righteous4Proc.cpp
@@ -391,7 +391,7 @@ void Righteous4::processReplacing(float **inputs, float **outputs, VstInt32 samp
 			
 			totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynL[1] /= totalA;
 			bynL[2] /= totalA;
 			bynL[3] /= totalA;
@@ -472,7 +472,7 @@ void Righteous4::processReplacing(float **inputs, float **outputs, VstInt32 samp
 			
 			totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynR[1] /= totalA;
 			bynR[2] /= totalA;
 			bynR[3] /= totalA;
@@ -900,7 +900,7 @@ void Righteous4::processDoubleReplacing(double **inputs, double **outputs, VstIn
 			
 			totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynL[1] /= totalA;
 			bynL[2] /= totalA;
 			bynL[3] /= totalA;
@@ -981,7 +981,7 @@ void Righteous4::processDoubleReplacing(double **inputs, double **outputs, VstIn
 			
 			totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynR[1] /= totalA;
 			bynR[2] /= totalA;
 			bynR[3] /= totalA;
diff --git a/plugins/WinVST/Ditherbox/DitherboxProc.cpp b/plugins/WinVST/Ditherbox/DitherboxProc.cpp
index 4115687..4906413 100755
--- a/plugins/WinVST/Ditherbox/DitherboxProc.cpp
+++ b/plugins/WinVST/Ditherbox/DitherboxProc.cpp
@@ -443,7 +443,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -518,7 +518,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -602,7 +602,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -683,7 +683,7 @@ void Ditherbox::processReplacing(float **inputs, float **outputs, VstInt32 sampl
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -1447,7 +1447,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -1522,7 +1522,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
@@ -1606,7 +1606,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynL[1] /= totalA;
 				bynL[2] /= totalA;
 				bynL[3] /= totalA;
@@ -1687,7 +1687,7 @@ void Ditherbox::processDoubleReplacing(double **inputs, double **outputs, VstInt
 				
 				totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 				totalA /= 1000;
-				if (totalA = 0) totalA = 1;
+				if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 				bynR[1] /= totalA;
 				bynR[2] /= totalA;
 				bynR[3] /= totalA;
diff --git a/plugins/WinVST/NaturalizeDither/NaturalizeDitherProc.cpp b/plugins/WinVST/NaturalizeDither/NaturalizeDitherProc.cpp
index 7bd2210..e0b2d86 100755
--- a/plugins/WinVST/NaturalizeDither/NaturalizeDitherProc.cpp
+++ b/plugins/WinVST/NaturalizeDither/NaturalizeDitherProc.cpp
@@ -140,7 +140,7 @@ void NaturalizeDither::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -215,7 +215,7 @@ void NaturalizeDither::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -374,7 +374,7 @@ void NaturalizeDither::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -449,7 +449,7 @@ void NaturalizeDither::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/WinVST/NotJustAnotherCD/NotJustAnotherCDProc.cpp b/plugins/WinVST/NotJustAnotherCD/NotJustAnotherCDProc.cpp
index 28c4385..af43200 100755
--- a/plugins/WinVST/NotJustAnotherCD/NotJustAnotherCDProc.cpp
+++ b/plugins/WinVST/NotJustAnotherCD/NotJustAnotherCDProc.cpp
@@ -145,7 +145,7 @@ void NotJustAnotherCD::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -226,7 +226,7 @@ void NotJustAnotherCD::processReplacing(float **inputs, float **outputs, VstInt3
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -395,7 +395,7 @@ void NotJustAnotherCD::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -476,7 +476,7 @@ void NotJustAnotherCD::processDoubleReplacing(double **inputs, double **outputs,
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/WinVST/NotJustAnotherDither/NotJustAnotherDitherProc.cpp b/plugins/WinVST/NotJustAnotherDither/NotJustAnotherDitherProc.cpp
index 46a073e..cbc6cc3 100755
--- a/plugins/WinVST/NotJustAnotherDither/NotJustAnotherDitherProc.cpp
+++ b/plugins/WinVST/NotJustAnotherDither/NotJustAnotherDitherProc.cpp
@@ -145,7 +145,7 @@ void NotJustAnotherDither::processReplacing(float **inputs, float **outputs, Vst
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -226,7 +226,7 @@ void NotJustAnotherDither::processReplacing(float **inputs, float **outputs, Vst
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
@@ -394,7 +394,7 @@ void NotJustAnotherDither::processDoubleReplacing(double **inputs, double **outp
 		
 		totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynL[1] /= totalA;
 		bynL[2] /= totalA;
 		bynL[3] /= totalA;
@@ -475,7 +475,7 @@ void NotJustAnotherDither::processDoubleReplacing(double **inputs, double **outp
 		
 		totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 		totalA /= 1000;
-		if (totalA = 0) totalA = 1;
+		if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 		bynR[1] /= totalA;
 		bynR[2] /= totalA;
 		bynR[3] /= totalA;
diff --git a/plugins/WinVST/Righteous4/Righteous4Proc.cpp b/plugins/WinVST/Righteous4/Righteous4Proc.cpp
index 630360f..feff69b 100755
--- a/plugins/WinVST/Righteous4/Righteous4Proc.cpp
+++ b/plugins/WinVST/Righteous4/Righteous4Proc.cpp
@@ -391,7 +391,7 @@ void Righteous4::processReplacing(float **inputs, float **outputs, VstInt32 samp
 			
 			totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynL[1] /= totalA;
 			bynL[2] /= totalA;
 			bynL[3] /= totalA;
@@ -472,7 +472,7 @@ void Righteous4::processReplacing(float **inputs, float **outputs, VstInt32 samp
 			
 			totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynR[1] /= totalA;
 			bynR[2] /= totalA;
 			bynR[3] /= totalA;
@@ -900,7 +900,7 @@ void Righteous4::processDoubleReplacing(double **inputs, double **outputs, VstIn
 			
 			totalA = bynL[1] + bynL[2] + bynL[3] + bynL[4] + bynL[5] + bynL[6] + bynL[7] + bynL[8] + bynL[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynL[1] /= totalA;
 			bynL[2] /= totalA;
 			bynL[3] /= totalA;
@@ -981,7 +981,7 @@ void Righteous4::processDoubleReplacing(double **inputs, double **outputs, VstIn
 			
 			totalA = bynR[1] + bynR[2] + bynR[3] + bynR[4] + bynR[5] + bynR[6] + bynR[7] + bynR[8] + bynR[9];
 			totalA /= 1000;
-			if (totalA = 0) totalA = 1;
+			if (totalA = 0) totalA = 1; // spotted by Laserbat: this 'scaling back' code doesn't. It always divides by the fallback of 1. Old NJAD doesn't scale back the things we're comparing against. Kept to retain known behavior, use the one in StudioTan and Monitoring for a tuned-as-intended NJAD.
 			bynR[1] /= totalA;
 			bynR[2] /= totalA;
 			bynR[3] /= totalA;