Update src/lib/audio/audio-effects.js

src/lib/audio/audio-effects.js

@@ -29,7 +29,7 @@ class AudioEffects {
     static get effectTypes () {
         return effectTypes;
     }
-    constructor (buffer, name, trimStart, trimEnd) {
+    constructor (buffer, options, trimStart, trimEnd) {
         this.trimStartSeconds = (trimStart * buffer.length) / buffer.sampleRate;
         this.trimEndSeconds = (trimEnd * buffer.length) / buffer.sampleRate;
         this.adjustedTrimStartSeconds = this.trimStartSeconds;
@@ -44,8 +44,9 @@ class AudioEffects {
         let adjustedAffectedSampleCount = affectedSampleCount;
         const unaffectedSampleCount = sampleCount - affectedSampleCount;
 
+        // These affect the sampleCount
         this.playbackRate = 1;
-        switch (name) {
+        switch (options.preset) {
             case effectTypes.ECHO:
                 sampleCount = Math.max(sampleCount,
                     Math.floor((this.trimEndSeconds + EchoEffect.TAIL_SECONDS) * buffer.sampleRate));
@@ -54,7 +55,6 @@ class AudioEffects {
                 this.playbackRate = pitchRatio;
                 adjustedAffectedSampleCount = Math.floor(affectedSampleCount / this.playbackRate);
                 sampleCount = unaffectedSampleCount + adjustedAffectedSampleCount;
-
                 break;
             case effectTypes.SLOWER:
                 this.playbackRate = 1 / pitchRatio;
@@ -62,9 +62,7 @@ class AudioEffects {
                 sampleCount = unaffectedSampleCount + adjustedAffectedSampleCount;
                 break;
             default:
-                if (!((typeof name === "object") && (name.special === true))) break;
-                const options = name;
-                if (options.pitch !== null) {
+                if (Object.prototype.hasOwnProperty.call(options, "pitch")) {
                     this.playbackRate = centsToFrequency(options.pitch);
                     adjustedAffectedSampleCount = Math.floor(affectedSampleCount / this.playbackRate);
                     sampleCount = unaffectedSampleCount + adjustedAffectedSampleCount;
@@ -78,19 +76,30 @@ class AudioEffects {
         this.adjustedTrimStart = this.adjustedTrimStartSeconds / durationSeconds;
         this.adjustedTrimEnd = this.adjustedTrimEndSeconds / durationSeconds;
 
+        let audioContextSampleRate = buffer.sampleRate;
+        let audioContextSampleCount = sampleCount;
+        if (Object.prototype.hasOwnProperty.call(options, "sampleRateEnforced")) {
+            const newSampleRate = options.sampleRateEnforced;
+            audioContextSampleRate = newSampleRate;
+            audioContextSampleCount = Math.floor((sampleCount / buffer.sampleRate) * newSampleRate);
+        }
         if (window.OfflineAudioContext) {
-            this.audioContext = new window.OfflineAudioContext(1, sampleCount, buffer.sampleRate);
+            this.audioContext = new window.OfflineAudioContext(1, audioContextSampleCount, audioContextSampleRate);
         } else {
             // Need to use webkitOfflineAudioContext, which doesn't support all sample rates.
             // Resample by adjusting sample count to make room and set offline context to desired sample rate.
-            const sampleScale = 44100 / buffer.sampleRate;
-            this.audioContext = new window.webkitOfflineAudioContext(1, sampleScale * sampleCount, 44100);
+            const sampleScale = 44100 / audioContextSampleRate;
+            this.audioContext = new window.webkitOfflineAudioContext(1, sampleScale * audioContextSampleCount, 44100);
         }
 
+        // All effects not seen below use the original buffer because it is not modified.
+        this.buffer = buffer;
+
         // For the reverse effect we need to manually reverse the data into a new audio buffer
         // to prevent overwriting the original, so that the undo stack works correctly.
         // Doing buffer.reverse() would mutate the original data.
-        if (name === effectTypes.REVERSE) {
+        if (options.preset === effectTypes.REVERSE) {
+            const buffer = this.buffer;
             const originalBufferData = buffer.getChannelData(0);
             const newBuffer = this.audioContext.createBuffer(1, buffer.length, buffer.sampleRate);
             const newBufferData = newBuffer.getChannelData(0);
@@ -108,20 +117,72 @@ class AudioEffects {
                 }
             }
             this.buffer = newBuffer;
-        } else {
-            // All other effects use the original buffer because it is not modified.
-            this.buffer = buffer;
+        }
+        if (Object.prototype.hasOwnProperty.call(options, "sampleRate")) {
+            // We can't overwrite the original buffer so we make a clone.
+            const buffer = this.buffer;
+            const originalBufferData = buffer.getChannelData(0);
+            const newBuffer = this.audioContext.createBuffer(1, buffer.length, buffer.sampleRate);
+            const newBufferData = newBuffer.getChannelData(0);
+            const bufferLength = buffer.length;
+
+            // Our clone from earlier also needs to keep the original buffer's sample rate, so we need to make yet another buffer.
+            const sampleRateBuffer = this.makeSampleRateBuffer(buffer, durationSeconds, options.sampleRate);
+            const sampleRateBufferData = sampleRateBuffer.getChannelData(0);
+
+            const startSamples = Math.floor(this.trimStartSeconds * buffer.sampleRate);
+            const endSamples = Math.floor(this.trimEndSeconds * buffer.sampleRate);
+            for (let i = 0; i < bufferLength; i++) {
+                if (i >= startSamples && i < endSamples) {
+                    // We need to convert sampleRate back to the current buffer's sampleRate
+                    const sampleRateModifiedIndex = i * (sampleRateBuffer.sampleRate / buffer.sampleRate);
+                    const lowerIndex = Math.floor(sampleRateModifiedIndex);
+                    const upperIndex = Math.min(lowerIndex + 1, sampleRateBuffer.length - 1);
+                    const interpolation = sampleRateModifiedIndex - lowerIndex;
+
+                    const sample =
+                        sampleRateBufferData[lowerIndex] * (1 - interpolation) +
+                        sampleRateBufferData[upperIndex] * interpolation;
+                    // This works without Number.isFinite but it breaks the waveform preview SVG because sample can be NaN
+                    newBufferData[i] = Number.isFinite(sample) ? sample : 0;
+                } else {
+                    newBufferData[i] = originalBufferData[i];
+                }
+            }
+            this.buffer = newBuffer;
         }
 
         this.source = this.audioContext.createBufferSource();
         this.source.buffer = this.buffer;
-        this.name = name;
+        this.options = options;
+    }
+    makeSampleRateBuffer(buffer, durationSeconds, newSampleRate) {
+        const originalBufferData = buffer.getChannelData(0);
+        const newBufferLength = Math.floor(durationSeconds * newSampleRate);
+        const newBuffer = this.audioContext.createBuffer(1, newBufferLength, newSampleRate);
+        const newBufferData = newBuffer.getChannelData(0);
+        const bufferLength = buffer.length;
+
+        // this does work with just bufferLength but causes cut-off when newSampleRate is larger than the current sample rate
+        for (let i = 0; i < newBufferLength; i++) {
+            const originalIndex = i * (buffer.sampleRate / newSampleRate);
+            const lowerIndex = Math.floor(originalIndex);
+            const upperIndex = Math.min(lowerIndex + 1, bufferLength - 1);
+            const interpolation = originalIndex - lowerIndex;
+
+            const sample =
+                originalBufferData[lowerIndex] * (1 - interpolation) +
+                originalBufferData[upperIndex] * interpolation;
+            newBufferData[i] = sample;
+        }
+
+        return newBuffer;
     }
     process (done) {
         // Some effects need to use more nodes and must expose an input and output
         let input;
         let output;
-        switch (this.name) {
+        switch (this.options.preset) {
             case effectTypes.FASTER:
             case effectTypes.SLOWER:
                 this.source.playbackRate.setValueAtTime(this.playbackRate, this.adjustedTrimStartSeconds);
@@ -164,15 +225,12 @@ class AudioEffects {
                     this.adjustedTrimStartSeconds, this.adjustedTrimEndSeconds));
                 break;
             default:
-                const name = this.name;
-                if (!((typeof name === "object") && (name.special === true))) break;
-                const options = name;
-                if (options.pitch !== null) {
+                if (Object.prototype.hasOwnProperty.call(this.options, "pitch")) {
                     this.source.playbackRate.setValueAtTime(this.playbackRate, this.adjustedTrimStartSeconds);
                     this.source.playbackRate.setValueAtTime(1.0, this.adjustedTrimEndSeconds);
                 }
-                if (options.volume !== null) {
-                    ({input, output} = new VolumeEffect(this.audioContext, options.volume,
+                if (Object.prototype.hasOwnProperty.call(this.options, "volume")) {
+                    ({input, output} = new VolumeEffect(this.audioContext, this.options.volume,
                         this.adjustedTrimStartSeconds, this.adjustedTrimEndSeconds));
                 }
                 break;
@@ -192,8 +250,7 @@ class AudioEffects {
         this.audioContext.oncomplete = ({renderedBuffer}) => {
             done(renderedBuffer, this.adjustedTrimStart, this.adjustedTrimEnd);
         };
-
     }
 }
 
-export default AudioEffects;
+export default AudioEffects;