higher samplerates for delta sigma

Author: ArdenButterfield

delta-sigma-panels/index.html

@@ -59,7 +59,7 @@ <h2>Delta-Sigma</h2>
           <div class="panel" id="delta-mod-panel"></div>
         </div>
         <div class="row sliders">
-          <div class="slider" id="sample-rate-slider"></div>
+          <div class="slider" id="ds-sample-rate-slider"></div>
           <div class="slider" id="delta-sigma-step-slider"></div>
         </div>
         <button class="play-button" id="play-delta-sigma">Play</button>

panel.js

@@ -136,15 +136,30 @@ class Panel {
     let pixel_max = this.plotHeight/2;
     let pixel_per_fullscale = pixel_max * this.settings.ampZoom;
     this.buffer.noFill();
-    //TODO: there are some artifacts here due to the way the signal is drawn, especially when zoomed in and/or large amplitude
     this.buffer.beginShape();
     this.buffer.curveTightness(1.0);
-    for (let x = 0; x < this.plotWidth; x++) {
-      let pixel_amp = pixel_per_fullscale * signal[Math.round(x/this.settings.timeZoom)];
+
+    const iToXScale = this.settings.timeZoom * (this.settings.displaySignalSize) / (signal.length);
+
+    const increment = Math.max(1, Math.floor(0.5/iToXScale));
+
+    console.log("inc", increment, "scale", iToXScale);
+
+    for (let i = 0; i < signal.length; i += increment) {
+      let x = i * iToXScale;
+      let pixel_amp = signal[i] * pixel_per_fullscale;
       let y = this.halfh - pixel_amp;
-      y = (y<this.plotTop)? y=this.plotTop : (y>this.plotBottom)? y= this.plotBottom : y=y; this.buffer.curveTightness(0.0);
+      // y = (y<this.plotTop)? this.plotTop : (y>this.plotBottom)? this.plotBottom : y;
+      this.buffer.curveTightness(0.0);
       this.buffer.curveVertex(x + this.plotLeft, y);
+      if (i === 0) {
+        this.buffer.curveVertex(x + this.plotLeft, y);
+      }
+      if (x > this.plotWidth) {
+        break;
+      }
     }
+
     this.buffer.endShape();
   }
 
@@ -436,7 +451,7 @@ class DeltaModPanel extends Panel {
     this.drawName();
     this.drawSignalAmplitudeTicks(this, this.plotHeight/2, 4);
     this.drawTimeTicks(this, this.numTimeTicks/this.settings.timeZoom, 1/(this.settings.timeZoom*this.settings.sampleRate));
-      }
+  }
 }
 
 

slider.js

@@ -217,6 +217,20 @@ class NumHarmSlider extends RangedSlider {
   }
 }
 
+class DeltaSigmaSampleRateSlider extends RangedSlider {
+  setup(p,settings){
+    this.settings = settings;
+    this.name ="Delta-Sigma sampling rate";
+    this.propName="deltaSigmaSamplingRate"
+    this.min = 1;
+    this.max = 1000000;
+    this.initial = 44100;
+    this.step = 1;
+    this.displayVal = this.initial;
+
+    this.makeSlider(p);
+  }
+}
 
 class SampleRateSlider extends RangedSlider{
   setup(p,settings){

waves.js

@@ -287,19 +287,15 @@ function filterSignal(signal, frequency, order, mode, filterKernel) {
 
     let characteristic = "butterworth";
 
-    // order = mode === "Butterworth" ? Math.min(order, 12) : Math.min(order, 4);
-
     let filterCoeffs = iirCalculator.lowpass({
-      order: order, // cascade 3 biquad filters (max: 12)
+      order: order, // cascade 3 biquad filters
       characteristic: characteristic,
       Fs: WEBAUDIO_MAX_SAMPLERATE, // sampling frequency
       Fc: frequency, // cutoff frequency / center frequency for bandpass, bandstop, peak
       preGain: false // adds one constant multiplication for highpass and lowpass
       // k = (1 + cos(omega)) * 0.5 / k = 1 with preGain == false
     });
 
-    console.log(filterCoeffs);
-
     let filter = new Fili.IirFilter(filterCoeffs);
 
     signal.forEach((x, n, y) => y[n] = filter.singleStep(x));
@@ -391,24 +387,86 @@ function renderOriginal(settings, fft, playback) {
   normalize(original, settings.amplitude);
 }
 
+function getInterpolatedSample(array, i) {
+  if (i <= 0) {
+    return array[0];
+  }
+  if (i >= array.length - 1) {
+    return array[array.length - 1];
+  }
+  let lowIndex = Math.floor(i);
+  let highIndex = lowIndex + 1;
+
+  return array[lowIndex] * (highIndex - i) + array[highIndex] * (i - lowIndex);
+}
+
 function renderDeltaSigma(settings, fft, playback) {
   let originalUnfiltered = playback ? settings.buffers.originalUnfiltered.playback : settings.buffers.originalUnfiltered.display;
   let deltaSigma = playback ? settings.buffers.deltaSigma.playback : settings.buffers.deltaSigma.display;
   let reconstructed = playback ? settings.buffers.reconstructed.playback : settings.buffers.reconstructed.display;
 
-  let samplePeriod = Math.floor(settings.downsamplingFactor);
   let step = settings.deltaSigmaStep;
-  let ds_state = 0;
-  for (let i = 0; i < originalUnfiltered.length; i += samplePeriod) {
-    if (ds_state > originalUnfiltered[i]) {
-      ds_state -= step;
-    } else {
-      ds_state += step;
+
+
+  if (settings.deltaSigmaSamplingRate <= (WEBAUDIO_MAX_SAMPLERATE/2)) {
+    if (!playback && deltaSigma.length !== settings.displaySignalSize) {
+      deltaSigma = new Float32Array(settings.displaySignalSize);
     }
-    for (let j = 0; j < samplePeriod; j += 1) {
-      deltaSigma[i+j] = ds_state;
-      reconstructed[i+j] = ds_state;
+    let samplePeriod = Math.floor(WEBAUDIO_MAX_SAMPLERATE / settings.deltaSigmaSamplingRate);
+    let ds_state = 0;
+    for (let i = 0; i < originalUnfiltered.length; i += samplePeriod) {
+      if (ds_state > originalUnfiltered[i]) {
+        ds_state -= step;
+      } else {
+        ds_state += step;
+      }
+      for (let j = 0; j < samplePeriod; j += 1) {
+        deltaSigma[i+j] = ds_state;
+        reconstructed[i+j] = ds_state;
+      }
+    }
+  } else if (!playback) {
+    // Simulate a higher sample rate
+    if (settings.buffers.deltaSigma.display.length !== settings.displaySignalSize * settings.deltaSigmaSamplingRate / WEBAUDIO_MAX_SAMPLERATE) {
+      settings.buffers.deltaSigma.display = new Float32Array(settings.displaySignalSize * settings.deltaSigmaSamplingRate / WEBAUDIO_MAX_SAMPLERATE);
+      settings.buffers.reconstructed.display = new Float32Array(settings.displaySignalSize * settings.deltaSigmaSamplingRate / WEBAUDIO_MAX_SAMPLERATE);
     }
+    let upsampledOutput = new Float32Array(settings.buffers.deltaSigma.display.length);
+
+    let ds_state = 0;
+    let scale = originalUnfiltered.length / settings.buffers.deltaSigma.display.length;
+    for (let i = 0; i < settings.buffers.deltaSigma.display.length; i += 1) {
+
+      if (ds_state > getInterpolatedSample(originalUnfiltered, i * scale)) {
+        ds_state -= step;
+      } else {
+        ds_state += step;
+      }
+      settings.buffers.deltaSigma.display[i] = ds_state;
+      settings.buffers.reconstructed.display[i] = ds_state;
+    }
+
+    // let iirCalculator = new Fili.CalcCascades();
+    //
+    // let characteristic = "butterworth";
+    //
+    // let filterCoeffs = iirCalculator.lowpass({
+    //   order: 6, // cascade 3 biquad filters
+    //   characteristic: characteristic,
+    //   Fs: settings.deltaSigmaSamplingRate, // sampling frequency
+    //   Fc: 20000, // cutoff frequency / center frequency for bandpass, bandstop, peak
+    //   preGain: false // adds one constant multiplication for highpass and lowpass
+    // });
+    //
+    // let filter = new Fili.IirFilter(filterCoeffs);
+    //
+    // upsampledOutput.forEach((x, n, y) => y[n] = filter.singleStep(x));
+    //
+    // const decimationRatio = settings.deltaSigmaSamplingRate / WEBAUDIO_MAX_SAMPLERATE;
+    // console.log(decimationRatio);
+    // for (let i = 0; i < reconstructed.length; ++i) {
+    //   reconstructed[i] = upsampledOutput[Math.min(Math.floor(i * decimationRatio), upsampledOutput.length - 1)];
+    // }
   }
 }
 
@@ -543,6 +601,7 @@ function downsampleWithQuantization(settings, fft, playback) {
 }
 
 function antiImagingFilter(settings, fft, playback) {
+
   let reconstructed = playback ? settings.buffers.reconstructed.playback : settings.buffers.reconstructed.display;
 
   // render reconstructed wave by low pass filtering the zero stuffed array----

widget.js

@@ -39,10 +39,12 @@ function getDefaultSettings() {
       deltaSigma: createBuffers()
     },
     amplitude: 1.0
+    , displaySignalSize: displaySignalSize
     , inputType: "Additive Synth"
     , fundFreq: 1250 // input signal fundamental freq
     , sampleRate: WEBAUDIO_MAX_SAMPLERATE
     , downsamplingFactor: 2
+    , deltaSigmaSamplingRate: 44100
     , noiseFloor: -96
     , numHarm: 2 //Number of harmonics
     , harmType: "All" // Harmonic series to evaluate - Odd, even or all
@@ -110,6 +112,7 @@ let sliderIdLookups = {
   'reconstruction-filter-order-slider': ReconstructionOrderSlider,
   'reconstruction-filter-freq-slider' : ReconstructionFilterFreqSlider,
   'sample-rate-slider' : SampleRateSlider,
+  'ds-sample-rate-slider' : DeltaSigmaSampleRateSlider,
   'dither-slider' : DitherSlider,
   'quantization-slider' : BitDepthSlider,
   'delta-sigma-step-slider' : DeltaSigmaStepSlider,