Correcting frequency selection, and making low cutoff properly scale with volume

Author: CaiB

ColorChord.NET/NoteFinder/Gen2NoteFinder.cs

@@ -203,11 +203,13 @@ public override void UpdateOutputs()
         this.AllBinMaxSmoothed = this.AllBinMax < NewAllBinMax ? (this.AllBinMax * 0.8F) + (NewAllBinMax * 0.2F) : (this.AllBinMax * 0.995F) + (NewAllBinMax * 0.005F);
         this.AllBinMax = Math.Max(0.01F, AllBinMaxSmoothed);
 
+        Vector256<float> CutoffVal = Vector256.Create(this.AllBinMaxSmoothed * 0.02F);
         for (int Step = 0; Step < AllBinValuesScaled.Length; Step += 8)
         {
             Vector256<float> MiddleValues = Vector256.LoadUnsafe(ref RawBinValuesPadded[Step + 1]);
             Vector256<float> Scaled = Avx.Divide(MiddleValues, Vector256.Create(this.AllBinMaxSmoothed * 2.2F));
-            Scaled.StoreUnsafe(ref AllBinValuesScaled[Step]);
+            Vector256<float> WithCutoff = Avx.Max(Vector256<float>.Zero, Avx.Subtract(Scaled, CutoffVal));
+            WithCutoff.StoreUnsafe(ref AllBinValuesScaled[Step]);
         }
 
         for (int Outer = 0; Outer < PeakBitsPacked.Length; Outer++)

ColorChord.NET/NoteFinder/Gen2NoteFinderDFT.cs

@@ -175,15 +175,16 @@ public sealed class Gen2NoteFinderDFT
         RawBinWidths = new float[BinCount];
 
         uint MaxAudioBufferSize = 0;
-        for (uint Bin = 0; Bin < BinCount; Bin++)
+        for (int Bin = 0; Bin < BinCount; Bin++)
         {
             float BinFrequency;
             uint ThisBufferSize;
             float ThisOctaveStart = StartFrequency * MathF.Pow(2, Bin / BinsPerOctave);
             BinFrequency = CalculateNoteFrequency(StartFrequency, BinsPerOctave, Bin);
-            float NextBinFrequency = CalculateNoteFrequency(StartFrequency, BinsPerOctave, Bin + 2);
+            float NextBinFrequencyUp = CalculateNoteFrequency(StartFrequency, BinsPerOctave, Bin + 1);
+            float NextBinFrequencyDown = CalculateNoteFrequency(StartFrequency, BinsPerOctave, Bin - 1);
             //float IdealWindowSize = WindowSizeForBinWidth(TopOctaveNextBinFreq - TopOctaveBinFreq); // TODO: Add scale factor to shift this from no overlap to -3dB point
-            ThisBufferSize = RoundedWindowSizeForBinWidth(NextBinFrequency - BinFrequency, BinFrequency, SampleRate);
+            ThisBufferSize = RoundedWindowSizeForBinWidth(NextBinFrequencyUp - NextBinFrequencyDown, BinFrequency, SampleRate);
 
             RawBinWidths[Bin] = MathF.Log2((BinFrequency + BinWidthAtWindowSize(ThisBufferSize, SampleRate)) / BinFrequency) * BinsPerOctave;
 
@@ -627,7 +628,7 @@ public void CalculateOutput()
         {
             float OutBinVal = this.RawBinMagnitudes[Bin] * this.LoudnessCorrectionFactors[Bin];
             this.OctaveBinValues[Bin % BinsPerOctave] += OutBinVal / this.OctaveCount;
-            this.AllBinValues[Bin + 1] = MathF.Max(0, OutBinVal - 0.08F);
+            this.AllBinValues[Bin + 1] = MathF.Max(0, OutBinVal);
         }
     }
 
@@ -735,8 +736,8 @@ private static uint RoundedWindowSizeForBinWidth(float binWidth, float frequency
         return (uint)Math.Min(ABSOLUTE_MAX_WINDOW_SIZE, MathF.Round((MathF.Max(MinWindowSizePeriods, MathF.Min(MaxWindowSizePeriods, MathF.Round(PeriodsInWindow))) * PeriodInSamples) + (PeriodInSamples * 0.5F)));
     }
 
-    private static float CalculateNoteFrequency(float octaveStart, uint binsPerOctave, uint binIndex) => octaveStart * GetNoteFrequencyMultiplier(binsPerOctave, binIndex);
-    private static float GetNoteFrequencyMultiplier(uint binsPerOctave, uint binIndex) => MathF.Pow(2F, (float)binIndex / binsPerOctave);
+    private static float CalculateNoteFrequency(float octaveStart, uint binsPerOctave, int binIndex) => octaveStart * GetNoteFrequencyMultiplier(binsPerOctave, binIndex);
+    private static float GetNoteFrequencyMultiplier(uint binsPerOctave, int binIndex) => MathF.Pow(2F, (float)binIndex / binsPerOctave);
 
     /// <summary> Gets a factor to multiply the output amplitude by to correct for percieved loudness. </summary>
     /// <remarks> Output is based on ISO 226:2023 data, and assumes a fixed loudness, and that the item being multiplied is sqrt(dB level). </remarks>