| !(function t(e, s, r) { |
| function i(o, f) { |
| if (!s[o]) { |
| if (!e[o]) { |
| var h = "function" == typeof require && require; |
| if (!f && h) return h(o, !0); |
| if (n) return n(o, !0); |
| var u = new Error("Cannot find module '" + o + "'"); |
| throw ((u.code = "MODULE_NOT_FOUND"), u); |
| } |
| var a = (s[o] = { exports: {} }); |
| e[o][0].call( |
| a.exports, |
| function (t) { |
| return i(e[o][1][t] || t); |
| }, |
| a, |
| a.exports, |
| t, |
| e, |
| s, |
| r, |
| ); |
| } |
| return s[o].exports; |
| } |
| for ( |
| var n = "function" == typeof require && require, o = 0; |
| o < r.length; |
| o++ |
| ) |
| i(r[o]); |
| return i; |
| })( |
| { |
| 1: [ |
| function (t, e, s) { |
| "use strict"; |
| function r(t) { |
| if ( |
| ((this.size = 0 | t), |
| this.size <= 1 || 0 != (this.size & (this.size - 1))) |
| ) |
| throw new Error( |
| "FFT size must be a power of two and bigger than 1", |
| ); |
| this._csize = t << 1; |
| for (var e = new Array(2 * this.size), s = 0; s < e.length; s += 2) { |
| const t = (Math.PI * s) / this.size; |
| (e[s] = Math.cos(t)), (e[s + 1] = -Math.sin(t)); |
| } |
| this.table = e; |
| for (var r = 0, i = 1; this.size > i; i <<= 1) r++; |
| (this._width = r % 2 == 0 ? r - 1 : r), |
| (this._bitrev = new Array(1 << this._width)); |
| for (var n = 0; n < this._bitrev.length; n++) { |
| this._bitrev[n] = 0; |
| for (var o = 0; o < this._width; o += 2) { |
| var f = this._width - o - 2; |
| this._bitrev[n] |= ((n >>> o) & 3) << f; |
| } |
| } |
| (this._out = null), (this._data = null), (this._inv = 0); |
| } |
| (e.exports = r), |
| (r.prototype.fromComplexArray = function (t, e) { |
| for ( |
| var s = e || new Array(t.length >>> 1), r = 0; |
| r < t.length; |
| r += 2 |
| ) |
| s[r >>> 1] = t[r]; |
| return s; |
| }), |
| (r.prototype.createComplexArray = function () { |
| const t = new Array(this._csize); |
| for (var e = 0; e < t.length; e++) t[e] = 0; |
| return t; |
| }), |
| (r.prototype.toComplexArray = function (t, e) { |
| for ( |
| var s = e || this.createComplexArray(), r = 0; |
| r < s.length; |
| r += 2 |
| ) |
| (s[r] = t[r >>> 1]), (s[r + 1] = 0); |
| return s; |
| }), |
| (r.prototype.completeSpectrum = function (t) { |
| for (var e = this._csize, s = e >>> 1, r = 2; r < s; r += 2) |
| (t[e - r] = t[r]), (t[e - r + 1] = -t[r + 1]); |
| }), |
| (r.prototype.transform = function (t, e) { |
| if (t === e) |
| throw new Error("Input and output buffers must be different"); |
| (this._out = t), |
| (this._data = e), |
| (this._inv = 0), |
| this._transform4(), |
| (this._out = null), |
| (this._data = null); |
| }), |
| (r.prototype.realTransform = function (t, e) { |
| if (t === e) |
| throw new Error("Input and output buffers must be different"); |
| (this._out = t), |
| (this._data = e), |
| (this._inv = 0), |
| this._realTransform4(), |
| (this._out = null), |
| (this._data = null); |
| }), |
| (r.prototype.inverseTransform = function (t, e) { |
| if (t === e) |
| throw new Error("Input and output buffers must be different"); |
| (this._out = t), |
| (this._data = e), |
| (this._inv = 1), |
| this._transform4(); |
| for (var s = 0; s < t.length; s++) t[s] /= this.size; |
| (this._out = null), (this._data = null); |
| }), |
| (r.prototype._transform4 = function () { |
| var t, |
| e, |
| s = this._out, |
| r = this._csize, |
| i = 1 << this._width, |
| n = (r / i) << 1, |
| o = this._bitrev; |
| if (4 === n) |
| for (t = 0, e = 0; t < r; t += n, e++) { |
| const s = o[e]; |
| this._singleTransform2(t, s, i); |
| } |
| else |
| for (t = 0, e = 0; t < r; t += n, e++) { |
| const s = o[e]; |
| this._singleTransform4(t, s, i); |
| } |
| var f = this._inv ? -1 : 1, |
| h = this.table; |
| for (i >>= 2; i >= 2; i >>= 2) { |
| var u = (n = (r / i) << 1) >>> 2; |
| for (t = 0; t < r; t += n) |
| for (var a = t + u, p = t, l = 0; p < a; p += 2, l += i) { |
| const t = p, |
| e = t + u, |
| r = e + u, |
| i = r + u, |
| n = s[t], |
| o = s[t + 1], |
| a = s[e], |
| c = s[e + 1], |
| d = s[r], |
| v = s[r + 1], |
| m = s[i], |
| b = s[i + 1], |
| _ = n, |
| B = o, |
| g = h[l], |
| y = f * h[l + 1], |
| w = a * g - c * y, |
| S = a * y + c * g, |
| z = h[2 * l], |
| x = f * h[2 * l + 1], |
| C = d * z - v * x, |
| I = d * x + v * z, |
| k = h[3 * l], |
| A = f * h[3 * l + 1], |
| T = m * k - b * A, |
| O = m * A + b * k, |
| q = _ + C, |
| P = B + I, |
| M = _ - C, |
| F = B - I, |
| R = w + T, |
| W = S + O, |
| H = f * (w - T), |
| E = f * (S - O), |
| N = q + R, |
| j = P + W, |
| L = q - R, |
| D = P - W, |
| U = M + E, |
| V = F - H, |
| G = M - E, |
| J = F + H; |
| (s[t] = N), |
| (s[t + 1] = j), |
| (s[e] = U), |
| (s[e + 1] = V), |
| (s[r] = L), |
| (s[r + 1] = D), |
| (s[i] = G), |
| (s[i + 1] = J); |
| } |
| } |
| }), |
| (r.prototype._singleTransform2 = function (t, e, s) { |
| const r = this._out, |
| i = this._data, |
| n = i[e], |
| o = i[e + 1], |
| f = i[e + s], |
| h = i[e + s + 1], |
| u = n + f, |
| a = o + h, |
| p = n - f, |
| l = o - h; |
| (r[t] = u), (r[t + 1] = a), (r[t + 2] = p), (r[t + 3] = l); |
| }), |
| (r.prototype._singleTransform4 = function (t, e, s) { |
| const r = this._out, |
| i = this._data, |
| n = this._inv ? -1 : 1, |
| o = 2 * s, |
| f = 3 * s, |
| h = i[e], |
| u = i[e + 1], |
| a = i[e + s], |
| p = i[e + s + 1], |
| l = i[e + o], |
| c = i[e + o + 1], |
| d = i[e + f], |
| v = i[e + f + 1], |
| m = h + l, |
| b = u + c, |
| _ = h - l, |
| B = u - c, |
| g = a + d, |
| y = p + v, |
| w = n * (a - d), |
| S = n * (p - v), |
| z = m + g, |
| x = b + y, |
| C = _ + S, |
| I = B - w, |
| k = m - g, |
| A = b - y, |
| T = _ - S, |
| O = B + w; |
| (r[t] = z), |
| (r[t + 1] = x), |
| (r[t + 2] = C), |
| (r[t + 3] = I), |
| (r[t + 4] = k), |
| (r[t + 5] = A), |
| (r[t + 6] = T), |
| (r[t + 7] = O); |
| }), |
| (r.prototype._realTransform4 = function () { |
| var t, |
| e, |
| s = this._out, |
| r = this._csize, |
| i = 1 << this._width, |
| n = (r / i) << 1, |
| o = this._bitrev; |
| if (4 === n) |
| for (t = 0, e = 0; t < r; t += n, e++) { |
| const s = o[e]; |
| this._singleRealTransform2(t, s >>> 1, i >>> 1); |
| } |
| else |
| for (t = 0, e = 0; t < r; t += n, e++) { |
| const s = o[e]; |
| this._singleRealTransform4(t, s >>> 1, i >>> 1); |
| } |
| var f = this._inv ? -1 : 1, |
| h = this.table; |
| for (i >>= 2; i >= 2; i >>= 2) { |
| var u = (n = (r / i) << 1) >>> 1, |
| a = u >>> 1, |
| p = a >>> 1; |
| for (t = 0; t < r; t += n) |
| for (var l = 0, c = 0; l <= p; l += 2, c += i) { |
| var d = t + l, |
| v = d + a, |
| m = v + a, |
| b = m + a, |
| _ = s[d], |
| B = s[d + 1], |
| g = s[v], |
| y = s[v + 1], |
| w = s[m], |
| S = s[m + 1], |
| z = s[b], |
| x = s[b + 1], |
| C = _, |
| I = B, |
| k = h[c], |
| A = f * h[c + 1], |
| T = g * k - y * A, |
| O = g * A + y * k, |
| q = h[2 * c], |
| P = f * h[2 * c + 1], |
| M = w * q - S * P, |
| F = w * P + S * q, |
| R = h[3 * c], |
| W = f * h[3 * c + 1], |
| H = z * R - x * W, |
| E = z * W + x * R, |
| N = C + M, |
| j = I + F, |
| L = C - M, |
| D = I - F, |
| U = T + H, |
| V = O + E, |
| G = f * (T - H), |
| J = f * (O - E), |
| K = N + U, |
| Q = j + V, |
| X = L + J, |
| Y = D - G; |
| if ( |
| ((s[d] = K), |
| (s[d + 1] = Q), |
| (s[v] = X), |
| (s[v + 1] = Y), |
| 0 !== l) |
| ) { |
| if (l !== p) { |
| var Z = L + -f * J, |
| $ = -D + -f * G, |
| tt = N + -f * U, |
| et = -j - -f * V, |
| st = t + a - l, |
| rt = t + u - l; |
| (s[st] = Z), |
| (s[st + 1] = $), |
| (s[rt] = tt), |
| (s[rt + 1] = et); |
| } |
| } else { |
| var it = N - U, |
| nt = j - V; |
| (s[m] = it), (s[m + 1] = nt); |
| } |
| } |
| } |
| }), |
| (r.prototype._singleRealTransform2 = function (t, e, s) { |
| const r = this._out, |
| i = this._data, |
| n = i[e], |
| o = i[e + s], |
| f = n + o, |
| h = n - o; |
| (r[t] = f), (r[t + 1] = 0), (r[t + 2] = h), (r[t + 3] = 0); |
| }), |
| (r.prototype._singleRealTransform4 = function (t, e, s) { |
| const r = this._out, |
| i = this._data, |
| n = this._inv ? -1 : 1, |
| o = 2 * s, |
| f = 3 * s, |
| h = i[e], |
| u = i[e + s], |
| a = i[e + o], |
| p = i[e + f], |
| l = h + a, |
| c = h - a, |
| d = u + p, |
| v = n * (u - p), |
| m = l + d, |
| b = c, |
| _ = -v, |
| B = l - d, |
| g = c, |
| y = v; |
| (r[t] = m), |
| (r[t + 1] = 0), |
| (r[t + 2] = b), |
| (r[t + 3] = _), |
| (r[t + 4] = B), |
| (r[t + 5] = 0), |
| (r[t + 6] = g), |
| (r[t + 7] = y); |
| }); |
| }, |
| {}, |
| ], |
| 2: [ |
| function (t, e, s) { |
| "use strict"; |
| const r = 128; |
| class i extends AudioWorkletProcessor { |
| constructor(t) { |
| super(t), |
| (this.nbInputs = t.numberOfInputs), |
| (this.nbOutputs = t.numberOfOutputs), |
| (this.blockSize = t.processorOptions.blockSize), |
| (this.hopSize = r), |
| (this.nbOverlaps = this.blockSize / this.hopSize), |
| (this.inputBuffers = new Array(this.nbInputs)), |
| (this.inputBuffersHead = new Array(this.nbInputs)), |
| (this.inputBuffersToSend = new Array(this.nbInputs)); |
| for (var e = 0; e < this.nbInputs; e++) |
| this.allocateInputChannels(e, 1); |
| (this.outputBuffers = new Array(this.nbOutputs)), |
| (this.outputBuffersToRetrieve = new Array(this.nbOutputs)); |
| for (e = 0; e < this.nbOutputs; e++) |
| this.allocateOutputChannels(e, 1); |
| } |
| reallocateChannelsIfNeeded(t, e) { |
| for (var s = 0; s < this.nbInputs; s++) { |
| let e = t[s].length; |
| e != this.inputBuffers[s].length && |
| this.allocateInputChannels(s, e); |
| } |
| for (s = 0; s < this.nbOutputs; s++) { |
| let t = e[s].length; |
| t != this.outputBuffers[s].length && |
| this.allocateOutputChannels(s, t); |
| } |
| } |
| allocateInputChannels(t, e) { |
| this.inputBuffers[t] = new Array(e); |
| for (var s = 0; s < e; s++) |
| (this.inputBuffers[t][s] = new Float32Array(this.blockSize + r)), |
| this.inputBuffers[t][s].fill(0); |
| (this.inputBuffersHead[t] = new Array(e)), |
| (this.inputBuffersToSend[t] = new Array(e)); |
| for (s = 0; s < e; s++) |
| (this.inputBuffersHead[t][s] = this.inputBuffers[t][s].subarray( |
| 0, |
| this.blockSize, |
| )), |
| (this.inputBuffersToSend[t][s] = new Float32Array( |
| this.blockSize, |
| )); |
| } |
| allocateOutputChannels(t, e) { |
| this.outputBuffers[t] = new Array(e); |
| for (var s = 0; s < e; s++) |
| (this.outputBuffers[t][s] = new Float32Array(this.blockSize)), |
| this.outputBuffers[t][s].fill(0); |
| this.outputBuffersToRetrieve[t] = new Array(e); |
| for (s = 0; s < e; s++) |
| (this.outputBuffersToRetrieve[t][s] = new Float32Array( |
| this.blockSize, |
| )), |
| this.outputBuffersToRetrieve[t][s].fill(0); |
| } |
| readInputs(t) { |
| if (t[0].length && 0 == t[0][0].length) |
| for (var e = 0; e < this.nbInputs; e++) |
| for (var s = 0; s < this.inputBuffers[e].length; s++) |
| this.inputBuffers[e][s].fill(0, this.blockSize); |
| else |
| for (e = 0; e < this.nbInputs; e++) |
| for (s = 0; s < this.inputBuffers[e].length; s++) { |
| let r = t[e][s]; |
| this.inputBuffers[e][s].set(r, this.blockSize); |
| } |
| } |
| writeOutputs(t) { |
| for (var e = 0; e < this.nbInputs; e++) |
| for (var s = 0; s < this.inputBuffers[e].length; s++) { |
| let i = this.outputBuffers[e][s].subarray(0, r); |
| t[e][s].set(i); |
| } |
| } |
| shiftInputBuffers() { |
| for (var t = 0; t < this.nbInputs; t++) |
| for (var e = 0; e < this.inputBuffers[t].length; e++) |
| this.inputBuffers[t][e].copyWithin(0, r); |
| } |
| shiftOutputBuffers() { |
| for (var t = 0; t < this.nbOutputs; t++) |
| for (var e = 0; e < this.outputBuffers[t].length; e++) |
| this.outputBuffers[t][e].copyWithin(0, r), |
| this.outputBuffers[t][e].subarray(this.blockSize - r).fill(0); |
| } |
| prepareInputBuffersToSend() { |
| for (var t = 0; t < this.nbInputs; t++) |
| for (var e = 0; e < this.inputBuffers[t].length; e++) |
| this.inputBuffersToSend[t][e].set(this.inputBuffersHead[t][e]); |
| } |
| handleOutputBuffersToRetrieve() { |
| for (var t = 0; t < this.nbOutputs; t++) |
| for (var e = 0; e < this.outputBuffers[t].length; e++) |
| for (var s = 0; s < this.blockSize; s++) |
| this.outputBuffers[t][e][s] += |
| this.outputBuffersToRetrieve[t][e][s] / this.nbOverlaps; |
| } |
| process(t, e, s) { |
| return ( |
| this.reallocateChannelsIfNeeded(t, e), |
| this.readInputs(t), |
| this.shiftInputBuffers(), |
| this.prepareInputBuffersToSend(), |
| this.processOLA( |
| this.inputBuffersToSend, |
| this.outputBuffersToRetrieve, |
| s, |
| ), |
| this.handleOutputBuffersToRetrieve(), |
| this.writeOutputs(e), |
| this.shiftOutputBuffers(), |
| !0 |
| ); |
| } |
| processOLA(t, e, s) { |
| console.assert(!1, "Not overriden"); |
| } |
| } |
| e.exports = i; |
| }, |
| {}, |
| ], |
| 3: [ |
| function (t, e, s) { |
| "use strict"; |
| const r = t("./ola-processor.js"), |
| i = t("fft.js"); |
| registerProcessor( |
| "phase-vocoder-processor", |
| class extends r { |
| static get parameterDescriptors() { |
| return [{ name: "pitchFactor", defaultValue: 1 }]; |
| } |
| constructor(t) { |
| (t.processorOptions = { blockSize: 2048 }), |
| super(t), |
| (this.fftSize = this.blockSize), |
| (this.timeCursor = 0), |
| (this.hannWindow = (function (t) { |
| let e = new Float32Array(t); |
| for (var s = 0; s < t; s++) |
| e[s] = 0.5 * (1 - Math.cos((2 * Math.PI * s) / t)); |
| return e; |
| })(this.blockSize)), |
| (this.fft = new i(this.fftSize)), |
| (this.freqComplexBuffer = this.fft.createComplexArray()), |
| (this.freqComplexBufferShifted = this.fft.createComplexArray()), |
| (this.timeComplexBuffer = this.fft.createComplexArray()), |
| (this.magnitudes = new Float32Array(this.fftSize / 2 + 1)), |
| (this.peakIndexes = new Int32Array(this.magnitudes.length)), |
| (this.nbPeaks = 0); |
| } |
| processOLA(t, e, s) { |
| const r = s.pitchFactor[s.pitchFactor.length - 1]; |
| for (var i = 0; i < this.nbInputs; i++) |
| for (var n = 0; n < t[i].length; n++) { |
| var o = t[i][n], |
| f = e[i][n]; |
| this.applyHannWindow(o), |
| this.fft.realTransform(this.freqComplexBuffer, o), |
| this.computeMagnitudes(), |
| this.findPeaks(), |
| this.shiftPeaks(r), |
| this.fft.completeSpectrum(this.freqComplexBufferShifted), |
| this.fft.inverseTransform( |
| this.timeComplexBuffer, |
| this.freqComplexBufferShifted, |
| ), |
| this.fft.fromComplexArray(this.timeComplexBuffer, f), |
| this.applyHannWindow(f); |
| } |
| this.timeCursor += this.hopSize; |
| } |
| applyHannWindow(t) { |
| for (var e = 0; e < this.blockSize; e++) |
| t[e] = t[e] * this.hannWindow[e]; |
| } |
| computeMagnitudes() { |
| for (var t = 0, e = 0; t < this.magnitudes.length; ) { |
| let s = this.freqComplexBuffer[e], |
| r = this.freqComplexBuffer[e + 1]; |
| (this.magnitudes[t] = s ** 2 + r ** 2), (t += 1), (e += 2); |
| } |
| } |
| findPeaks() { |
| this.nbPeaks = 0; |
| var t = 2; |
| let e = this.magnitudes.length - 2; |
| for (; t < e; ) { |
| let e = this.magnitudes[t]; |
| this.magnitudes[t - 1] >= e || this.magnitudes[t - 2] >= e |
| ? t++ |
| : this.magnitudes[t + 1] >= e || this.magnitudes[t + 2] >= e |
| ? t++ |
| : ((this.peakIndexes[this.nbPeaks] = t), |
| this.nbPeaks++, |
| (t += 2)); |
| } |
| } |
| shiftPeaks(t) { |
| this.freqComplexBufferShifted.fill(0); |
| for (var e = 0; e < this.nbPeaks; e++) { |
| let n = this.peakIndexes[e], |
| o = Math.round(n * t); |
| if (o > this.magnitudes.length) break; |
| var s = 0, |
| r = this.fftSize; |
| if (e > 0) { |
| let t = this.peakIndexes[e - 1]; |
| s = n - Math.floor((n - t) / 2); |
| } |
| if (e < this.nbPeaks - 1) { |
| let t = this.peakIndexes[e + 1]; |
| r = n + Math.ceil((t - n) / 2); |
| } |
| let f = r - n; |
| for (var i = s - n; i < f; i++) { |
| let t = n + i, |
| e = o + i; |
| if (e >= this.magnitudes.length) break; |
| let s = (2 * Math.PI * (e - t)) / this.fftSize, |
| r = Math.cos(s * this.timeCursor), |
| f = Math.sin(s * this.timeCursor), |
| h = 2 * t, |
| u = h + 1, |
| a = this.freqComplexBuffer[h], |
| p = this.freqComplexBuffer[u], |
| l = a * r - p * f, |
| c = a * f + p * r, |
| d = 2 * e, |
| v = d + 1; |
| (this.freqComplexBufferShifted[d] += l), |
| (this.freqComplexBufferShifted[v] += c); |
| } |
| } |
| } |
| }, |
| ); |
| }, |
| { "./ola-processor.js": 2, "fft.js": 1 }, |
| ], |
| }, |
| {}, |
| [3], |
| ); |
|
|
