Audio processing improvements

- Move metering calculations to audio thread
- Try for 48K input if available
- Better state management for I/O switching, enabled/disabled toggle

Author: mcslee

src/main/java/heronarts/lx/audio/BandFilter.java

@@ -32,6 +32,8 @@
 @LXModulator.Device("Band Filter")
 public class BandFilter extends LXModulator implements LXNormalizedParameter, LXOscComponent {
 
+  private static final int NYQUIST_FREQ = 24000;
+
   /**
    * Gain of the meter, in decibels
    */
@@ -110,15 +112,14 @@ public BandFilter(String label, LX lx) {
   public BandFilter(String label, GraphicMeter meter) {
     super(label);
 
-    this.impl = new LXMeterImpl(meter.numBands, meter.fft.getBandOctaveRatio());
+    this.impl = new LXMeterImpl(meter.numBands);
     this.meter = meter;
 
-    final int nyquist = meter.fft.getSampleRate() / 2;
-    this.minFreq = new BoundedParameter("Min Freq", 60, 0, nyquist)
+    this.minFreq = new BoundedParameter("Min Freq", 60, 0, NYQUIST_FREQ)
       .setDescription("Minimum frequency the gate responds to")
       .setExponent(4)
       .setUnits(LXParameter.Units.HERTZ);
-    this.maxFreq = new BoundedParameter("Max Freq", 120, 0, nyquist)
+    this.maxFreq = new BoundedParameter("Max Freq", 120, 0, NYQUIST_FREQ)
       .setDescription("Maximum frequency the gate responds to")
       .setExponent(4)
       .setUnits(LXParameter.Units.HERTZ);
@@ -195,7 +196,7 @@ protected double computeValue(double deltaMs) {
     float newAverage = this.meter.fft.getAverage(this.minFreq.getValuef(), this.maxFreq.getValuef()) / this.meter.fft.getSize();
     float averageGain = (newAverage >= this.averageRaw) ? attackGain : releaseGain;
     this.averageRaw = newAverage + averageGain * (this.averageRaw - newAverage);
-    double averageDb = 20 * Math.log(this.averageRaw) / DecibelMeter.LOG_10 + gainValue + slopeValue * this.averageOctave;
+    double averageDb = DecibelMeter.amplitudeToDecibels(this.averageRaw) + gainValue + slopeValue * this.averageOctave;
     this.averageNorm = 1 + averageDb / rangeValue;
 
     return LXUtils.constrain(this.averageNorm, 0, 1);

src/main/java/heronarts/lx/audio/DecibelMeter.java

@@ -33,6 +33,7 @@
 public class DecibelMeter extends LXModulator implements LXNormalizedParameter, LXOscComponent {
 
   protected static final double LOG_10 = Math.log(10);
+  protected static final double RATIO_20_LOG10 = 20. / LOG_10;
 
   protected LXAudioBuffer buffer;
 
@@ -94,15 +95,16 @@ private static class Parameters {
 
   private final static double PEAK_HOLD_MS = 250;
 
-  protected float attackGain;
-  protected float releaseGain;
+  protected double attackGain;
+  protected double releaseGain;
 
   private float rmsRaw = 0;
-  private float rmsLevel = 0;
-  private double dbLevel = -96;
+  private double rmsEnv = 0;
+  private double rmsPeak = 0;
 
-  private float rmsPeak = 0;
+  private double dbEnv = -96;
   private double dbPeak = 0;
+
   private double normalizedPeak = 0;
   private double peakMillis = 0;
 
@@ -135,22 +137,39 @@ public DecibelMeter(String label, LXAudioBuffer buffer, Parameters params) {
 
   public DecibelMeter(String label, LXAudioBuffer buffer, CompoundParameter gain, CompoundParameter range, CompoundParameter attack, CompoundParameter release) {
     super(label);
-    this.buffer = buffer;
     this.gain = gain;
     this.range = range;
     this.attack = attack;
     this.release = release;
+    setBuffer(buffer);
   }
 
-  public DecibelMeter setBuffer(LXAudioBuffer buffer) {
+  public final DecibelMeter setBuffer(LXAudioBuffer buffer) {
+    if (this.buffer != null) {
+      this.buffer.removeMeter(this);
+    }
     this.buffer = buffer;
+    if (this.buffer != null) {
+      this.buffer.addMeter(this);
+    }
     return this;
   }
 
   public double getExponent() {
     throw new UnsupportedOperationException("DecibelMeter does not support exponent");
   }
 
+  /**
+   * Converts an amplitude (normalized 0-1, typically RMS) to decibels, negative
+   * value up to 0dbFS
+   *
+   * @param amplitude Normalized amplitude, 0-1
+   * @return Decibel value, negative infinity -> max 0dBFS
+   */
+  public static double amplitudeToDecibels(double amplitude) {
+    return RATIO_20_LOG10 * Math.log(amplitude);
+  }
+
   /**
    * Return raw underlying levels, no attack/gain smoothing
    *
@@ -164,7 +183,7 @@ public float getRaw() {
    * @return Raw decibel value of the meter
    */
   public double getDecibels() {
-    return this.dbLevel;
+    return this.dbEnv;
   }
 
   /**
@@ -189,37 +208,53 @@ public float getSquaref() {
     return (float) getSquare();
   }
 
-  @Override
-  protected double computeValue(double deltaMs) {
-    double releaseValue = this.release.getValue();
-    this.attackGain = (float) Math.exp(-deltaMs / this.attack.getValue());
-    this.releaseGain = (float) Math.exp(-deltaMs / releaseValue);
-
+  /**
+   * Compute new values when a frame of audio input is received. This is called by the
+   * thread that has filled the audio buffer.
+   */
+  protected void onAudioFrame() {
     this.rmsRaw = this.buffer.getRms();
-    float rmsGain = (this.rmsRaw >= this.rmsLevel) ? this.attackGain : this.releaseGain;
-    this.rmsLevel = this.rmsRaw + rmsGain * (this.rmsLevel - this.rmsRaw);
+
+    this.attackGain = Math.exp(-this.buffer.bufferSize() / (this.attack.getValue() * this.buffer.sampleRate() * .001));
+    this.releaseGain = Math.exp(-this.buffer.bufferSize() / (this.release.getValue() * this.buffer.sampleRate() * .001));
+
+    final double gain = (this.rmsRaw > this.rmsEnv) ? this.attackGain : this.releaseGain;
+    this.rmsEnv = (this.rmsRaw + gain * (this.rmsEnv - this.rmsRaw));
 
     if (this.rmsRaw > this.rmsPeak) {
       this.rmsPeak = this.rmsRaw;
       this.peakMillis = 0;
     } else {
-      this.peakMillis += deltaMs;
+      this.peakMillis += this.buffer.bufferSize() * 1000. / this.buffer.sampleRate();
       if (this.peakMillis > PEAK_HOLD_MS) {
-        double peakReleaseTime = Math.min(deltaMs, this.peakMillis - PEAK_HOLD_MS);
-        float releaseGain = (float) Math.exp(-peakReleaseTime / releaseValue);
-        this.rmsPeak *= releaseGain;
+        final double r = Math.exp(-this.buffer.bufferSize() / (this.release.getValue() * .001 * this.buffer.sampleRate()));
+        this.rmsPeak = this.rmsRaw + r * (this.rmsPeak - this.rmsRaw);
       }
     }
-    double range = this.range.getValue();
-    double gain = this.gain.getValue();
+  }
+
+  @Override
+  protected double computeValue(double deltaMs) {
+    final double range = this.range.getValue();
+    final double gain = this.gain.getValue();
 
-    this.dbPeak = 20 * Math.log(this.rmsPeak) / LOG_10 + gain;
+    this.dbPeak = amplitudeToDecibels(this.rmsPeak) + gain;
     this.normalizedPeak = LXUtils.constrain(1 + this.dbPeak / range, 0, 1);
 
-    this.dbLevel = 20 * Math.log(this.rmsLevel) / LOG_10 + gain;
-    return LXUtils.constrain(1 + this.dbLevel / range, 0, 1);
+    this.dbEnv = amplitudeToDecibels(this.rmsEnv) + gain;
+    return LXUtils.constrain(1 + this.dbEnv / range, 0, 1);
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    this.rmsRaw = 0;
+    this.rmsEnv = this.dbEnv = 0;
+    this.rmsPeak = this.dbPeak = this.normalizedPeak = 0;
+    setValue(0);
   }
 
+
   @Override
   public LXNormalizedParameter setNormalized(double value) {
     throw new UnsupportedOperationException("Cannot setNormalized on DecibelMeter");

src/main/java/heronarts/lx/audio/FourierTransform.java

@@ -18,6 +18,8 @@
 
 package heronarts.lx.audio;
 
+import java.util.Arrays;
+
 public class FourierTransform {
 
   public static final float LOG_2 = (float) Math.log(2);
@@ -40,8 +42,6 @@ public float getCoefficient(int i, int n) {
   private Window window = Window.HAMMING;
 
   private final int bufferSize;
-  private final int sampleRate;
-  private final float bandWidthInv;
 
   private final int logN;
   private final float[] sinN;
@@ -53,20 +53,25 @@ public float getCoefficient(int i, int n) {
   private final float[] imaginary;
   private final float[] amplitude;
 
-  private int numBands = 0;
-  private float[] bands;
-  private int[] bandOffset;
+  private final int numBands;
+  private final float[] bands;
+  private final int[] bandOffset;
+
+  // Function of sample rate, specified by compute() call
+  private int sampleRate;
+  private float bandWidthInv;
   private float bandOctaveRatio;
 
-  public FourierTransform(int bufferSize, int sampleRate) {
+  public FourierTransform(int bufferSize) {
+    this(bufferSize, DEFAULT_NUM_BANDS);
+  }
+
+  public FourierTransform(int bufferSize, int numBands) {
     if ((bufferSize & (bufferSize - 1)) != 0) {
       throw new IllegalArgumentException("bufferSize must be a power of two: " + bufferSize);
     }
 
     this.bufferSize = bufferSize;
-    this.sampleRate = sampleRate;
-    this.bandWidthInv = this.bufferSize / (float) this.sampleRate;
-
     this.logN = (int) (Math.log(bufferSize) / Math.log(2));
 
     this.sinN = new float[this.logN];
@@ -83,7 +88,9 @@ public FourierTransform(int bufferSize, int sampleRate) {
     this.imaginary = new float[this.bufferSize];
     this.amplitude = new float[this.bufferSize/2 + 1];
 
-    setNumBands(DEFAULT_NUM_BANDS);
+    this.numBands = numBands;
+    this.bands = new float[this.numBands];
+    this.bandOffset = new int[this.numBands + 1];
   }
 
   private void computePhaseTables() {
@@ -109,10 +116,6 @@ public int getSize() {
     return this.bufferSize;
   }
 
-  public int getSampleRate() {
-    return this.sampleRate;
-  }
-
   public FourierTransform setWindow(Window window) {
     if (this.window != window) {
       this.window = window;
@@ -127,10 +130,15 @@ private void computeWindowCoefficients() {
     }
   }
 
-  public FourierTransform compute(float[] samples) {
+  public FourierTransform compute(LXAudioBuffer buffer) {
+    final float[] samples = buffer.samples;
     if (samples.length != this.bufferSize) {
       throw new IllegalArgumentException("Samples must have same length as FourierTransform size: " + samples.length);
     }
+
+    // Set sample rate
+    setSampleRate(buffer.sampleRate());
+
     // Apply window function, initialize bit-reverse-indexed values
     for (int i = 0; i < this.bufferSize; ++i) {
       int bri = this.bitReverseIndex[i];
@@ -181,24 +189,27 @@ public float get(int i) {
     return this.amplitude[i];
   }
 
-  public FourierTransform setNumBands(int numBands) {
-    if (this.numBands != numBands) {
-      this.numBands = numBands;
-      this.bands = new float[this.numBands];
-      this.bandOffset = new int[this.numBands + 1];
-      this.bandOffset[0] = 0;
-
-      float nyquist = this.sampleRate / 2;
-      float nyquistRatio = nyquist / BASE_BAND_HZ;
-      float bandExpRange = (float) Math.log(nyquistRatio) / LOG_2;
-      this.bandOctaveRatio = bandExpRange / (this.numBands - 1);
-
-      for (int i = 0; i < this.numBands; ++i) {
-        float bandLimitHz = (float) Math.pow(2, i * this.bandOctaveRatio) * BASE_BAND_HZ;
-        this.bandOffset[i+1] = Math.round(this.bandWidthInv * bandLimitHz);
+  private void setSampleRate(int sampleRate) {
+    if (this.sampleRate != sampleRate) {
+      this.sampleRate = sampleRate;
+      if (this.sampleRate <= 0) {
+        this.bandWidthInv = 0;
+        this.bandOctaveRatio = 0;
+        Arrays.fill(this.bandOffset, 0);
+      } else {
+        this.bandWidthInv = this.bufferSize / (float) this.sampleRate;
+
+        float nyquist = this.sampleRate / 2;
+        float nyquistRatio = nyquist / BASE_BAND_HZ;
+        float bandExpRange = (float) Math.log(nyquistRatio) / LOG_2;
+        this.bandOctaveRatio = bandExpRange / (this.numBands - 1);
+
+        for (int i = 0; i < this.numBands; ++i) {
+          float bandLimitHz = (float) Math.pow(2, i * this.bandOctaveRatio) * BASE_BAND_HZ;
+          this.bandOffset[i+1] = Math.round(this.bandWidthInv * bandLimitHz);
+        }
       }
     }
-    return this;
   }
 
   public int getNumBands() {

src/main/java/heronarts/lx/audio/GraphicMeter.java

@@ -50,8 +50,6 @@ public class GraphicMeter extends DecibelMeter {
 
   public final FourierTransform fft;
 
-  private final float[] sampleBuffer;
-
   public final NormalizedParameter[] bands;
 
   public GraphicMeter(LXAudioComponent component) {
@@ -97,10 +95,8 @@ public GraphicMeter(LXAudioBuffer buffer, int numBands) {
   public GraphicMeter(String label, LXAudioBuffer buffer, int numBands) {
     super(label, buffer);
     addParameter("slope", this.slope);
-    this.sampleBuffer = new float[buffer.bufferSize()];
-    this.fft = new FourierTransform(buffer.bufferSize(), buffer.sampleRate());
-    this.fft.setNumBands(this.numBands = numBands);
-    this.impl = new LXMeterImpl(this.numBands, this.fft.getBandOctaveRatio());
+    this.fft = new FourierTransform(buffer.bufferSize(), this.numBands = numBands);
+    this.impl = new LXMeterImpl(this.numBands);
     this.bands = this.impl.bands;
     int i = 1;
     for (NormalizedParameter band : this.bands) {
@@ -109,32 +105,22 @@ public GraphicMeter(String label, LXAudioBuffer buffer, int numBands) {
   }
 
   @Override
-  protected double computeValue(double deltaMs) {
-    double result = super.computeValue(deltaMs);
-    this.buffer.getSamples(this.sampleBuffer);
-    this.fft.compute(this.sampleBuffer);
-
+  protected void onAudioFrame() {
+    super.onAudioFrame();
     this.impl.compute(
-      this.fft,
-      this.attackGain,
-      this.releaseGain,
+      this.fft.compute(this.buffer),
+      this.attackGain, // set by DecibelMeter.onAudioFrame()
+      this.releaseGain, // set by DecibelMeter.onAudioFrame()
       this.gain.getValue(),
       this.range.getValue(),
       this.slope.getValue()
     );
-
-    return result;
   }
 
-  /**
-   * Returns a snapshot of the last raw audio sample buffer frame that was used to compute
-   * this meter. Note that this is copy of the audio buffer local to the LX thread and this particular
-   * meter. The buffer is only updated when the meter is running, once per LX engine loop.
-   *
-   * @return Raw audio sample buffer used to compute this meter
-   */
-  public float[] getSamples() {
-    return this.sampleBuffer;
+  @Override
+  protected void onStop() {
+    super.onStop();
+    this.impl.onStop();
   }
 
   /**