Making number of bins per octave adjustable

Author: CaiB

ColorChord.NET/NoteFinder/Gen2NoteFinder.cs

@@ -77,7 +77,7 @@ public Gen2NoteFinder(string name, Dictionary<string, object> config)
 
         SetupBuffers();
         this.SampleRate = 48000; // TODO: Temporary until source is connected ahead of time
-        this.DFT = new(this.OctaveCount, this.SampleRate, this.StartFrequency, this.LoudnessCorrectionAmount, RunTimingReceivers);
+        this.DFT = new(this.OctaveCount, 24, this.SampleRate, this.StartFrequency, this.LoudnessCorrectionAmount, RunTimingReceivers);
         Reconfigure();
     }
 
@@ -106,7 +106,7 @@ public override void AdjustOutputSpeed(uint period)
     public override void SetSampleRate(int sampleRate)
     {
         this.SampleRate = (uint)sampleRate;
-        this.DFT = new(this.OctaveCount, this.SampleRate, this.StartFrequency, this.LoudnessCorrectionAmount, RunTimingReceivers);
+        this.DFT = new(this.OctaveCount, 24, this.SampleRate, this.StartFrequency, this.LoudnessCorrectionAmount, RunTimingReceivers);
         Reconfigure();
         Log.Debug($"There are {TimingReceivers.Length} timing receivers");
         for (int i = 0; i < TimingReceivers.Length; i++)

ColorChord.NET/NoteFinder/Gen2NoteFinderDFT.cs

@@ -24,7 +24,6 @@ public sealed class Gen2NoteFinderDFT
     private const uint MAX_WINDOW_SIZE = 6144; // At 48KHz, scaled for other sample rates
     private const uint ABSOLUTE_MAX_WINDOW_SIZE = 32768; // Cannot exceed this regardless of sample rate, otherwise the accumulators may overflow
     private const uint USHORT_RANGE = ((uint)ushort.MaxValue) + 1;
-    private const uint BINS_PER_OCTAVE = 24;
 
     private const ushort SINE_TABLE_90_OFFSET = 8;
     private const ushort SINE_TABLE_90_OFFSET_SCALED = 8 << 11;
@@ -48,6 +47,9 @@ public sealed class Gen2NoteFinderDFT
     /// <summary> The number of octaves to analyze. </summary>
     public uint OctaveCount { get; private init; }
 
+    /// <summary> How many output bins should be calculated for each octave. </summary>
+    public uint BinsPerOctave { get; private init; }
+
     /// <summary> How long our sample window is. </summary>
     public uint MaxPresentWindowSize { get; private init; } = 8192;
 
@@ -57,9 +59,6 @@ public sealed class Gen2NoteFinderDFT
 
     public float StartFrequency { get; private init; }
 
-    /// <summary> The number of DFT bins per octave. </summary>
-    public uint BinsPerOctave => BINS_PER_OCTAVE;
-
     /// <summary> The total number of bins over all octaves. </summary>
     public readonly ushort BinCount;
 
@@ -84,7 +83,7 @@ public sealed class Gen2NoteFinderDFT
     private readonly ushort[] AudioBufferSubHeads;
 
     /// <summary> How far forward in the sine table this bin should step with every added sample, such that one full sine wave (wrap back to 0) occurs after the number of steps corresponding to the bin frequency. Format is fixed-point 5b+11b. </summary>
-    /// <remarks> Indexed by [Bin], size is [<see cref="BINS_PER_OCTAVE"/>] </remarks>
+    /// <remarks> Indexed by [Bin], size is [<see cref="BinsPerOctave"/>] </remarks>
     private readonly DualU16[] SinTableStepSize;
 
     /// <summary>
@@ -137,16 +136,24 @@ public sealed class Gen2NoteFinderDFT
 
     private float IIR_CONST = 0.85F; // TODO: Scale dynamically, lower => more older data
 
-    public Gen2NoteFinderDFT(uint octaveCount, uint sampleRate, float startFrequency, float loudnessCorrection, TimingReceiverCallback? timingCallback) // TODO: Why are some properties while others not
+    /// <summary> Instantiates a Gen2DFT with the desired settings. </summary>
+    /// <param name="octaveCount"> The number of octaves to analyze </param>
+    /// <param name="binsPerOctave"> The number of output bins to calculate for each octave, must be a multiple of 4 </param>
+    /// <param name="sampleRate"> The sample rate of the input audio signal </param>
+    /// <param name="startFrequency"> The desired frequency of the lowest bin </param>
+    /// <param name="loudnessCorrection"> The amount of human ear-modelled loudness correction to apply to the output bin values, between 0.0 and 1.0 </param>
+    /// <param name="timingCallback"> A callback that will be dispatched at defined regular intervals during audio processing </param>
+    public Gen2NoteFinderDFT(uint octaveCount, uint binsPerOctave, uint sampleRate, float startFrequency, float loudnessCorrection, TimingReceiverCallback? timingCallback) // TODO: Why are some properties while others not
     {
         this.OctaveCount = octaveCount;
+        this.BinsPerOctave = binsPerOctave;
         this.SampleRate = sampleRate;
         this.StartFrequency = startFrequency;
         this.LoudnessCorrectionAmount = loudnessCorrection;
         this.TimingCallback = timingCallback;
 
-        this.BinCount = (ushort)(OctaveCount * BINS_PER_OCTAVE);
-        this.StartOfTopOctave = (ushort)((OctaveCount - 1) * BINS_PER_OCTAVE);
+        this.BinCount = (ushort)(OctaveCount * BinsPerOctave);
+        this.StartOfTopOctave = (ushort)((OctaveCount - 1) * BinsPerOctave);
         this.StartFrequencyOfTopOctave = StartFrequency * MathF.Pow(2, OctaveCount - 1);
 
         AudioBufferSizes = new uint[BinCount];
@@ -172,9 +179,9 @@ public sealed class Gen2NoteFinderDFT
         {
             float BinFrequency;
             uint ThisBufferSize;
-            float ThisOctaveStart = StartFrequency * MathF.Pow(2, Bin / BINS_PER_OCTAVE);
-            BinFrequency = CalculateNoteFrequency(StartFrequency, BINS_PER_OCTAVE, Bin);
-            float NextBinFrequency = CalculateNoteFrequency(StartFrequency, BINS_PER_OCTAVE, Bin + 2);
+            float ThisOctaveStart = StartFrequency * MathF.Pow(2, Bin / BinsPerOctave);
+            BinFrequency = CalculateNoteFrequency(StartFrequency, BinsPerOctave, Bin);
+            float NextBinFrequency = CalculateNoteFrequency(StartFrequency, BinsPerOctave, Bin + 2);
             //float IdealWindowSize = WindowSizeForBinWidth(TopOctaveNextBinFreq - TopOctaveBinFreq); // TODO: Add scale factor to shift this from no overlap to -3dB point
             ThisBufferSize = RoundedWindowSizeForBinWidth(NextBinFrequency - BinFrequency, BinFrequency, SampleRate);
 
@@ -185,8 +192,8 @@ public sealed class Gen2NoteFinderDFT
             MaxAudioBufferSize = Math.Max(MaxAudioBufferSize, ThisBufferSize);
 
             float NCOffset = SampleRate / (AudioBufferSizes[Bin] * 2F);
-            float StepSizeNCL = USHORT_RANGE * (CalculateNoteFrequency(StartFrequency, BINS_PER_OCTAVE, Bin) - NCOffset) / SampleRate;
-            float StepSizeNCR = USHORT_RANGE * (CalculateNoteFrequency(StartFrequency, BINS_PER_OCTAVE, Bin) + NCOffset) / SampleRate;
+            float StepSizeNCL = USHORT_RANGE * (CalculateNoteFrequency(StartFrequency, BinsPerOctave, Bin) - NCOffset) / SampleRate;
+            float StepSizeNCR = USHORT_RANGE * (CalculateNoteFrequency(StartFrequency, BinsPerOctave, Bin) + NCOffset) / SampleRate;
             SinTableStepSize[Bin].NCLeft = (ushort)Math.Round(StepSizeNCL);
             SinTableStepSize[Bin].NCRight = (ushort)Math.Round(StepSizeNCR);
 
@@ -214,10 +221,10 @@ public sealed class Gen2NoteFinderDFT
             for (int Octave = 0; Octave < OctaveCount; Octave++)
             {
                 StringBuilder OctaveOutput = new();
-                OctaveOutput.Append($"{RawBinFrequencies[Octave * BINS_PER_OCTAVE]:F1}~{RawBinFrequencies[((Octave + 1) * BINS_PER_OCTAVE) - 1]:F1}Hz: ");
-                for (uint Bin = 0; Bin < BINS_PER_OCTAVE; Bin++)
+                OctaveOutput.Append($"{RawBinFrequencies[Octave * BinsPerOctave]:F1}~{RawBinFrequencies[((Octave + 1) * BinsPerOctave) - 1]:F1}Hz: ");
+                for (uint Bin = 0; Bin < BinsPerOctave; Bin++)
                 {
-                    OctaveOutput.Append(AudioBufferSizes[(Octave * BINS_PER_OCTAVE) + Bin]);
+                    OctaveOutput.Append(AudioBufferSizes[(Octave * BinsPerOctave) + Bin]);
                     OctaveOutput.Append(',');
                 }
                 Log.Debug(OctaveOutput.ToString());
@@ -567,7 +574,7 @@ public void CalculateOutput()
         lock (this.MergedDataLockObj)
         {
             if (this.MergedDataAmplitude == 0) { return; } // This may have (and actually often does) happen if multiple outputs are present and operating on different threads.
-            for (int Bin = 0; Bin < BINS_PER_OCTAVE; Bin++) { this.OctaveBinValues[Bin] = 0; }
+            for (int Bin = 0; Bin < BinsPerOctave; Bin++) { this.OctaveBinValues[Bin] = 0; }
 
             int BinIndex = 0;
             if (Avx2.IsSupported && ENABLE_SIMD)
@@ -619,7 +626,7 @@ public void CalculateOutput()
         for (int Bin = 0; Bin < BinCount; Bin++)
         {
             float OutBinVal = this.RawBinMagnitudes[Bin] * this.LoudnessCorrectionFactors[Bin];
-            this.OctaveBinValues[Bin % BINS_PER_OCTAVE] += OutBinVal / this.OctaveCount;
+            this.OctaveBinValues[Bin % BinsPerOctave] += OutBinVal / this.OctaveCount;
             this.AllBinValues[Bin + 1] = MathF.Max(0, OutBinVal - 0.08F);
         }
     }

Gen2DFTLib/Gen2DFT.cs

@@ -5,24 +5,28 @@
 namespace Gen2DFTLib;
 
 /// <summary> Provides the core DFT algorithm used in the Gen2NoteFinder in ColorChord.NET for use in other software. </summary>
-/// <remarks> Make sure to initialize with <see cref="Init(uint, uint, float, float)"/> before attempting to use. </remarks>
+/// <remarks> Make sure to initialize with <see cref="Init(uint, uint, uint, float, float)"/> before attempting to use. </remarks>
 public static unsafe class Gen2DFT
 {
     private static Gen2NoteFinderDFT DFT;
     private static GCHandle BinMagnitudesHandle, BinFrequenciesHandle, BinWidthsHandle;
 
     /// <summary> Prepares the DFT for use, initializing internal data structures. </summary>
     /// <param name="octaveCount"> The number of octaves to analyze </param>
+    /// <param name="binsPerOctave"> The number of output bins to calculate for each octave. Must be a multiple of 4 </param>
     /// <param name="sampleRate"> The sample rate of the input audio </param>
     /// <param name="startFrequency"> The desired frequency of the lowest bin </param>
     /// <param name="loudnessCorrection"> The amount of human-modelled loudness equalization to apply to the output bins </param>
+    /// <returns> 0 for success, negative value for failure </returns>
     [UnmanagedCallersOnly(EntryPoint = "Gen2DFT_Init")]
-    public static void Init(uint octaveCount, uint sampleRate, float startFrequency, float loudnessCorrection)
+    public static int Init(uint octaveCount, uint binsPerOctave, uint sampleRate, float startFrequency, float loudnessCorrection)
     {
-        DFT = new(octaveCount, sampleRate, startFrequency, loudnessCorrection, null);
+        if (binsPerOctave % 4 != 0) { return -1; }
+        DFT = new(octaveCount, binsPerOctave, sampleRate, startFrequency, loudnessCorrection, null);
         BinMagnitudesHandle = GCHandle.Alloc(DFT.RawBinMagnitudes, GCHandleType.Pinned);
         BinFrequenciesHandle = GCHandle.Alloc(DFT.RawBinFrequencies, GCHandleType.Pinned);
         BinWidthsHandle = GCHandle.Alloc(DFT.RawBinWidths, GCHandleType.Pinned);
+        return 0;
     }
 
     /// <summary> Processes the given audio data into the DFT. </summary>
@@ -49,18 +53,18 @@ public static void AddAudioData(short* newData, uint count)
     public static uint GetBinCount() => DFT.BinCount;
 
     /// <summary> Gets the current DFT output data. Make sure to call <see cref="CalculateOutput"/> before this. </summary>
-    /// <returns> The raw magnitudes of each DFT bin, array length is <see cref="GetBinCount"/>. This pointer will not change during runtime unless <see cref="Init(uint, uint, float, float)"/> is called again, so it is safe to reuse </returns>
+    /// <returns> The raw magnitudes of each DFT bin, array length is <see cref="GetBinCount"/>. This pointer will not change during runtime unless <see cref="Init(uint, uint, uint, float, float)"/> is called again, so it is safe to reuse </returns>
     [UnmanagedCallersOnly(EntryPoint = "Gen2DFT_GetBinMagnitudes")]
     public static float* GetBinMagnitudes() => (float*)BinMagnitudesHandle.AddrOfPinnedObject();
 
     /// <summary> Gets the central response frequencies of each DFT bin. </summary>
-    /// <returns> The frequency of each DFT bin in Hz, array length is <see cref="GetBinCount"/>. This pointer will not change during runtime unless <see cref="Init(uint, uint, float, float)"/> is called again, so it is safe to reuse </returns>
+    /// <returns> The frequency of each DFT bin in Hz, array length is <see cref="GetBinCount"/>. This pointer will not change during runtime unless <see cref="Init(uint, uint, uint, float, float)"/> is called again, so it is safe to reuse </returns>
     [UnmanagedCallersOnly(EntryPoint = "Gen2DFT_GetBinFrequencies")]
     public static float* GetBinFrequencies() => (float*)BinFrequenciesHandle.AddrOfPinnedObject();
 
     /// <summary> Gets the sensitivity range width of each bin, in number of bins. </summary>
     /// <remarks> A value of 2 would mean that this bin stops responding to frequencies around the center of the bin above and below (this bin's range = 1, plus 0.5 bins on either side) </remarks>
-    /// <returns> The width of each bin in number of bins, array length is <see cref="GetBinCount"/>. This pointer will not change during runtime unless <see cref="Init(uint, uint, float, float)"/> is called again, so it is safe to reuse </returns>
+    /// <returns> The width of each bin in number of bins, array length is <see cref="GetBinCount"/>. This pointer will not change during runtime unless <see cref="Init(uint, uint, uint, float, float)"/> is called again, so it is safe to reuse </returns>
     [UnmanagedCallersOnly(EntryPoint = "Gen2DFT_GetBinWidths")]
     public static float* GetBinWidths() => (float*)BinWidthsHandle.AddrOfPinnedObject();
 }