@yume-chan/pcm-player 0.0.20 → 0.0.22

package/worker/worker.ts

@@ -1,80 +1,192 @@
+const INPUT_HOP_SIZE = 3000;
+const SCALE = 0.9;
+const OUTPUT_HOP_SIZE = (INPUT_HOP_SIZE * SCALE) | 0;
+
+const WINDOW_SIZE = 6000;
+const WINDOW_WEIGHT_TABLE = new Float32Array(WINDOW_SIZE);
+for (let i = 0; i < WINDOW_SIZE / 2; i += 1) {
+    const value = Math.sin((i / WINDOW_SIZE) * Math.PI);
+    WINDOW_WEIGHT_TABLE[i] = value;
+    WINDOW_WEIGHT_TABLE[WINDOW_SIZE - i - 1] = value;
+}
+
 abstract class SourceProcessor<T>
     extends AudioWorkletProcessor
     implements AudioWorkletProcessorImpl
 {
-    private _sources: T[] = [];
-    private _sourceSampleCount = 0;
+    channelCount: number;
+    #readBuffer: Float32Array;
+
+    #chunks: T[] = [];
+    #chunkSampleCounts: number[] = [];
+    #totalSampleCount = 0;
+
+    #starting = true;
+    #speedUp = false;
+    #readOffset = 0;
+    #inputOffset = 0;
+    #outputOffset = 0;
 
-    public constructor() {
+    constructor(options: { outputChannelCount?: number[] }) {
         super();
+
+        this.channelCount = options.outputChannelCount![0]!;
+        this.#readBuffer = new Float32Array(this.channelCount);
+
         this.port.onmessage = (event) => {
+            while (this.#totalSampleCount > 0.35 * 48000) {
+                this.#chunks.shift();
+                const count = this.#chunkSampleCounts.shift()!;
+                this.#totalSampleCount -= count;
+            }
+
             const data = event.data as ArrayBuffer[];
             const [source, length] = this.createSource(data);
-            this._sources.push(source);
-            this._sourceSampleCount += length;
+            this.#chunks.push(source);
+            this.#chunkSampleCounts.push(length);
+            this.#totalSampleCount += length;
+
+            if (!this.#speedUp && this.#totalSampleCount > 0.25 * 48000) {
+                this.#speedUp = true;
+                this.#readOffset = 0;
+                this.#inputOffset = 0;
+                this.#outputOffset = 0;
+            }
         };
     }
 
     protected abstract createSource(data: ArrayBuffer[]): [T, number];
 
-    process(_inputs: Float32Array[][], outputs: Float32Array[][]) {
-        const outputLeft = outputs[0]![0]!;
-        const outputRight = outputs[0]![1]!;
-        const outputLength = outputLeft.length;
-        let outputIndex = 0;
+    process(_inputs: Float32Array[][], [outputs]: Float32Array[][]) {
+        if (this.#starting) {
+            if (this.#totalSampleCount < 0.1 * 48000) {
+                return true;
+            } else {
+                this.#starting = false;
+            }
+        }
 
-        // Resample source catch up with output
-        // TODO: should we limit the minimum and maximum speed?
-        // TODO: this simple resample method changes pitch
-        const sourceIndexStep = this._sourceSampleCount > 48000 ? 1.02 : 1;
-        let sourceIndex = 0;
+        if (this.#speedUp && this.#totalSampleCount < 0.15 * 48000) {
+            this.#speedUp = false;
+            this.#starting = true;
+        }
+
+        const outputLength = outputs![0]!.length;
 
-        while (this._sources.length > 0 && outputIndex < outputLength) {
-            const beginSourceIndex = sourceIndex | 0;
+        if (this.#speedUp) {
+            for (let i = 0; i < outputLength; i += 1) {
+                let totalWeight = 0;
 
-            let source: T | undefined = this._sources[0];
-            [source, sourceIndex, outputIndex] = this.copyChunk(
-                sourceIndex,
-                sourceIndexStep,
+                const firstWindow = Math.max(
+                    0,
+                    Math.floor(
+                        (this.#outputOffset - WINDOW_SIZE) / OUTPUT_HOP_SIZE,
+                    ) + 1,
+                );
+
+                let inWindowIndex =
+                    this.#outputOffset - firstWindow * OUTPUT_HOP_SIZE;
+                let inputIndex = firstWindow * INPUT_HOP_SIZE + inWindowIndex;
+
+                while (inputIndex > 0 && inWindowIndex >= 0) {
+                    this.#read(inputIndex - this.#readOffset);
+                    const weight = WINDOW_WEIGHT_TABLE[inWindowIndex]!;
+                    for (let j = 0; j < this.channelCount; j += 1) {
+                        outputs![j]![i] += this.#readBuffer[j]! * weight;
+                    }
+                    totalWeight += weight;
+
+                    inputIndex += INPUT_HOP_SIZE - OUTPUT_HOP_SIZE;
+                    inWindowIndex -= OUTPUT_HOP_SIZE;
+                }
+
+                if (totalWeight > 0) {
+                    for (let j = 0; j < this.channelCount; j += 1) {
+                        outputs![j]![i] /= totalWeight;
+                    }
+                }
+
+                this.#outputOffset += 1;
+                if (firstWindow > 0) {
+                    this.#outputOffset -= OUTPUT_HOP_SIZE;
+                    this.#readOffset -= INPUT_HOP_SIZE;
+                    this.#inputOffset += (1 - SCALE) * INPUT_HOP_SIZE;
+                }
+            }
+
+            this.#inputOffset += outputLength;
+            const firstChunkSampleCount = this.#chunkSampleCounts[0]!;
+            if (
+                firstChunkSampleCount !== undefined &&
+                this.#inputOffset >= firstChunkSampleCount
+            ) {
+                this.#chunks.shift();
+                this.#chunkSampleCounts.shift();
+                this.#totalSampleCount -= firstChunkSampleCount;
+                this.#readOffset += firstChunkSampleCount;
+                this.#inputOffset -= firstChunkSampleCount;
+            }
+        } else {
+            this.#copyChunks(outputs!);
+        }
+
+        return true;
+    }
+
+    #copyChunks(outputs: Float32Array[]) {
+        let outputIndex = 0;
+        const outputLength = outputs[0]!.length;
+
+        while (this.#chunks.length > 0 && outputIndex < outputLength) {
+            let source: T | undefined = this.#chunks[0];
+            let consumedSampleCount = 0;
+            [source, consumedSampleCount, outputIndex] = this.copyChunk(
                 source!,
-                outputLeft,
-                outputRight,
+                outputs,
                 outputLength,
-                outputIndex
+                outputIndex,
             );
 
-            const consumedSampleCount = (sourceIndex | 0) - beginSourceIndex;
-            this._sourceSampleCount -= consumedSampleCount;
-            sourceIndex -= consumedSampleCount;
+            this.#totalSampleCount -= consumedSampleCount;
 
             if (source) {
                 // Output full
-                this._sources[0] = source;
-                return true;
+                this.#chunks[0] = source;
+                this.#chunkSampleCounts[0]! -= consumedSampleCount;
+                return;
             }
 
-            this._sources.shift();
+            this.#chunks.shift();
+            this.#chunkSampleCounts.shift();
         }
+    }
 
-        if (outputIndex < outputLength) {
-            console.log(
-                `[Audio] Buffer underflow, inserting silence: ${
-                    outputLength - outputIndex
-                } samples`
-            );
+    #read(offset: number) {
+        for (let i = 0; i < this.#chunks.length; i += 1) {
+            const length = this.#chunkSampleCounts[i]!;
+
+            if (offset < length) {
+                this.read(this.#chunks[i]!, offset, this.#readBuffer);
+                return;
+            }
+
+            offset -= length;
         }
 
-        return true;
+        this.#readBuffer.fill(0);
     }
 
+    protected abstract read(
+        source: T,
+        offset: number,
+        target: Float32Array,
+    ): void;
+
     protected abstract copyChunk(
-        sourceIndex: number,
-        sourceIndexStep: number,
         source: T,
-        outputLeft: Float32Array,
-        outputRight: Float32Array,
+        outputs: Float32Array[],
         outputLength: number,
-        outputIndex: number
+        outputIndex: number,
     ): [source: T | undefined, sourceIndex: number, outputIndex: number];
 }
 
@@ -84,135 +196,151 @@ class Int16SourceProcessor
 {
     protected override createSource(data: ArrayBuffer[]): [Int16Array, number] {
         const source = new Int16Array(data[0]!);
-        return [source, source.length / 2];
+        return [source, source.length / this.channelCount];
+    }
+
+    protected override read(
+        source: Int16Array,
+        offset: number,
+        target: Float32Array,
+    ) {
+        const sourceOffset = offset * this.channelCount;
+        for (let i = 0; i < this.channelCount; i += 1) {
+            target[i] = source[sourceOffset + i]! / 0x8000;
+        }
     }
 
     protected override copyChunk(
-        sourceIndex: number,
-        sourceIndexStep: number,
         source: Int16Array,
-        outputLeft: Float32Array,
-        outputRight: Float32Array,
+        outputs: Float32Array[],
         outputLength: number,
-        outputIndex: number
+        outputIndex: number,
     ): [
         source: Int16Array | undefined,
         sourceIndex: number,
-        outputIndex: number
+        outputIndex: number,
     ] {
         const sourceLength = source.length;
-        let sourceSampleIndex = sourceIndex << 1;
-
-        while (sourceSampleIndex < sourceLength) {
-            outputLeft[outputIndex] = source[sourceSampleIndex]! / 0x8000;
-            outputRight[outputIndex] = source[sourceSampleIndex + 1]! / 0x8000;
+        let sourceIndex = 0;
 
-            sourceIndex += sourceIndexStep;
-            sourceSampleIndex = sourceIndex << 1;
+        while (sourceIndex < sourceLength) {
+            for (let i = 0; i < this.channelCount; i += 1) {
+                outputs[i]![outputIndex] = source[sourceIndex]! / 0x8000;
+                sourceIndex += 1;
+            }
             outputIndex += 1;
 
             if (outputIndex === outputLength) {
                 return [
-                    sourceSampleIndex < sourceLength
-                        ? source.subarray(sourceSampleIndex)
+                    sourceIndex < sourceLength
+                        ? source.subarray(sourceIndex)
                         : undefined,
-                    sourceIndex,
+                    sourceIndex / this.channelCount,
                     outputIndex,
                 ];
             }
         }
 
-        return [undefined, sourceIndex, outputIndex];
+        return [undefined, sourceIndex / this.channelCount, outputIndex];
     }
 }
 
 class Float32SourceProcessor extends SourceProcessor<Float32Array> {
     protected override createSource(
-        data: ArrayBuffer[]
+        data: ArrayBuffer[],
     ): [Float32Array, number] {
         const source = new Float32Array(data[0]!);
-        return [source, source.length / 2];
+        return [source, source.length / this.channelCount];
+    }
+
+    protected override read(
+        source: Float32Array,
+        offset: number,
+        target: Float32Array,
+    ) {
+        const sourceOffset = offset * this.channelCount;
+        for (let i = 0; i < this.channelCount; i += 1) {
+            target[i] = source[sourceOffset + i]!;
+        }
     }
 
     protected override copyChunk(
-        sourceIndex: number,
-        sourceIndexStep: number,
         source: Float32Array,
-        outputLeft: Float32Array,
-        outputRight: Float32Array,
+        outputs: Float32Array[],
         outputLength: number,
-        outputIndex: number
+        outputIndex: number,
     ): [
         source: Float32Array | undefined,
         sourceIndex: number,
-        outputIndex: number
+        outputIndex: number,
     ] {
         const sourceLength = source.length;
-        let sourceSampleIndex = sourceIndex << 1;
-
-        while (sourceSampleIndex < sourceLength) {
-            outputLeft[outputIndex] = source[sourceSampleIndex]!;
-            outputRight[outputIndex] = source[sourceSampleIndex + 1]!;
+        let sourceIndex = 0;
 
-            sourceIndex += sourceIndexStep;
-            sourceSampleIndex = sourceIndex << 1;
+        while (sourceIndex < sourceLength) {
+            for (let i = 0; i < this.channelCount; i += 1) {
+                outputs[i]![outputIndex] = source[sourceIndex]!;
+                sourceIndex += 1;
+            }
             outputIndex += 1;
 
             if (outputIndex === outputLength) {
                 return [
-                    sourceSampleIndex < sourceLength
-                        ? source.subarray(sourceSampleIndex)
+                    sourceIndex < sourceLength
+                        ? source.subarray(sourceIndex)
                         : undefined,
-                    sourceIndex,
+                    sourceIndex / this.channelCount,
                     outputIndex,
                 ];
             }
         }
 
-        return [undefined, sourceIndex, outputIndex];
+        return [undefined, sourceIndex / this.channelCount, outputIndex];
     }
 }
 
 class Float32PlanerSourceProcessor extends SourceProcessor<Float32Array[]> {
     protected override createSource(
-        data: ArrayBuffer[]
+        data: ArrayBuffer[],
     ): [Float32Array[], number] {
         const source = data.map((channel) => new Float32Array(channel));
         return [source, source[0]!.length];
     }
 
+    protected override read(
+        source: Float32Array[],
+        offset: number,
+        target: Float32Array,
+    ) {
+        for (let i = 0; i < target.length; i += 1) {
+            target[i] = source[i]![offset]!;
+        }
+    }
+
     protected override copyChunk(
-        sourceIndex: number,
-        sourceIndexStep: number,
         source: Float32Array[],
-        outputLeft: Float32Array,
-        outputRight: Float32Array,
+        outputs: Float32Array[],
         outputLength: number,
-        outputIndex: number
+        outputIndex: number,
     ): [
         source: Float32Array[] | undefined,
         sourceIndex: number,
-        outputIndex: number
+        outputIndex: number,
     ] {
-        const sourceLeft = source[0]!;
-        const sourceRight = source[1]!;
-        const sourceLength = sourceLeft.length;
-        let sourceSampleIndex = sourceIndex | 0;
-
-        while (sourceSampleIndex < sourceLength) {
-            outputLeft[outputIndex] = sourceLeft[sourceSampleIndex]!;
-            outputRight[outputIndex] = sourceRight[sourceSampleIndex]!;
+        const sourceLength = source[0]!.length;
+        let sourceIndex = 0;
 
-            sourceIndex += sourceIndexStep;
-            sourceSampleIndex = sourceIndex | 0;
+        while (sourceIndex < sourceLength) {
+            for (let i = 0; i < this.channelCount; i += 1) {
+                outputs[i]![outputIndex] = source[i]![sourceIndex]!;
+            }
+            sourceIndex += 1;
             outputIndex += 1;
 
             if (outputIndex === outputLength) {
                 return [
-                    sourceSampleIndex < sourceLength
-                        ? source.map((channel) =>
-                              channel.subarray(sourceSampleIndex)
-                          )
+                    sourceIndex < sourceLength
+                        ? source.map((channel) => channel.subarray(sourceIndex))
                         : undefined,
                     sourceIndex,
                     outputIndex,
@@ -228,5 +356,5 @@ registerProcessor("int16-source-processor", Int16SourceProcessor);
 registerProcessor("float32-source-processor", Float32SourceProcessor);
 registerProcessor(
     "float32-planer-source-processor",
-    Float32PlanerSourceProcessor
+    Float32PlanerSourceProcessor,
 );