@gjsify/webaudio 0.1.9

package/lib/esm/audio-buffer-source-node.js

@@ -0,0 +1,63 @@
+import { AudioNode } from "./audio-node.js";
+import { AudioParam } from "./audio-param.js";
+import { GstPlayer } from "./gst-player.js";
+import { GainNode } from "./gain-node.js";
+class AudioBufferSourceNode extends AudioNode {
+  buffer = null;
+  loop = false;
+  loopStart = 0;
+  loopEnd = 0;
+  playbackRate;
+  onended = null;
+  _player = null;
+  _started = false;
+  constructor() {
+    super(0, 1);
+    this.playbackRate = new AudioParam(1, 0.0625, 16);
+  }
+  start(when = 0, offset = 0, duration) {
+    if (this._started) {
+      throw new DOMException("AudioBufferSourceNode can only be started once", "InvalidStateError");
+    }
+    this._started = true;
+    if (!this.buffer) return;
+    const gainNode = this._findGainNode();
+    const volume = gainNode ? gainNode.gain.value : 1;
+    this._player = new GstPlayer({
+      audioBuffer: this.buffer,
+      volume,
+      loop: this.loop,
+      offset,
+      duration,
+      playbackRate: this.playbackRate.value,
+      onEnded: () => {
+        if (gainNode) {
+          gainNode._activePlayers.delete(this._player);
+        }
+        this._player = null;
+        this.onended?.();
+      }
+    });
+    if (gainNode && this._player) {
+      gainNode._activePlayers.add(this._player);
+    }
+  }
+  stop(_when = 0) {
+    if (this._player) {
+      this._player.stop();
+    }
+  }
+  /** Walk the output chain to find a GainNode */
+  _findGainNode() {
+    for (const node of this._outputs) {
+      if (node instanceof GainNode) return node;
+      for (const inner of node._outputs) {
+        if (inner instanceof GainNode) return inner;
+      }
+    }
+    return null;
+  }
+}
+export {
+  AudioBufferSourceNode
+};

package/lib/esm/audio-buffer.js

@@ -0,0 +1,37 @@
+class AudioBuffer {
+  sampleRate;
+  length;
+  duration;
+  numberOfChannels;
+  /** @internal */
+  _channelData;
+  constructor(options) {
+    this.sampleRate = options.sampleRate;
+    this.length = options.length;
+    this.numberOfChannels = options.numberOfChannels;
+    this.duration = this.length / this.sampleRate;
+    this._channelData = [];
+    for (let i = 0; i < this.numberOfChannels; i++) {
+      this._channelData.push(new Float32Array(this.length));
+    }
+  }
+  getChannelData(channel) {
+    if (channel < 0 || channel >= this.numberOfChannels) {
+      throw new RangeError(`channel index ${channel} out of range [0, ${this.numberOfChannels})`);
+    }
+    return this._channelData[channel];
+  }
+  copyFromChannel(destination, channelNumber, bufferOffset = 0) {
+    const src = this.getChannelData(channelNumber);
+    const len = Math.min(destination.length, src.length - bufferOffset);
+    destination.set(src.subarray(bufferOffset, bufferOffset + len));
+  }
+  copyToChannel(source, channelNumber, bufferOffset = 0) {
+    const dest = this.getChannelData(channelNumber);
+    const len = Math.min(source.length, dest.length - bufferOffset);
+    dest.set(source.subarray(0, len), bufferOffset);
+  }
+}
+export {
+  AudioBuffer
+};

package/lib/esm/audio-context.js

@@ -0,0 +1,94 @@
+import GLib from "gi://GLib?version=2.0";
+import { ensureGstInit } from "./gst-init.js";
+import { AudioBuffer } from "./audio-buffer.js";
+import { AudioNode } from "./audio-node.js";
+import { AudioDestinationNode } from "./audio-destination-node.js";
+import { AudioBufferSourceNode } from "./audio-buffer-source-node.js";
+import { GainNode } from "./gain-node.js";
+import { decodeAudioDataSync } from "./gst-decoder.js";
+class AudioContext {
+  state = "suspended";
+  sampleRate = 44100;
+  destination;
+  listener = {};
+  _startTime;
+  constructor() {
+    ensureGstInit();
+    this._startTime = GLib.get_monotonic_time();
+    this.destination = new AudioDestinationNode();
+  }
+  /** Monotonically increasing time in seconds since context creation. */
+  get currentTime() {
+    return (GLib.get_monotonic_time() - this._startTime) / 1e6;
+  }
+  createGain() {
+    return new GainNode();
+  }
+  createBufferSource() {
+    return new AudioBufferSourceNode();
+  }
+  createBuffer(numberOfChannels, length, sampleRate) {
+    return new AudioBuffer({ numberOfChannels, length, sampleRate });
+  }
+  /**
+   * Decode encoded audio data (MP3, WAV, OGG, etc.) into an AudioBuffer.
+   * Uses GStreamer's decodebin for format-agnostic decoding.
+   */
+  decodeAudioData(arrayBuffer, successCallback, errorCallback) {
+    try {
+      const buffer = decodeAudioDataSync(arrayBuffer);
+      successCallback?.(buffer);
+      return Promise.resolve(buffer);
+    } catch (err) {
+      const domErr = err instanceof DOMException ? err : new DOMException("Unable to decode audio data", "EncodingError");
+      errorCallback?.(domErr);
+      return Promise.reject(domErr);
+    }
+  }
+  async resume() {
+    this.state = "running";
+  }
+  async suspend() {
+    this.state = "suspended";
+  }
+  async close() {
+    this.state = "closed";
+  }
+  // Stub methods for APIs not yet backed by GStreamer (Phase 3)
+  createAnalyser() {
+    return {
+      connect: () => {
+      },
+      disconnect: () => {
+      },
+      fftSize: 2048,
+      frequencyBinCount: 1024,
+      getByteFrequencyData: () => {
+      },
+      getFloatFrequencyData: () => {
+      }
+    };
+  }
+  createDynamicsCompressor() {
+    return new AudioNode();
+  }
+  createBiquadFilter() {
+    return new AudioNode();
+  }
+  createConvolver() {
+    return new AudioNode();
+  }
+  createPanner() {
+    return new AudioNode();
+  }
+  createStereoPanner() {
+    return new AudioNode();
+  }
+  addEventListener(_type, _listener) {
+  }
+  removeEventListener(_type, _listener) {
+  }
+}
+export {
+  AudioContext
+};

package/lib/esm/audio-destination-node.js

@@ -0,0 +1,10 @@
+import { AudioNode } from "./audio-node.js";
+class AudioDestinationNode extends AudioNode {
+  maxChannelCount = 2;
+  constructor() {
+    super(1, 0);
+  }
+}
+export {
+  AudioDestinationNode
+};

package/lib/esm/audio-node.js

@@ -0,0 +1,33 @@
+class AudioNode {
+  /** @internal downstream connections */
+  _outputs = /* @__PURE__ */ new Set();
+  /** @internal upstream connections */
+  _inputs = /* @__PURE__ */ new Set();
+  numberOfInputs;
+  numberOfOutputs;
+  channelCount;
+  constructor(numberOfInputs = 1, numberOfOutputs = 1) {
+    this.numberOfInputs = numberOfInputs;
+    this.numberOfOutputs = numberOfOutputs;
+    this.channelCount = 2;
+  }
+  connect(destination) {
+    this._outputs.add(destination);
+    destination._inputs.add(this);
+    return destination;
+  }
+  disconnect(destination) {
+    if (destination) {
+      this._outputs.delete(destination);
+      destination._inputs.delete(this);
+    } else {
+      for (const node of this._outputs) {
+        node._inputs.delete(this);
+      }
+      this._outputs.clear();
+    }
+  }
+}
+export {
+  AudioNode
+};

package/lib/esm/audio-param.js

@@ -0,0 +1,78 @@
+import GLib from "gi://GLib?version=2.0";
+class AudioParam {
+  defaultValue;
+  minValue;
+  maxValue;
+  /** @internal callback invoked when value changes */
+  _onChange = null;
+  _value;
+  _rampTimerId = null;
+  constructor(defaultValue = 0, minValue = -34028235e31, maxValue = 34028235e31) {
+    this.defaultValue = defaultValue;
+    this.minValue = minValue;
+    this.maxValue = maxValue;
+    this._value = defaultValue;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(v) {
+    this._cancelRamp();
+    this._value = Math.max(this.minValue, Math.min(this.maxValue, v));
+    this._onChange?.(this._value);
+  }
+  setValueAtTime(value, _startTime) {
+    this.value = value;
+    return this;
+  }
+  linearRampToValueAtTime(value, _endTime) {
+    this.value = value;
+    return this;
+  }
+  exponentialRampToValueAtTime(value, _endTime) {
+    this.value = value;
+    return this;
+  }
+  setTargetAtTime(target, _startTime, timeConstant) {
+    this._cancelRamp();
+    if (timeConstant <= 0) {
+      this.value = target;
+      return this;
+    }
+    const stepMs = Math.max(10, Math.round(timeConstant * 100));
+    this._rampTimerId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, stepMs, () => {
+      const diff = target - this._value;
+      if (Math.abs(diff) < 1e-3) {
+        this._value = target;
+        this._onChange?.(this._value);
+        this._rampTimerId = null;
+        return GLib.SOURCE_REMOVE;
+      }
+      const factor = 1 - Math.exp(-stepMs / (timeConstant * 1e3));
+      this._value += diff * factor;
+      this._onChange?.(this._value);
+      return GLib.SOURCE_CONTINUE;
+    });
+    return this;
+  }
+  setValueCurveAtTime(_values, _startTime, _duration) {
+    return this;
+  }
+  cancelScheduledValues(_startTime) {
+    this._cancelRamp();
+    return this;
+  }
+  cancelAndHoldAtTime(_cancelTime) {
+    this._cancelRamp();
+    return this;
+  }
+  _cancelRamp() {
+    if (this._rampTimerId !== null) {
+      GLib.source_remove(this._rampTimerId);
+      this._rampTimerId = null;
+    }
+  }
+}
+export {
+  AudioParam
+};

package/lib/esm/gain-node.js

@@ -0,0 +1,19 @@
+import { AudioNode } from "./audio-node.js";
+import { AudioParam } from "./audio-param.js";
+class GainNode extends AudioNode {
+  gain;
+  /** @internal active players that need volume updates */
+  _activePlayers = /* @__PURE__ */ new Set();
+  constructor() {
+    super(1, 1);
+    this.gain = new AudioParam(1, 0, 10);
+    this.gain._onChange = (value) => {
+      for (const player of this._activePlayers) {
+        player.setVolume(value);
+      }
+    };
+  }
+}
+export {
+  GainNode
+};

package/lib/esm/gst-decoder.js

@@ -0,0 +1,64 @@
+import { ensureGstInit, Gst } from "./gst-init.js";
+import { AudioBuffer } from "./audio-buffer.js";
+import GstApp from "gi://GstApp?version=1.0";
+void GstApp;
+const PIPELINE_DESC = "appsrc name=src ! decodebin ! audioconvert ! audioresample ! capsfilter caps=audio/x-raw,format=F32LE,layout=interleaved ! appsink name=sink sync=false";
+function decodeAudioDataSync(arrayBuffer) {
+  ensureGstInit();
+  const pipeline = Gst.parse_launch(PIPELINE_DESC);
+  const appsrc = pipeline.get_by_name("src");
+  const appsink = pipeline.get_by_name("sink");
+  pipeline.set_state(Gst.State.PLAYING);
+  const data = new Uint8Array(arrayBuffer);
+  appsrc.push_buffer(Gst.Buffer.new_wrapped(data));
+  appsrc.end_of_stream();
+  const chunks = [];
+  let sampleRate = 0;
+  let channels = 0;
+  while (true) {
+    const sample = appsink.try_pull_sample(2 * Number(Gst.SECOND));
+    if (!sample) break;
+    if (sampleRate === 0) {
+      const caps = sample.get_caps();
+      if (caps) {
+        const struct = caps.get_structure(0);
+        [, sampleRate] = struct.get_int("rate");
+        [, channels] = struct.get_int("channels");
+      }
+    }
+    const buffer = sample.get_buffer();
+    if (!buffer) continue;
+    const [ok, mapInfo] = buffer.map(Gst.MapFlags.READ);
+    if (ok) {
+      chunks.push(new Uint8Array(mapInfo.data));
+      buffer.unmap(mapInfo);
+    }
+  }
+  pipeline.set_state(Gst.State.NULL);
+  if (sampleRate === 0 || channels === 0) {
+    throw new DOMException("Unable to decode audio data", "EncodingError");
+  }
+  let totalBytes = 0;
+  for (const c of chunks) totalBytes += c.length;
+  const totalFrames = totalBytes / (4 * channels);
+  const audioBuffer = new AudioBuffer({
+    numberOfChannels: channels,
+    length: totalFrames,
+    sampleRate
+  });
+  let offset = 0;
+  for (const chunk of chunks) {
+    const f32 = new Float32Array(chunk.buffer, chunk.byteOffset, chunk.length / 4);
+    const framesInChunk = f32.length / channels;
+    for (let frame = 0; frame < framesInChunk; frame++) {
+      for (let ch = 0; ch < channels; ch++) {
+        audioBuffer._channelData[ch][offset + frame] = f32[frame * channels + ch];
+      }
+    }
+    offset += framesInChunk;
+  }
+  return audioBuffer;
+}
+export {
+  decodeAudioDataSync
+};

package/lib/esm/gst-init.js

@@ -0,0 +1,12 @@
+import Gst from "gi://Gst?version=1.0";
+let initialized = false;
+function ensureGstInit() {
+  if (!initialized) {
+    Gst.init(null);
+    initialized = true;
+  }
+}
+export {
+  Gst,
+  ensureGstInit
+};

package/lib/esm/gst-player.js

@@ -0,0 +1,125 @@
+import { ensureGstInit, Gst } from "./gst-init.js";
+import GstApp from "gi://GstApp?version=1.0";
+void GstApp;
+class GstPlayer {
+  _pipeline = null;
+  _volumeElement = null;
+  _busWatchId = null;
+  _ended = false;
+  _loop;
+  _onEnded;
+  _audioBuffer;
+  constructor(options) {
+    ensureGstInit();
+    this._loop = options.loop;
+    this._onEnded = options.onEnded;
+    this._audioBuffer = options.audioBuffer;
+    const { audioBuffer, volume, offset, duration, playbackRate } = options;
+    const sr = audioBuffer.sampleRate;
+    const ch = audioBuffer.numberOfChannels;
+    const pcmData = this._interleave(audioBuffer, offset, duration);
+    if (pcmData.length === 0) {
+      this._fireEnded();
+      return;
+    }
+    const capsStr = `audio/x-raw,format=F32LE,rate=${sr},channels=${ch},layout=interleaved`;
+    const desc = `appsrc name=src caps="${capsStr}" format=3 ! audioconvert ! volume name=vol ! autoaudiosink`;
+    this._pipeline = Gst.parse_launch(desc);
+    this._volumeElement = this._pipeline.get_by_name("vol");
+    const appsrc = this._pipeline.get_by_name("src");
+    this._volumeElement.set_property("volume", Math.max(0, Math.min(volume, 10)));
+    const bus = this._pipeline.get_bus();
+    this._busWatchId = bus.add_watch(0, (_bus, msg) => {
+      if (msg.type === Gst.MessageType.EOS) {
+        if (this._loop && !this._ended) {
+          this._restartPlayback(appsrc, pcmData);
+        } else {
+          this._fireEnded();
+        }
+      } else if (msg.type === Gst.MessageType.ERROR) {
+        this._fireEnded();
+      }
+      return true;
+    });
+    const gstBuf = Gst.Buffer.new_wrapped(pcmData);
+    const totalFrames = pcmData.length / (4 * ch);
+    gstBuf.pts = 0;
+    gstBuf.duration = Math.floor(totalFrames / sr * Number(Gst.SECOND));
+    appsrc.push_buffer(gstBuf);
+    appsrc.end_of_stream();
+    if (playbackRate !== 1) {
+      this._pipeline.set_state(Gst.State.PAUSED);
+      this._pipeline.seek(
+        playbackRate,
+        Gst.Format.TIME,
+        Gst.SeekFlags.FLUSH | Gst.SeekFlags.ACCURATE,
+        Gst.SeekType.SET,
+        0,
+        Gst.SeekType.NONE,
+        -1
+      );
+    }
+    this._pipeline.set_state(Gst.State.PLAYING);
+  }
+  /** Update volume on a running pipeline */
+  setVolume(value) {
+    if (this._volumeElement && !this._ended) {
+      this._volumeElement.set_property("volume", Math.max(0, Math.min(value, 10)));
+    }
+  }
+  /** Update loop flag */
+  setLoop(value) {
+    this._loop = value;
+  }
+  /** Stop playback and clean up */
+  stop() {
+    if (this._ended) return;
+    this._fireEnded();
+  }
+  /** Whether playback has ended */
+  get ended() {
+    return this._ended;
+  }
+  _restartPlayback(appsrc, pcmData) {
+    if (this._pipeline) {
+      this._pipeline.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, 0);
+    }
+  }
+  _fireEnded() {
+    if (this._ended) return;
+    this._ended = true;
+    this._cleanup();
+    this._onEnded();
+  }
+  _cleanup() {
+    if (this._pipeline) {
+      this._pipeline.set_state(Gst.State.NULL);
+      this._pipeline = null;
+    }
+    if (this._busWatchId !== null) {
+      this._busWatchId = null;
+    }
+    this._volumeElement = null;
+  }
+  /**
+   * Interleave AudioBuffer's per-channel Float32Arrays into a single Uint8Array.
+   * Applies offset (seconds) and optional duration (seconds).
+   */
+  _interleave(buf, offsetSec, durationSec) {
+    const ch = buf.numberOfChannels;
+    const startFrame = Math.min(Math.floor(offsetSec * buf.sampleRate), buf.length);
+    const maxFrames = buf.length - startFrame;
+    const frames = durationSec !== void 0 ? Math.min(Math.floor(durationSec * buf.sampleRate), maxFrames) : maxFrames;
+    if (frames <= 0) return new Uint8Array(0);
+    const interleaved = new Float32Array(frames * ch);
+    for (let frame = 0; frame < frames; frame++) {
+      for (let c = 0; c < ch; c++) {
+        interleaved[frame * ch + c] = buf._channelData[c][startFrame + frame];
+      }
+    }
+    return new Uint8Array(interleaved.buffer);
+  }
+}
+export {
+  GstPlayer
+};

package/lib/esm/html-audio-element.js

@@ -0,0 +1,61 @@
+import { ensureGstInit, Gst } from "./gst-init.js";
+const SUPPORTED_TYPES = /* @__PURE__ */ new Set([
+  "audio/mpeg",
+  "audio/mp3",
+  "audio/wav",
+  "audio/x-wav",
+  "audio/ogg",
+  "audio/webm",
+  "audio/flac",
+  "audio/x-flac",
+  "audio/aac",
+  "audio/mp4"
+]);
+class HTMLAudioElement {
+  src = "";
+  volume = 1;
+  loop = false;
+  paused = true;
+  currentTime = 0;
+  duration = 0;
+  readyState = 0;
+  _pipeline = null;
+  canPlayType(type) {
+    const mime = type.split(";")[0].trim().toLowerCase();
+    return SUPPORTED_TYPES.has(mime) ? "maybe" : "";
+  }
+  play() {
+    if (!this.src) return Promise.resolve();
+    ensureGstInit();
+    this._cleanup();
+    this._pipeline = Gst.ElementFactory.make("playbin", "player");
+    if (!this._pipeline) return Promise.resolve();
+    this._pipeline.set_property("uri", this.src);
+    this._pipeline.set_property("volume", this.volume);
+    this._pipeline.set_state(Gst.State.PLAYING);
+    this.paused = false;
+    return Promise.resolve();
+  }
+  pause() {
+    if (this._pipeline) {
+      this._pipeline.set_state(Gst.State.PAUSED);
+      this.paused = true;
+    }
+  }
+  load() {
+    this._cleanup();
+  }
+  addEventListener(_type, _listener) {
+  }
+  removeEventListener(_type, _listener) {
+  }
+  _cleanup() {
+    if (this._pipeline) {
+      this._pipeline.set_state(Gst.State.NULL);
+      this._pipeline = null;
+    }
+  }
+}
+export {
+  HTMLAudioElement
+};

package/lib/esm/index.js

@@ -0,0 +1,18 @@
+import { AudioContext } from "./audio-context.js";
+import { AudioBuffer } from "./audio-buffer.js";
+import { AudioNode } from "./audio-node.js";
+import { AudioDestinationNode } from "./audio-destination-node.js";
+import { AudioBufferSourceNode } from "./audio-buffer-source-node.js";
+import { GainNode } from "./gain-node.js";
+import { AudioParam } from "./audio-param.js";
+import { HTMLAudioElement } from "./html-audio-element.js";
+export {
+  AudioBuffer,
+  AudioBufferSourceNode,
+  AudioContext,
+  AudioDestinationNode,
+  AudioNode,
+  AudioParam,
+  GainNode,
+  HTMLAudioElement
+};

package/lib/esm/register.js

@@ -0,0 +1,13 @@
+import { AudioContext, HTMLAudioElement } from "./index.js";
+if (typeof globalThis.AudioContext === "undefined") {
+  globalThis.AudioContext = AudioContext;
+}
+if (typeof globalThis.webkitAudioContext === "undefined") {
+  globalThis.webkitAudioContext = AudioContext;
+}
+if (typeof globalThis.Audio === "undefined") {
+  globalThis.Audio = HTMLAudioElement;
+}
+if (typeof globalThis.HTMLAudioElement === "undefined") {
+  globalThis.HTMLAudioElement = HTMLAudioElement;
+}

package/lib/types/audio-buffer-source-node.d.ts

@@ -0,0 +1,18 @@
+import { AudioNode } from './audio-node.js';
+import { AudioParam } from './audio-param.js';
+import type { AudioBuffer } from './audio-buffer.js';
+export declare class AudioBufferSourceNode extends AudioNode {
+    buffer: AudioBuffer | null;
+    loop: boolean;
+    loopStart: number;
+    loopEnd: number;
+    readonly playbackRate: AudioParam;
+    onended: (() => void) | null;
+    private _player;
+    private _started;
+    constructor();
+    start(when?: number, offset?: number, duration?: number): void;
+    stop(_when?: number): void;
+    /** Walk the output chain to find a GainNode */
+    private _findGainNode;
+}

package/lib/types/audio-buffer.d.ts

@@ -0,0 +1,17 @@
+export interface AudioBufferOptions {
+    numberOfChannels: number;
+    length: number;
+    sampleRate: number;
+}
+export declare class AudioBuffer {
+    readonly sampleRate: number;
+    readonly length: number;
+    readonly duration: number;
+    readonly numberOfChannels: number;
+    /** @internal */
+    _channelData: Float32Array[];
+    constructor(options: AudioBufferOptions);
+    getChannelData(channel: number): Float32Array;
+    copyFromChannel(destination: Float32Array, channelNumber: number, bufferOffset?: number): void;
+    copyToChannel(source: Float32Array, channelNumber: number, bufferOffset?: number): void;
+}