@ain1084/audio-worklet-stream 0.1.8 → 1.0.1

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

@@ -1,4 +1,3 @@
-import { enumFrames, type FrameCallback } from './buffer-utils'
 import { FrameBuffer } from './buffer'
 
 /**
@@ -8,49 +7,72 @@ import { FrameBuffer } from './buffer'
  */
 export class FrameBufferWriter {
   private readonly _frameBuffer: FrameBuffer
-  private readonly _usedFrameInBuffer: Uint32Array
+  private readonly _usedFramesInBuffer: Uint32Array
   private readonly _totalFrames: BigUint64Array
   private _index: number = 0
 
   /**
    * Creates an instance of FrameBufferWriter.
    * @param frameBuffer - The shared buffer to write to.
-   * @param usedFrameInBuffer - The Uint32Array tracking the usage of the buffer.
+   * @param usedFramesInBuffer - The Uint32Array tracking the usage of the buffer.
    * @param totalFrames - The BigUint64Array tracking the total frames written to the buffer.
    */
-  constructor(frameBuffer: FrameBuffer, usedFrameInBuffer: Uint32Array, totalFrames: BigUint64Array) {
+  constructor(frameBuffer: FrameBuffer, usedFramesInBuffer: Uint32Array, totalFrames: BigUint64Array) {
     this._frameBuffer = frameBuffer
-    this._usedFrameInBuffer = usedFrameInBuffer
+    this._usedFramesInBuffer = usedFramesInBuffer
     this._totalFrames = totalFrames
   }
 
   /**
-   * Get the number of available spaces in the buffer.
-   * @returns The number of available spaces in the buffer.
+   * Get the number of available frames in the buffer.
+   * This represents the number of frames that can be written before the buffer is full.
+   * @returns The number of available frames in the buffer.
    */
-  public get available(): number {
-    return this._frameBuffer.length - Atomics.load(this._usedFrameInBuffer, 0)
+  public get availableFrames(): number {
+    return this._frameBuffer.frameCount - Atomics.load(this._usedFramesInBuffer, 0)
   }
 
   /**
    * Get the total number of frames written to the buffer.
+   *
    * @returns The total number of frames written.
    */
   public get totalFrames(): bigint {
+    // This class is not used concurrently by multiple threads,
+    // so `Atomics` is not necessary when reading `totalFrames`.
     return this._totalFrames[0]
   }
 
   /**
-   * Write audio frame data to the buffer using the provided frameCallback.
-   * @param frameCallback - The frameCallback function to process each section of the buffer.
-   * @returns The number of frames processed.
-   * @throws RangeError - If the processed length exceeds the part length.
+   * Writes audio frame data into the buffer using the provided callback.
+   * This method handles one or more writable segments within the ring buffer
+   * and invokes the callback for each segment.
+   *
+   * @param processFrameSegment - The callback function invoked for each writable segment
+   *   of the ring buffer. It receives:
+   *   1. `buffer`: A Float32Array representing the writable segment of the buffer.
+   *   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 wrote.
+   *   If the callback writes fewer frames than available in the current segment,
+   *   processing will stop early.
+   *
+   * @returns The total number of frames written across all segments.
+   *   Note: The return value is in frames, not in samples.
+   *
+   * @throws RangeError - If the processFrameSegment callback returns a written length greater than the available space in the current segment.
+   *
+   * @remarks The buffer is an array of samples, but it is always provided in frame-sized segments.
+   * Each frame consists of multiple samples (e.g., for stereo, a frame contains a sample for the left channel
+   * and one for the right channel). You must access and process the buffer in frame-sized chunks,
+   * based on the structure of the frames.
    */
-  public write(frameCallback: FrameCallback): number {
-    const result = enumFrames(this._frameBuffer, this._index, this.available, frameCallback)
+  public write(processFrameSegment: (buffer: Float32Array, offset: number) => number): number {
+    const result = this._frameBuffer.enumFrameSegments(this._index, this.availableFrames, processFrameSegment)
     this._index = result.nextIndex
-    Atomics.add(this._usedFrameInBuffer, 0, result.frames)
-    Atomics.add(this._totalFrames, 0, BigInt(result.frames))
-    return result.frames
+    Atomics.add(this._usedFramesInBuffer, 0, result.totalProcessedFrames)
+    Atomics.add(this._totalFrames, 0, BigInt(result.totalProcessedFrames))
+    return result.totalProcessedFrames
   }
 }

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'