@ain1084/audio-worklet-stream 1.0.5 → 2.0.0

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

@@ -1,82 +0,0 @@
-import { FrameBuffer } from './buffer'
-import { FrameBufferConfig } from './buffer-config'
-
-/**
- * FrameBufferWriter class
- * This class writes audio frame data to a shared Float32Array buffer.
- * The buffer usage is tracked using a Uint32Array.
- */
-export class FrameBufferWriter {
-  private readonly _frameBuffer: FrameBuffer
-  private readonly _usedFramesInBuffer: Uint32Array
-  private readonly _totalFrames: BigUint64Array
-  private _index: number = 0
-
-  /**
-   * @internal
-   * Creates an instance of FrameBufferWriter.
-   * @param config - The configuration object containing:
-   *   - `sampleBuffer`: The shared buffer to write audio data frames.
-   *   - `samplesPerFrame`: The number of samples per frame.
-   *   - `usedFramesInBuffer`: A Uint32Array tracking the usage of frames in the buffer.
-   *   - `totalWriteFrames`: A BigUint64Array tracking the total frames written to the buffer.
-   */
-  constructor(config: FrameBufferConfig) {
-    this._frameBuffer = new FrameBuffer(config.sampleBuffer, config.samplesPerFrame)
-    this._usedFramesInBuffer = config.usedFramesInBuffer
-    this._totalFrames = config.totalWriteFrames
-  }
-
-  /**
-   * 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 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]
-  }
-
-  /**
-   * 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(processFrameSegment: (buffer: Float32Array, offset: number) => number): number {
-    const result = this._frameBuffer.enumFrameSegments(this._index, this.availableFrames, processFrameSegment)
-    this._index = result.nextIndex
-    Atomics.add(this._usedFramesInBuffer, 0, result.totalProcessedFrames)
-    Atomics.add(this._totalFrames, 0, BigInt(result.totalProcessedFrames))
-    return result.totalProcessedFrames
-  }
-}

package/src/frame-buffer/buffer.ts

@@ -1,79 +0,0 @@
-/**
- * FrameBuffer class
- * This class manages a buffer of audio frames.
- */
-export class FrameBuffer {
-  private readonly _buffer: Float32Array
-  private readonly _samplesPerFrame: number
-  private readonly _frameCount: number
-
-  /**
-   * Creates an instance of FrameBuffer.
-   * @param buffer - The Float32Array buffer to manage.
-   * @param samplesPerFrame - The number of samples per frame.
-   */
-  public constructor(buffer: Float32Array, samplesPerFrame: number) {
-    this._buffer = buffer
-    this._samplesPerFrame = samplesPerFrame
-    this._frameCount = Math.floor(buffer.length / samplesPerFrame)
-  }
-
-  /**
-   * Gets the count of the buffer in frames.
-   * @returns The count of the buffer in frames.
-   */
-  public get frameCount(): number {
-    return this._frameCount
-  }
-
-  private getFrames(index: number, count: number): Float32Array {
-    return this._buffer.subarray(index * this._samplesPerFrame, (index + count) * this._samplesPerFrame)
-  }
-
-  /**
-   * 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 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 }
-  }
-}