@storyteller-platform/ghost-story 0.0.1

package/dist/vad/ActiveGate.d.cts

@@ -0,0 +1,53 @@
+import { Readable } from 'node:stream';
+
+interface VadOptions {
+    lowCutoff?: number;
+    highCutoff?: number;
+    positiveAdaptationRate?: number;
+    negativeAdaptationRate?: number;
+    peakLoudnessDecay?: number;
+    backwardExtensionDuration?: number;
+    relativeThreshold?: number;
+}
+declare const defaultVadOptions: Required<VadOptions>;
+interface VadSegment {
+    startTime: number;
+    endTime: number;
+    isActive: boolean;
+}
+type RawAudio = {
+    audioChannels: Float32Array[];
+    sampleRate: number;
+};
+declare function detectVoiceActivity(rawAudio: RawAudio, options?: VadOptions): VadSegment[];
+interface StreamOptions extends VadOptions {
+    sampleRate?: number;
+    channelCount?: number;
+}
+declare function vadFromFile(path: string, options?: StreamOptions): Promise<VadSegment[]>;
+declare function vadFromStream(stream: Readable, options?: StreamOptions): AsyncGenerator<VadSegment>;
+declare class StreamingVad {
+    readonly sampleRate: number;
+    readonly channelCount: number;
+    private readonly opts;
+    private readonly channelFilters;
+    private readonly loudness;
+    private readonly minLoudness;
+    private readonly maxLoudness;
+    private readonly frameDuration;
+    private readonly ticksPerSecond;
+    private readonly backwardFrameCount;
+    private frameBuffer;
+    private currentSampleIndex;
+    private emittedUpToTime;
+    private pendingSegment;
+    constructor(sampleRate: number, channelCount: number, options?: VadOptions);
+    process(sample: number, channel: number): void;
+    flush(final?: boolean): VadSegment[];
+    private computeActivity;
+    finalize(): VadSegment[];
+    getSegments(): VadSegment[];
+    reset(): void;
+}
+
+export { type RawAudio, type StreamOptions, StreamingVad, type VadOptions, type VadSegment, defaultVadOptions, detectVoiceActivity, vadFromFile, vadFromStream };

package/dist/vad/ActiveGate.d.ts

@@ -0,0 +1,53 @@
+import { Readable } from 'node:stream';
+
+interface VadOptions {
+    lowCutoff?: number;
+    highCutoff?: number;
+    positiveAdaptationRate?: number;
+    negativeAdaptationRate?: number;
+    peakLoudnessDecay?: number;
+    backwardExtensionDuration?: number;
+    relativeThreshold?: number;
+}
+declare const defaultVadOptions: Required<VadOptions>;
+interface VadSegment {
+    startTime: number;
+    endTime: number;
+    isActive: boolean;
+}
+type RawAudio = {
+    audioChannels: Float32Array[];
+    sampleRate: number;
+};
+declare function detectVoiceActivity(rawAudio: RawAudio, options?: VadOptions): VadSegment[];
+interface StreamOptions extends VadOptions {
+    sampleRate?: number;
+    channelCount?: number;
+}
+declare function vadFromFile(path: string, options?: StreamOptions): Promise<VadSegment[]>;
+declare function vadFromStream(stream: Readable, options?: StreamOptions): AsyncGenerator<VadSegment>;
+declare class StreamingVad {
+    readonly sampleRate: number;
+    readonly channelCount: number;
+    private readonly opts;
+    private readonly channelFilters;
+    private readonly loudness;
+    private readonly minLoudness;
+    private readonly maxLoudness;
+    private readonly frameDuration;
+    private readonly ticksPerSecond;
+    private readonly backwardFrameCount;
+    private frameBuffer;
+    private currentSampleIndex;
+    private emittedUpToTime;
+    private pendingSegment;
+    constructor(sampleRate: number, channelCount: number, options?: VadOptions);
+    process(sample: number, channel: number): void;
+    flush(final?: boolean): VadSegment[];
+    private computeActivity;
+    finalize(): VadSegment[];
+    getSegments(): VadSegment[];
+    reset(): void;
+}
+
+export { type RawAudio, type StreamOptions, StreamingVad, type VadOptions, type VadSegment, defaultVadOptions, detectVoiceActivity, vadFromFile, vadFromStream };

package/dist/vad/ActiveGate.js

@@ -0,0 +1,329 @@
+import { Converter } from "ffmpeg-stream";
+const defaultVadOptions = {
+  lowCutoff: 100,
+  highCutoff: 1e3,
+  positiveAdaptationRate: 400,
+  negativeAdaptationRate: 10,
+  peakLoudnessDecay: 4,
+  backwardExtensionDuration: 0.2,
+  relativeThreshold: -15
+};
+function detectVoiceActivity(rawAudio, options = {}) {
+  var _a;
+  const channelCount = rawAudio.audioChannels.length;
+  const firstChannel = rawAudio.audioChannels[0];
+  if (!firstChannel || channelCount === 0) return [];
+  const vad = new StreamingVad(rawAudio.sampleRate, channelCount, options);
+  for (let i = 0; i < firstChannel.length; i++) {
+    for (let ch = 0; ch < channelCount; ch++) {
+      const sample = ((_a = rawAudio.audioChannels[ch]) == null ? void 0 : _a[i]) ?? 0;
+      vad.process(sample, ch);
+    }
+  }
+  return vad.finalize();
+}
+const defaultStreamOptions = {
+  sampleRate: 16e3,
+  channelCount: 1
+};
+async function vadFromFile(path, options = {}) {
+  const converter = new Converter();
+  converter.createInputFromFile(path);
+  const outputStream = converter.createOutputStream({
+    f: "f32le",
+    ar: "16000",
+    ac: "1",
+    acodec: "pcm_f32le"
+  });
+  const segments = [];
+  const run = converter.run();
+  try {
+    for await (const seg of vadFromStream(outputStream, options)) {
+      segments.push(seg);
+    }
+  } catch (error) {
+    converter.kill();
+    throw error;
+  } finally {
+    await run;
+  }
+  return segments;
+}
+async function* vadFromStream(stream, options = {}) {
+  const sampleRate = options.sampleRate ?? defaultStreamOptions.sampleRate;
+  const channelCount = options.channelCount ?? defaultStreamOptions.channelCount;
+  const vad = new StreamingVad(sampleRate, channelCount, options);
+  let leftover = Buffer.alloc(0);
+  for await (const chunk of stream) {
+    const combined = Buffer.concat([leftover, chunk]);
+    const bytesPerSample = 4;
+    const bytesPerFrame = bytesPerSample * channelCount;
+    const completeFrames = Math.floor(combined.length / bytesPerFrame);
+    const usableBytes = completeFrames * bytesPerFrame;
+    for (let offset = 0; offset < usableBytes; offset += bytesPerFrame) {
+      for (let ch = 0; ch < channelCount; ch++) {
+        const sample = combined.readFloatLE(offset + ch * bytesPerSample);
+        vad.process(sample, ch);
+      }
+    }
+    leftover = combined.subarray(usableBytes);
+    for (const seg of vad.flush()) {
+      yield seg;
+    }
+  }
+  for (const seg of vad.flush(true)) {
+    yield seg;
+  }
+}
+class StreamingVad {
+  constructor(sampleRate, channelCount, options = {}) {
+    this.sampleRate = sampleRate;
+    this.channelCount = channelCount;
+    this.opts = { ...defaultVadOptions, ...options };
+    this.ticksPerSecond = sampleRate * channelCount;
+    this.backwardFrameCount = Math.ceil(
+      this.opts.backwardExtensionDuration / this.frameDuration
+    );
+    this.channelFilters = Array.from({ length: channelCount }, () => ({
+      highpass: createBiquadFilter("highpass", sampleRate, this.opts.lowCutoff),
+      lowpass: createBiquadFilter("lowpass", sampleRate, this.opts.highCutoff)
+    }));
+    const initialPower = dbToGain(-60) ** 2;
+    this.loudness = new SmoothEstimator(
+      this.opts.positiveAdaptationRate / this.ticksPerSecond,
+      this.opts.negativeAdaptationRate / this.ticksPerSecond,
+      initialPower
+    );
+    this.minLoudness = new DecayingPeak(
+      "min",
+      -60,
+      this.opts.peakLoudnessDecay / this.ticksPerSecond
+    );
+    this.maxLoudness = new DecayingPeak(
+      "max",
+      -60,
+      this.opts.peakLoudnessDecay / this.ticksPerSecond
+    );
+  }
+  opts;
+  channelFilters;
+  loudness;
+  minLoudness;
+  maxLoudness;
+  frameDuration = 0.01;
+  ticksPerSecond;
+  backwardFrameCount;
+  frameBuffer = [];
+  currentSampleIndex = 0;
+  emittedUpToTime = 0;
+  pendingSegment = null;
+  process(sample, channel) {
+    const filter = this.channelFilters[channel];
+    if (!filter) return;
+    sample = filter.highpass.process(sample);
+    sample = filter.lowpass.process(sample);
+    this.loudness.update(sample ** 2);
+    const currentDb = gainToDb(
+      Math.sqrt(Math.max(this.loudness.value, dbToGain(-60) ** 2))
+    );
+    this.minLoudness.update(currentDb);
+    if (currentDb >= -60) {
+      this.maxLoudness.update(currentDb);
+    }
+    const time = this.currentSampleIndex / this.sampleRate;
+    const lastFrame = this.frameBuffer[this.frameBuffer.length - 1];
+    if (!lastFrame || time > lastFrame.time + this.frameDuration) {
+      this.frameBuffer.push({
+        time,
+        loudness: currentDb,
+        maxLoudness: this.maxLoudness.value
+      });
+    }
+    if (channel === this.channelCount - 1) {
+      this.currentSampleIndex++;
+    }
+  }
+  // flush finalized segments, keeping buffer for backward extension
+  // call with final=true when done processing to get remaining segments
+  flush(final = false) {
+    var _a;
+    const segments = [];
+    const frameCount = this.frameBuffer.length;
+    if (frameCount === 0) return segments;
+    const finalizeCount = final ? frameCount : Math.max(0, frameCount - this.backwardFrameCount);
+    if (finalizeCount === 0) return segments;
+    const active = this.computeActivity(finalizeCount, final);
+    for (let i = 0; i < finalizeCount; i++) {
+      const frame = this.frameBuffer[i];
+      if (!frame) continue;
+      const isActive = active[i] ?? false;
+      const startTime = frame.time;
+      const endTime = startTime + this.frameDuration;
+      if (this.pendingSegment && this.pendingSegment.isActive === isActive) {
+        this.pendingSegment.endTime = endTime;
+      } else {
+        if (this.pendingSegment) {
+          segments.push(this.pendingSegment);
+        }
+        this.pendingSegment = { startTime, endTime, isActive };
+      }
+    }
+    if (final && this.pendingSegment) {
+      segments.push(this.pendingSegment);
+      this.pendingSegment = null;
+    }
+    this.frameBuffer.splice(0, finalizeCount);
+    this.emittedUpToTime = ((_a = segments[segments.length - 1]) == null ? void 0 : _a.endTime) ?? this.emittedUpToTime;
+    return segments;
+  }
+  computeActivity(count, includeBuffer) {
+    const active = new Array(count).fill(false);
+    const lookAheadEnd = includeBuffer ? this.frameBuffer.length : Math.min(count + this.backwardFrameCount, this.frameBuffer.length);
+    let extendTo = count;
+    for (let i = lookAheadEnd - 1; i >= 0; i--) {
+      const frame = this.frameBuffer[i];
+      if (!frame) continue;
+      const refLoudness = Math.max(frame.maxLoudness, -30);
+      const isLoud = frame.loudness >= refLoudness + this.opts.relativeThreshold;
+      if (isLoud) {
+        extendTo = Math.max(i - this.backwardFrameCount, 0);
+      }
+      if (i < count) {
+        if (i >= extendTo || isLoud) {
+          active[i] = true;
+        }
+      }
+    }
+    return active;
+  }
+  finalize() {
+    const segments = this.flush(true);
+    return segments;
+  }
+  getSegments() {
+    return this.flush(true);
+  }
+  // reset all state to process a new audio stream
+  reset() {
+    this.frameBuffer = [];
+    this.currentSampleIndex = 0;
+    this.emittedUpToTime = 0;
+    this.pendingSegment = null;
+    this.loudness.reset(dbToGain(-60) ** 2);
+    this.minLoudness.reset(-60);
+    this.maxLoudness.reset(-60);
+    for (const filter of this.channelFilters) {
+      filter.highpass.reset();
+      filter.lowpass.reset();
+    }
+  }
+}
+class SmoothEstimator {
+  constructor(upRate, downRate, initial) {
+    this.upRate = upRate;
+    this.downRate = downRate;
+    this.value = initial;
+  }
+  value;
+  update(target) {
+    const diff = target - this.value;
+    const rate = diff >= 0 ? this.upRate : this.downRate;
+    this.value += diff * rate;
+  }
+  reset(value) {
+    this.value = value;
+  }
+}
+class DecayingPeak {
+  constructor(kind, initial, decay) {
+    this.kind = kind;
+    this.decay = decay;
+    this.value = initial;
+  }
+  value;
+  update(v) {
+    if (this.kind === "max") {
+      this.value -= this.decay;
+      this.value = Math.max(v, this.value);
+    } else {
+      this.value += this.decay;
+      this.value = Math.min(v, this.value);
+    }
+  }
+  reset(value) {
+    this.value = value;
+  }
+}
+class BiquadFilter {
+  constructor(c) {
+    this.c = c;
+  }
+  x1 = 0;
+  x2 = 0;
+  y1 = 0;
+  y2 = 0;
+  process(x) {
+    const y = this.c.b0 * x + this.c.b1 * this.x1 + this.c.b2 * this.x2 - this.c.a1 * this.y1 - this.c.a2 * this.y2;
+    this.x2 = this.x1;
+    this.x1 = x;
+    this.y2 = this.y1;
+    this.y1 = y;
+    return y;
+  }
+  reset() {
+    this.x1 = 0;
+    this.x2 = 0;
+    this.y1 = 0;
+    this.y2 = 0;
+  }
+}
+function createBiquadFilter(type, sampleRate, freq, q = 0.7071) {
+  const nyquist = sampleRate / 2;
+  const w = Math.min(freq / nyquist, 1);
+  if (w === 1) {
+    return new BiquadFilter(
+      type === "lowpass" ? { b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 } : { b0: 0, b1: 0, b2: 0, a1: 0, a2: 0 }
+    );
+  }
+  if (w === 0 && type === "highpass") {
+    return new BiquadFilter({ b0: 1, b1: 0, b2: 0, a1: 0, a2: 0 });
+  }
+  const theta = Math.PI * w;
+  const alpha = Math.sin(theta) / (2 * Math.pow(10, q / 20));
+  const cosw = Math.cos(theta);
+  let b0, b1, b2;
+  if (type === "lowpass") {
+    const beta = (1 - cosw) / 2;
+    b0 = beta;
+    b1 = 2 * beta;
+    b2 = beta;
+  } else {
+    const beta = (1 + cosw) / 2;
+    b0 = beta;
+    b1 = -2 * beta;
+    b2 = beta;
+  }
+  const a0 = 1 + alpha;
+  const a1 = -2 * cosw;
+  const a2 = 1 - alpha;
+  return new BiquadFilter({
+    b0: b0 / a0,
+    b1: b1 / a0,
+    b2: b2 / a0,
+    a1: a1 / a0,
+    a2: a2 / a0
+  });
+}
+function gainToDb(gain) {
+  return gain <= 1e-5 ? -100 : 20 * Math.log10(gain);
+}
+function dbToGain(db) {
+  return db <= -100 ? 0 : Math.pow(10, db / 20);
+}
+export {
+  StreamingVad,
+  defaultVadOptions,
+  detectVoiceActivity,
+  vadFromFile,
+  vadFromStream
+};