@ain1084/audio-worklet-stream 0.1.8 → 1.0.0

package/src/frame-buffer/buffer.ts

@@ -5,7 +5,7 @@
 export class FrameBuffer {
   private readonly _buffer: Float32Array
   private readonly _samplesPerFrame: number
-  private readonly _length: number
+  private readonly _frameCount: number
 
   /**
    * Creates an instance of FrameBuffer.
@@ -15,54 +15,65 @@ export class FrameBuffer {
   public constructor(buffer: Float32Array, samplesPerFrame: number) {
     this._buffer = buffer
     this._samplesPerFrame = samplesPerFrame
-    this._length = Math.floor(buffer.length / samplesPerFrame)
+    this._frameCount = Math.floor(buffer.length / samplesPerFrame)
   }
 
   /**
-   * Sets the frame data in the buffer.
-   * @param index - The starting index in the buffer.
-   * @param samples - The samples to set in the buffer.
-   * @param sampleStart - The starting position in the samples array (default is 0).
-   * @param sampleCount - The number of samples to set (default is the length of the samples array).
-   * @returns A number of written frames.
-   * @throws Error - If the number of samples per frame does not match the specified number of samples.
+   * Gets the count of the buffer in frames.
+   * @returns The count of the buffer in frames.
    */
-  public setFrames(index: number, samples: Float32Array, sampleStart: number = 0, sampleCount?: number): number {
-    index *= this._samplesPerFrame
-    const sampleEnd = (sampleCount !== undefined) ? Math.min(sampleStart + sampleCount, samples.length) : samples.length
-    const frames = (sampleEnd - sampleStart) / this._samplesPerFrame
-    if (!Number.isInteger(frames)) {
-      throw new Error(`Error: The number of samples per frame does not match the specified number of samples. Expected samples per frame: ${this._samplesPerFrame}, but got: ${sampleEnd - sampleStart}.`)
-    }
-    for (let sampleIndex = sampleStart; sampleIndex < sampleEnd; ++sampleIndex, ++index) {
-      this._buffer[index] = samples[sampleIndex]
-    }
-    return frames
+  public get frameCount(): number {
+    return this._frameCount
   }
 
-  /**
-   * Converts the frame data to output.
-   * This method is intended to be called from within the process method of the AudioWorkletProcessor.
-   * It converts the interleaved frame data to the structure expected by the process method's outputs.
-   * @param frameIndex - The index of the frame to convert.
-   * @param frames - The number of frames to convert.
-   * @param output - The output array to store the converted data.
-   * @param outputOffset - The offset in the output array at which to start storing the data.
-   */
-  public convertToOutput(frameIndex: number, frames: number, output: Float32Array[], outputOffset: number): void {
-    const samplesPerFrame = this._samplesPerFrame
-    output.forEach((outputChannel, channelNumber) => {
-      for (let i = channelNumber, j = 0; j < frames; i += samplesPerFrame, ++j) {
-        outputChannel[outputOffset + j] = this._buffer[frameIndex + i]
-      }
-    })
+  private getFrames(index: number, count: number): Float32Array {
+    return this._buffer.subarray(index * this._samplesPerFrame, (index + count) * this._samplesPerFrame)
   }
 
   /**
-   * Gets the length of the buffer in frames.
-   * @returns The length of the buffer in frames.
+   * Processes sections of a Float32Array buffer using a callback function.
+   * This function handles one or more segments within the ring buffer and invokes
+   * the provided callback for each segment. It is intended for internal use only.
+   *
+   * @param startIndex - The starting index in the buffer from where processing should begin.
+   * @param availableFrames - The total number of frames available to process in the buffer.
+   * @param processFrameSegment - The callback function invoked for each segment
+   *   of the ring buffer during enumeration. It receives:
+   *   1. `buffer`: A Float32Array representing the segment to process. The buffer is an array
+   *      of samples but is always provided in frame-sized segments.
+   *   2. `offset`: The cumulative number of frames processed so far, used as the starting index
+   *      for the current segment relative to the entire data.
+   *   The callback must return the number of frames it successfully processed.
+   *   If the callback processes fewer frames than available in the current segment,
+   *   processing will stop early.
+   *
+   * @returns An object containing:
+   *          - totalProcessedFrames: The number of frames successfully processed.
+   *          - nextIndex: The index in the buffer for the next processing cycle.
+   *
+   * @throws RangeError - If the processFrameSegment callback returns a processed length greater than the available section length.
+   *
+   * @remarks The buffer is always provided in frame-sized segments, meaning that the buffer contains complete frames.
+   * You must process the buffer in frame-sized chunks based on the structure of the frames.
    */
-  public get length(): number {
-    return this._length
+  public enumFrameSegments(startIndex: number, availableFrames: number,
+    processFrameSegment: (buffer: Float32Array, offset: number) => number): { totalProcessedFrames: number, nextIndex: number } {
+    let totalProcessedFrames = 0
+    while (totalProcessedFrames < availableFrames) {
+      // Determine the length of the current section to process
+      const sectionFrames = Math.min(this.frameCount - startIndex, availableFrames - totalProcessedFrames)
+      // Process the current section using the frameCallback function
+      const processedFrames = processFrameSegment(this.getFrames(startIndex, sectionFrames), totalProcessedFrames)
+      // Ensure the processed length does not exceed the section length
+      if (processedFrames > sectionFrames) {
+        throw new RangeError(`Processed frames (${processedFrames}) exceeds section frames (${sectionFrames})`)
+      }
+      totalProcessedFrames += processedFrames
+      startIndex = (startIndex + processedFrames) % this.frameCount
+      if (processedFrames < sectionFrames) {
+        break
+      }
+    }
+    return { totalProcessedFrames, nextIndex: startIndex }
   }
 }

package/src/output-message.ts

@@ -4,21 +4,21 @@
  * @typeParam type - The type of message. Can be 'stop' or 'underrun'.
  *
  * For 'stop' messages:
- * @property frames - The total frames processed when stopped.
+ * @property totalProcessedFrames - The total frames processed when stopped.
  *
  * For 'underrun' messages:
- * @property frames - The number of frames that have been underrun.
+ * @property underrunFrameCount - The number of frames that have been underrun.
  *
  * Example:
  * ```typescript
- * const message: MessageToAudioNode = { type: 'stop', frames: 1000n };
+ * const message: MessageToAudioNode = { type: 'stop', totalProcessedFrames: 1000n };
  * // or
- * const message: MessageToAudioNode = { type: 'underrun', frames: 256 };
+ * const message: MessageToAudioNode = { type: 'underrun', underrunFrameCount: 256 };
  * ```
  */
 export type MessageToAudioNode =
-  | { type: 'stop', frames: bigint }
-  | { type: 'underrun', frames: number }
+  | { type: 'stop', totalProcessedFrames: bigint }
+  | { type: 'underrun', underrunFrameCount: number }
 
 /**
  * Messages sent from the main thread to the processor.
@@ -26,12 +26,12 @@ export type MessageToAudioNode =
  * @typeParam type - The type of message. Can be 'stop'.
  *
  * For 'stop' messages:
- * @property frames - The position in frames to stop at.
+ * @property framePosition - The position in frames to stop at.
  *
  * Example:
  * ```typescript
- * const message: MessageToProcessor = { type: 'stop', frames: 1000n };
+ * const message: MessageToProcessor = { type: 'stop', framePosition: 1000n };
  * ```
  */
 export type MessageToProcessor =
-  | { type: 'stop', frames: bigint }
+  | { type: 'stop', framePosition: bigint }

package/src/output-stream-node.ts

@@ -3,7 +3,7 @@ import type { OutputStreamProcessorOptions } from './output-stream-processor'
 import { PROCESSOR_NAME } from './constants'
 import { StopEvent, UnderrunEvent } from './events'
 import { BufferWriteStrategy } from './write-strategy/strategy'
-import { FrameBufferConfig } from './frame-buffer/buffer-factory'
+import { FrameBufferConfig } from './frame-buffer/buffer-config'
 
 /**
  * Stream state
@@ -36,7 +36,7 @@ export class OutputStreamNode extends AudioWorkletNode {
    * @param bufferConfig - The configuration for the buffer.
    * @param strategy - The strategy for writing to the buffer.
    */
-  protected constructor(
+  private constructor(
     baseAudioContext: BaseAudioContext,
     bufferConfig: FrameBufferConfig,
     strategy: BufferWriteStrategy,
@@ -55,6 +55,21 @@ export class OutputStreamNode extends AudioWorkletNode {
     this.port.onmessage = this.handleMessage.bind(this)
   }
 
+  /**
+   * Creates an instance of OutputStreamNode.
+   * @param audioContext - The audio context to use.
+   * @param info - The configuration for the buffer.
+   * @param strategy - The strategy for writing to the buffer.
+   * @returns A promise that resolves to an instance of OutputStreamNode.
+   */
+  public static async create(audioContext: BaseAudioContext, info: FrameBufferConfig, strategy: BufferWriteStrategy): Promise<OutputStreamNode> {
+    const node = new OutputStreamNode(audioContext, info, strategy)
+    if (!(await strategy.onInit(node))) {
+      throw new Error('Failed to onInit.')
+    }
+    return node
+  }
+
   /**
    * Start playback.
    * The node must be connected before starting playback using connect() method.
@@ -84,17 +99,17 @@ export class OutputStreamNode extends AudioWorkletNode {
    * Stop the node processing at a given frame position.
    * Returns a Promise that resolves when the node has completely stopped.
    * The node is disconnected once stopping is complete.
-   * @param frames - The frame position at which to stop the processing, in frames.
-   *                   If frames is 0 or if the current playback frame position has already passed the specified value,
+   * @param framePosition - The frame position at which to stop the processing, in frames.
+   *                   If framePosition is 0 or if the current playback frame position has already passed the specified value,
    *                   the node will stop immediately.
    * @returns A promise that resolves when the node has stopped.
    */
-  public stop(frames: bigint = BigInt(0)): Promise<void> {
+  public stop(framePosition: bigint = BigInt(0)): Promise<void> {
     switch (this._state) {
       case 'started':
         return new Promise((resolve) => {
           this._state = 'stopping'
-          const message: MessageToProcessor = { type: 'stop', frames }
+          const message: MessageToProcessor = { type: 'stop', framePosition: framePosition }
           this.port.postMessage(message)
           this.addEventListener(StopEvent.type, () => {
             resolve()
@@ -121,10 +136,10 @@ export class OutputStreamNode extends AudioWorkletNode {
     switch (event.data.type) {
       case 'stop':
         this.handleStopped()
-        this.dispatchEvent(new StopEvent(event.data.frames))
+        this.dispatchEvent(new StopEvent(event.data.totalProcessedFrames))
         break
       case 'underrun':
-        this.dispatchEvent(new UnderrunEvent(event.data.frames))
+        this.dispatchEvent(new UnderrunEvent(event.data.underrunFrameCount))
         break
       default:
         throw new Error(`Unexpected event value: ${event.data}`)
@@ -178,24 +193,3 @@ export class OutputStreamNode extends AudioWorkletNode {
     return Atomics.load(this._totalWriteFrames, 0)
   }
 }
-
-/**
- * OutputStreamNodeFactory class
- * Factory class to create instances of OutputStreamNode.
- */
-export class OutputStreamNodeFactory extends OutputStreamNode {
-  /**
-   * Creates an instance of OutputStreamNodeFactory.
-   * @param audioContext - The audio context to use.
-   * @param info - The configuration for the buffer.
-   * @param strategy - The strategy for writing to the buffer.
-   * @returns A promise that resolves to an instance of OutputStreamNodeFactory.
-   */
-  public static async create(audioContext: BaseAudioContext, info: FrameBufferConfig, strategy: BufferWriteStrategy): Promise<OutputStreamNode> {
-    const node = new OutputStreamNodeFactory(audioContext, info, strategy)
-    if (!(await strategy.onInit(node))) {
-      throw new Error('Failed to onPrepare.')
-    }
-    return node
-  }
-}

package/src/output-stream-processor.ts

@@ -32,8 +32,8 @@ const createFrameBufferReader = (options: OutputStreamProcessorOptions) => {
 class OutputStreamProcessor extends AudioWorkletProcessor {
   private readonly _frameReader: FrameBufferReader
   private _shouldStop = false
-  private _stopFrames: bigint | undefined
-  private _underrunFrames = 0
+  private _stopFramePosition: bigint | undefined
+  private _underrunFrameCount = 0
 
   /**
    * Creates an instance of OutputStreamProcessor.
@@ -53,12 +53,12 @@ class OutputStreamProcessor extends AudioWorkletProcessor {
     if (event.data.type !== 'stop') {
       throw new Error(`Unexpected message type: ${event.data.type}`)
     }
-    const frames = event.data.frames
-    if (frames <= 0) {
+    const framePosition = event.data.framePosition
+    if (framePosition <= 0) {
       this._shouldStop = true
     }
     else {
-      this._stopFrames = frames
+      this._stopFramePosition = framePosition
     }
   }
 
@@ -67,18 +67,18 @@ class OutputStreamProcessor extends AudioWorkletProcessor {
    * If underrunFrames is provided and not zero, it adds to the current underrun frame count.
    * If underrunFrames is 0, it indicates that the underrun state has been resolved,
    * and the total underrun frame count is sent to the main thread before being reset.
-   * @param underrunFrames - The number of underrun frames to add (default is 0).
+   * @param underrunFrameCount - The number of underrun frames to add (default is 0).
    */
-  private updateUnderrun(underrunFrames: number = 0): void {
-    if (underrunFrames !== 0) {
-      this._underrunFrames += underrunFrames
+  private updateUnderrun(underrunFrameCount: number = 0): void {
+    if (underrunFrameCount !== 0) {
+      this._underrunFrameCount += underrunFrameCount
       return
     }
-    if (this._underrunFrames === 0) {
+    if (this._underrunFrameCount === 0) {
       return
     }
-    this.port.postMessage({ type: 'underrun', frames: this._underrunFrames } as MessageToAudioNode)
-    this._underrunFrames = 0
+    this.port.postMessage({ type: 'underrun', underrunFrameCount: this._underrunFrameCount } as MessageToAudioNode)
+    this._underrunFrameCount = 0
   }
 
   /**
@@ -86,7 +86,7 @@ class OutputStreamProcessor extends AudioWorkletProcessor {
    * @param totalFrames - The total number of frames processed so far.
    */
   private checkStopCondition(totalFrames: bigint) {
-    if (this._stopFrames !== undefined && totalFrames >= this._stopFrames) {
+    if (this._stopFramePosition !== undefined && totalFrames >= this._stopFramePosition) {
       this._shouldStop = true
     }
   }
@@ -99,16 +99,23 @@ class OutputStreamProcessor extends AudioWorkletProcessor {
    */
   process(_inputs: Float32Array[][], outputs: Float32Array[][]): boolean {
     const output = outputs[0]
-    const readFrames = this._frameReader.read((frame, offset) => {
-      const frames = Math.min(frame.frames, output[0].length - offset)
-      frame.buffer.convertToOutput(frame.index, frames, output, offset)
-      return frames
+    const samplesPerFrame = output.length
+    const readFrames = this._frameReader.read((buffer, offset) => {
+      const bufferFrameCount = buffer.length / samplesPerFrame
+      const frameCount = Math.min(bufferFrameCount, output[0].length - offset)
+      // Deinterleaves interleaved audio frame data and writes it to the output.
+      output.forEach((outputChannel, channelIndex) => {
+        for (let i = channelIndex, j = 0; j < frameCount; i += samplesPerFrame, ++j) {
+          outputChannel[offset + j] = buffer[i]
+        }
+      })
+      return frameCount
     })
     const totalFrames = this._frameReader.totalFrames
     this.checkStopCondition(totalFrames)
     if (this._shouldStop) {
       this.updateUnderrun()
-      this.port.postMessage({ type: 'stop', frames: totalFrames } as MessageToAudioNode)
+      this.port.postMessage({ type: 'stop', totalProcessedFrames: totalFrames } as MessageToAudioNode)
       this.port.close()
       return false
     }

package/src/stream-node-factory.ts

@@ -1,7 +1,7 @@
 import processor from './output-stream-processor?worker&url'
 import { ManualBufferWriteStrategy } from './write-strategy/manual'
-import { FrameBufferFactory } from './frame-buffer/buffer-factory'
-import type { OutputStreamNode, OutputStreamNodeFactory } from './output-stream-node'
+import { createFillerFrameBufferConfig, createFrameBufferConfig } from './frame-buffer/buffer-config'
+import type { OutputStreamNode } from './output-stream-node'
 import { TimedBufferWriteStrategy } from './write-strategy/timed'
 import type { FrameBufferFiller } from './frame-buffer/buffer-filler'
 import { FrameBufferWriter } from './frame-buffer/buffer-writer'
@@ -47,14 +47,14 @@ export type WorkerBufferNodeParams<T> = TimedBufferNodeParams & Readonly<{
  */
 export class StreamNodeFactory {
   private _audioContext: AudioContext
-  private readonly _outputStreamNodeFactory: typeof OutputStreamNodeFactory
+  private readonly _outputStreamNodeFactory: typeof OutputStreamNode
 
   /**
    * Constructor for StreamNodeFactory.
    * @param context - The AudioContext to use.
    * @param outputStreamNodeFactory - The factory for creating OutputStreamNode instances.
    */
-  private constructor(context: AudioContext, outputStreamNodeFactory: typeof OutputStreamNodeFactory) {
+  private constructor(context: AudioContext, outputStreamNodeFactory: typeof OutputStreamNode) {
     this._audioContext = context
     this._outputStreamNodeFactory = outputStreamNodeFactory
   }
@@ -72,7 +72,7 @@ export class StreamNodeFactory {
         context.audioWorklet.addModule(processor),
         import('./output-stream-node'),
       ])
-      return new StreamNodeFactory(context, loadResults[1].OutputStreamNodeFactory)
+      return new StreamNodeFactory(context, loadResults[1].OutputStreamNode)
     }
     catch (error) {
       throw new Error('Failed to load modules: ' + error)
@@ -91,9 +91,9 @@ export class StreamNodeFactory {
     if (params.frameBufferSize <= 0 || !Number.isInteger(params.frameBufferSize)) {
       throw new Error('Invalid frameBufferSize: must be a positive integer.')
     }
-    const bufferConfig = FrameBufferFactory.createFrameBufferConfig({ ...params })
-    const strategy = new ManualBufferWriteStrategy(bufferConfig)
-    return [await this._outputStreamNodeFactory.create(this.audioContext, bufferConfig, strategy), strategy.writer]
+    const config = createFrameBufferConfig({ ...params })
+    const strategy = new ManualBufferWriteStrategy(config)
+    return [await this._outputStreamNodeFactory.create(this.audioContext, config, strategy), strategy.writer]
   }
 
   /**
@@ -105,13 +105,14 @@ export class StreamNodeFactory {
   public async createTimedBufferNode(
     frameFiller: FrameBufferFiller, params: TimedBufferNodeParams,
   ): Promise<OutputStreamNode> {
-    StreamNodeFactory.validateTimedBufferNodeParams(params)
     if (typeof frameFiller !== 'object' || frameFiller === null) {
       throw new Error('Invalid frameFiller: must be an object.')
     }
-    const config = FrameBufferFactory.createFillerFrameBufferConfig(this._audioContext.sampleRate, { ...params })
-    const strategy = new TimedBufferWriteStrategy(config, frameFiller)
-    return this._outputStreamNodeFactory.create(this.audioContext, config, strategy)
+    StreamNodeFactory.validateTimedBufferNodeParams(params)
+    const paramsWithSampleRate = StreamNodeFactory.applySampleRateToParams(params, this._audioContext.sampleRate)
+    const config = createFillerFrameBufferConfig(paramsWithSampleRate)
+    return this._outputStreamNodeFactory.create(this.audioContext, config,
+      new TimedBufferWriteStrategy(config, frameFiller))
   }
 
   /**
@@ -124,9 +125,10 @@ export class StreamNodeFactory {
     worker: new () => Worker, params: WorkerBufferNodeParams<FillerParams>,
   ): Promise<OutputStreamNode> {
     StreamNodeFactory.validateTimedBufferNodeParams(params)
-    const config = FrameBufferFactory.createFillerFrameBufferConfig(this._audioContext.sampleRate, { ...params })
-    const strategy = new WorkerBufferWriteStrategy<FillerParams>(config, worker, params.fillerParams)
-    return this._outputStreamNodeFactory.create(this._audioContext, config, strategy)
+    const paramsWithSampleRate = StreamNodeFactory.applySampleRateToParams(params, this._audioContext.sampleRate)
+    const config = createFillerFrameBufferConfig(paramsWithSampleRate)
+    return this._outputStreamNodeFactory.create(this._audioContext, config,
+      new WorkerBufferWriteStrategy<FillerParams>(config, worker, params.fillerParams))
   }
 
   /**
@@ -151,6 +153,22 @@ export class StreamNodeFactory {
     }
   }
 
+  /**
+   * Applies a default sample rate to the given parameters if the sampleRate is undefined.
+   * This function creates a new TimedBufferNodeParams object with the specified sampleRate,
+   * while keeping other properties unchanged.
+   *
+   * @param params - The original parameters for the TimedBufferNode.
+   * @param defaultSampleRate - The default sample rate to use if params.sampleRate is undefined.
+   * @returns A new TimedBufferNodeParams object with the sample rate applied.
+   */
+  private static applySampleRateToParams(params: TimedBufferNodeParams, defaultSampleRate: number): TimedBufferNodeParams {
+    return {
+      ...params,
+      sampleRate: params.sampleRate ?? defaultSampleRate,
+    }
+  }
+
   /**
    * Get the AudioContext associated with this factory.
    * @returns The AudioContext instance.

package/src/write-strategy/manual.ts

@@ -1,5 +1,5 @@
 import { BufferWriteStrategy } from './strategy'
-import { createFrameBufferWriter, FrameBufferConfig } from '../frame-buffer/buffer-factory'
+import { createFrameBufferWriter, FrameBufferConfig } from '../frame-buffer/buffer-config'
 import { FrameBufferWriter } from '../frame-buffer/buffer-writer'
 
 /**

package/src/write-strategy/timed.ts

@@ -1,5 +1,5 @@
 import { BufferWriteStrategy } from './strategy'
-import { createFrameBufferWriter, FillerFrameBufferConfig } from '../frame-buffer/buffer-factory'
+import { createFrameBufferWriter, FillerFrameBufferConfig } from '../frame-buffer/buffer-config'
 import { FrameBufferWriter } from '../frame-buffer/buffer-writer'
 import { FrameBufferFiller } from '../frame-buffer/buffer-filler'
 import { OutputStreamNode } from '../output-stream-node'

package/src/write-strategy/worker/message.ts

@@ -1,4 +1,4 @@
-import type { FillerFrameBufferConfig } from '../../frame-buffer/buffer-factory'
+import type { FillerFrameBufferConfig } from '../../frame-buffer/buffer-config'
 
 /**
  * Message sent from the main thread to the worker.

package/src/write-strategy/worker/strategy.ts

@@ -1,5 +1,5 @@
 import type { BufferWriteStrategy } from '../strategy'
-import type { FillerFrameBufferConfig } from '../../frame-buffer/buffer-factory'
+import type { FillerFrameBufferConfig } from '../../frame-buffer/buffer-config'
 import type { MessageToStrategy, MessageToWorker } from './message'
 import type { OutputStreamNode } from '../../output-stream-node'
 

package/src/write-strategy/worker/worker.ts

@@ -1,4 +1,4 @@
-import { createFrameBufferWriter, FillerFrameBufferConfig } from '../../frame-buffer/buffer-factory'
+import { createFrameBufferWriter, FillerFrameBufferConfig } from '../../frame-buffer/buffer-config'
 import type { FrameBufferFiller } from '../../frame-buffer/buffer-filler'
 import type { FrameBufferWriter } from '../../frame-buffer/buffer-writer'
 import { MessageToStrategy, MessageToWorker } from './message'

package/src/frame-buffer/buffer-factory.ts

@@ -1,115 +0,0 @@
-import { FrameBuffer } from './buffer'
-import { FrameBufferWriter } from './buffer-writer'
-
-/**
- * Parameters for creating a FrameBuffer.
- * @property frameBufferSize - The size of the frame buffer.
- * @property channelCount - The number of audio channels.
- */
-export type FrameBufferParams = Readonly<{
-  frameBufferSize: number
-  channelCount: number
-}>
-
-/**
- * Parameters for creating a FillerFrameBuffer.
- * @property channelCount - The number of audio channels.
- * @property fillInterval - The interval in milliseconds for filling the buffer.
- * @property sampleRate - The sample rate of the audio context.
- * @property frameBufferChunks - The number of chunks in the frame buffer.
- */
-export type FillerFrameBufferParams = Readonly<{
-  channelCount: number
-  fillInterval?: number
-  sampleRate?: number
-  frameBufferChunks?: number
-}>
-
-/**
- * Configuration for a FrameBuffer.
- * This configuration is returned by the createFrameBufferConfig function.
- * @property sampleBuffer - The shared buffer for audio data frames.
- * @property samplesPerFrame - The number of samples per frame.
- * @property usedFramesInBuffer - The usage count of the frames in the buffer.
- * @property totalReadFrames - The total frames read from the buffer.
- * @property totalWriteFrames - The total frames written to the buffer.
- */
-export type FrameBufferConfig = Readonly<{
-  sampleBuffer: Float32Array
-  samplesPerFrame: number
-  usedFramesInBuffer: Uint32Array
-  totalReadFrames: BigUint64Array
-  totalWriteFrames: BigUint64Array
-}>
-
-/**
- * Configuration for a FillerFrameBuffer.
- * This configuration is returned by the createFillerFrameBufferConfig function.
- * @property sampleRate - The sample rate of the audio context.
- * @property fillInterval - The interval in milliseconds for filling the buffer.
- */
-export type FillerFrameBufferConfig = FrameBufferConfig & Readonly<{
-  sampleRate: number
-  fillInterval: number
-}>
-
-/**
- * Creates a FrameBufferWriter instance.
- * @param config - The configuration for the FrameBuffer.
- * @returns A new instance of FrameBufferWriter.
- */
-export const createFrameBufferWriter = (config: FrameBufferConfig): FrameBufferWriter => {
-  return new FrameBufferWriter(
-    new FrameBuffer(config.sampleBuffer, config.samplesPerFrame),
-    config.usedFramesInBuffer, config.totalWriteFrames,
-  )
-}
-
-/**
- * FrameBufferFactory class
- * Provides static methods to create frame buffer configurations and writers.
- */
-export class FrameBufferFactory {
-  public static readonly DEFAULT_FILL_INTERVAL_MS = 20
-  public static readonly DEFAULT_FRAME_BUFFER_CHUNKS = 5
-  public static readonly PROCESS_UNIT = 128
-
-  /**
-   * Creates a FrameBufferConfig instance.
-   * @param params - The parameters for the FrameBuffer.
-   * @returns A new instance of FrameBufferConfig.
-   */
-  public static createFrameBufferConfig(params: FrameBufferParams): FrameBufferConfig {
-    return {
-      sampleBuffer: new Float32Array(
-        new SharedArrayBuffer(params.frameBufferSize * params.channelCount * Float32Array.BYTES_PER_ELEMENT),
-      ),
-      samplesPerFrame: params.channelCount,
-      usedFramesInBuffer: new Uint32Array(new SharedArrayBuffer(Uint32Array.BYTES_PER_ELEMENT)),
-      totalReadFrames: new BigUint64Array(new SharedArrayBuffer(BigUint64Array.BYTES_PER_ELEMENT)),
-      totalWriteFrames: new BigUint64Array(new SharedArrayBuffer(BigUint64Array.BYTES_PER_ELEMENT)),
-    }
-  }
-
-  /**
-   * Creates a FillerFrameBufferConfig instance.
-   * @param defaultSampleRate - The sample rate of the audio context.
-   * @param params - The parameters for the FillerFrameBuffer.
-   * @returns A new instance of FillerFrameBufferConfig.
-   */
-  public static createFillerFrameBufferConfig(defaultSampleRate: number, params: FillerFrameBufferParams): FillerFrameBufferConfig {
-    const sampleRate = params.sampleRate ?? defaultSampleRate
-    const intervalMillisecond = params.fillInterval ?? FrameBufferFactory.DEFAULT_FILL_INTERVAL_MS
-    const frameBufferSize = Math.floor(
-      sampleRate * intervalMillisecond / 1000 + (FrameBufferFactory.PROCESS_UNIT - 1),
-    ) & ~(FrameBufferFactory.PROCESS_UNIT - 1)
-    const frameBufferChunkCount = params.frameBufferChunks ?? FrameBufferFactory.DEFAULT_FRAME_BUFFER_CHUNKS
-    const config = FrameBufferFactory.createFrameBufferConfig(
-      { frameBufferSize: frameBufferSize * frameBufferChunkCount, channelCount: params.channelCount })
-    return {
-      ...config,
-      sampleRate,
-      fillInterval: intervalMillisecond,
-    }
-  }
-}

package/src/frame-buffer/buffer-utils.ts

@@ -1,48 +0,0 @@
-import type { FrameBuffer } from './buffer'
-
-/**
- * Type definition for the callback function used in enumFrames.
- * The callback processes each section of the frame buffer.
- * @param frame - An object containing:
- *                - buffer: The FrameBuffer instance.
- *                - index: The starting index in the buffer.
- *                - frames: The number of frames in the section.
- * @param offset - The offset in the buffer from the start of processing.
- * @returns The number of frames processed.
- */
-export type FrameCallback = (frame: { buffer: FrameBuffer, index: number, frames: number }, offset: number) => number
-
-/**
- * Processes sections of a Float32Array buffer using a callback function.
- * This function is intended for internal use only.
- *
- * @param buffer - The FrameBuffer to process. This buffer is expected to be shared.
- * @param startIndex - The starting index in the buffer from where processing should begin.
- * @param availableFrames - The total number of frames available to process in the buffer.
- * @param frameCallback - The callback function to process each section of the buffer.
- *                          It should return the number of frames processed.
- * @returns An object containing:
- *          - frames: The number of frames successfully processed.
- *          - nextIndex: The index in the buffer for the next processing cycle.
- * @throws RangeError - If the frameCallback returns a processed length greater than the part length.
- */
-export const enumFrames = (buffer: FrameBuffer, startIndex: number, availableFrames: number, frameCallback: FrameCallback):
-{ frames: number, nextIndex: number } => {
-  let totalFrames = 0
-  while (totalFrames < availableFrames) {
-    // Determine the length of the current section to process
-    const sectionFrames = Math.min(buffer.length - startIndex, availableFrames - totalFrames)
-    // Process the current section using the frameCallback function
-    const processedFrames = frameCallback({ buffer, index: startIndex, frames: sectionFrames }, totalFrames)
-    // Ensure the processed length does not exceed the section length
-    if (processedFrames > sectionFrames) {
-      throw new RangeError(`Processed frames (${processedFrames}) exceeds section frames (${sectionFrames})`)
-    }
-    totalFrames += processedFrames
-    startIndex = (startIndex + processedFrames) % buffer.length
-    if (processedFrames < sectionFrames) {
-      break
-    }
-  }
-  return { frames: totalFrames, nextIndex: startIndex }
-}