@pompeii-labs/audio 0.0.1

package/dist/index.mjs

@@ -0,0 +1,522 @@
+// src/decoders/wav.ts
+function decodeWAV(bytes) {
+  const view = new DataView(bytes.buffer);
+  if (String.fromCharCode(...bytes.slice(0, 4)) !== "RIFF" || String.fromCharCode(...bytes.slice(8, 12)) !== "WAVE") {
+    console.log("Invalid WAV header detected");
+    return null;
+  }
+  let offset = 12;
+  let audioFormat = 0;
+  let channels = 0;
+  let sampleRate = 0;
+  let bitsPerSample = 0;
+  let dataOffset = 0;
+  let dataSize = 0;
+  while (offset < bytes.length - 8) {
+    const chunkId = String.fromCharCode(...bytes.slice(offset, offset + 4));
+    const chunkSize = view.getUint32(offset + 4, true);
+    if (chunkId === "fmt ") {
+      audioFormat = view.getUint16(offset + 8, true);
+      channels = view.getUint16(offset + 10, true);
+      sampleRate = view.getUint32(offset + 12, true);
+      bitsPerSample = view.getUint16(offset + 22, true);
+    } else if (chunkId === "data") {
+      dataOffset = offset + 8;
+      const availableSize = bytes.length - dataOffset;
+      dataSize = Math.min(chunkSize, availableSize);
+      break;
+    }
+    offset += 8 + chunkSize;
+  }
+  if (audioFormat !== 1) {
+    throw new Error(`Unsupported WAV format: ${audioFormat}`);
+  }
+  const bytesPerSample = bitsPerSample / 8;
+  const numSamples = Math.floor(dataSize / bytesPerSample);
+  const samples = new Float32Array(numSamples);
+  for (let i = 0; i < numSamples; i++) {
+    const byteOffset = dataOffset + i * bytesPerSample;
+    if (byteOffset + bytesPerSample > bytes.length) {
+      console.error("Buffer overflow detected:", {
+        byteOffset,
+        bytesPerSample,
+        bufferLength: bytes.length,
+        sampleIndex: i
+      });
+      throw new Error("Buffer overflow while reading samples");
+    }
+    let sample = 0;
+    if (bitsPerSample === 8) {
+      sample = (bytes[byteOffset] - 128) / 128;
+    } else if (bitsPerSample === 16) {
+      const rawValue = view.getInt16(byteOffset, true);
+      sample = rawValue / 32768;
+    } else if (bitsPerSample === 24) {
+      const byte1 = bytes[byteOffset];
+      const byte2 = bytes[byteOffset + 1];
+      const byte3 = bytes[byteOffset + 2];
+      const value = byte3 << 16 | byte2 << 8 | byte1;
+      sample = (value > 8388607 ? value - 16777216 : value) / 8388608;
+    } else if (bitsPerSample === 32) {
+      sample = view.getFloat32(byteOffset, true);
+    }
+    samples[i] = Math.max(-1, Math.min(1, sample));
+  }
+  const result = {
+    sampleRate,
+    channels,
+    bitsPerSample,
+    samples,
+    duration: numSamples / (sampleRate * channels)
+    // Calculate duration in seconds
+  };
+  return result;
+}
+
+// src/decoders/mulaw.ts
+function mulawToPcm16(mulawData) {
+  const pcmData = new Int16Array(mulawData.length);
+  for (let i = 0; i < mulawData.length; i++) {
+    pcmData[i] = mulawToLinear(mulawData[i]);
+  }
+  return pcmData;
+}
+function mulawToLinear(mulawByte) {
+  const inverted = mulawByte ^ 255;
+  const sign = inverted & 128;
+  const segment = (inverted & 112) >> 4;
+  const step = inverted & 15;
+  let linear;
+  if (segment === 0) {
+    linear = (step << 1) + 1;
+  } else {
+    linear = (step << 1) + 1 + 32 << segment + 2;
+  }
+  linear -= 33;
+  return sign ? -linear : linear;
+}
+
+// src/encoders/mulaw.ts
+var BIAS = 132;
+var CLIP = 32635;
+var encodeTable = [
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  5,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  6,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7,
+  7
+];
+function encodeSample(sample) {
+  const sign = sample >> 8 & 128;
+  if (sign !== 0) sample = -sample;
+  sample = sample + BIAS;
+  if (sample > CLIP) sample = CLIP;
+  const exponent = encodeTable[sample >> 7 & 255];
+  const mantissa = sample >> exponent + 3 & 15;
+  return ~(sign | exponent << 4 | mantissa);
+}
+function pcm16ToMulaw(pcmData) {
+  const mulawData = new Uint8Array(pcmData.length);
+  for (let i = 0; i < pcmData.length; i++) {
+    mulawData[i] = encodeSample(pcmData[i]);
+  }
+  return mulawData;
+}
+
+// src/helpers/bufferToInt16Array.ts
+function bufferToInt16Array(buffer) {
+  return new Int16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 2);
+}
+
+// src/helpers/int16ArrayToBuffer.ts
+function int16ArrayToBuffer(int16Array) {
+  return Buffer.from(int16Array.buffer, int16Array.byteOffset, int16Array.byteLength);
+}
+
+// src/helpers/convertAudioFormat.ts
+function encodePcm(audio, encoding) {
+  switch (encoding) {
+    case "mulaw":
+      return Buffer.from(pcm16ToMulaw(audio));
+    case "pcm":
+      return int16ArrayToBuffer(audio);
+    default:
+      throw new Error(`Could not encode audio: Unsupported encoding: ${encoding}`);
+  }
+}
+function decodeToPcm(audio, encoding) {
+  switch (encoding) {
+    case "mulaw":
+      return mulawToPcm16(audio);
+    case "pcm":
+      return bufferToInt16Array(audio);
+    default:
+      throw new Error(`Could not decode audio: Unsupported encoding: ${encoding}`);
+  }
+}
+
+// src/helpers/detectFormat.ts
+function identifyAudioFormat(bytes) {
+  const checkBytes = (offset, expected) => {
+    if (offset + expected.length > bytes.length) return false;
+    return expected.every((byte, i) => bytes[offset + i] === byte);
+  };
+  if (checkBytes(0, [82, 73, 70, 70]) && // "RIFF"
+  checkBytes(8, [87, 65, 86, 69])) {
+    return {
+      format: "WAV",
+      mimeType: "audio/wav",
+      description: "Waveform Audio File Format"
+    };
+  }
+  if (checkBytes(0, [73, 68, 51]) || // ID3 tag
+  checkBytes(0, [255, 251]) || // MP3 frame sync
+  checkBytes(0, [255, 243]) || // MP3 frame sync
+  checkBytes(0, [255, 242])) {
+    return {
+      format: "MP3",
+      mimeType: "audio/mpeg",
+      description: "MPEG Audio Layer III"
+    };
+  }
+  if (checkBytes(0, [102, 76, 97, 67])) {
+    return {
+      format: "FLAC",
+      mimeType: "audio/flac",
+      description: "Free Lossless Audio Codec"
+    };
+  }
+  if (checkBytes(0, [79, 103, 103, 83])) {
+    return {
+      format: "OGG",
+      mimeType: "audio/ogg",
+      description: "Ogg Vorbis"
+    };
+  }
+  if (checkBytes(4, [102, 116, 121, 112]) && // "ftyp"
+  (checkBytes(8, [77, 52, 65, 32]) || // "M4A "
+  checkBytes(8, [105, 115, 111, 109]))) {
+    return {
+      format: "M4A",
+      mimeType: "audio/mp4",
+      description: "MPEG-4 Audio"
+    };
+  }
+  if (checkBytes(0, [70, 79, 82, 77]) && // "FORM"
+  checkBytes(8, [65, 73, 70, 70])) {
+    return {
+      format: "AIFF",
+      mimeType: "audio/aiff",
+      description: "Audio Interchange File Format"
+    };
+  }
+  if (checkBytes(
+    0,
+    [
+      48,
+      38,
+      178,
+      117,
+      142,
+      102,
+      207,
+      17,
+      166,
+      217,
+      0,
+      170,
+      0,
+      98,
+      206,
+      108
+    ]
+  )) {
+    return {
+      format: "WMA",
+      mimeType: "audio/x-ms-wma",
+      description: "Windows Media Audio"
+    };
+  }
+  return null;
+}
+
+// src/helpers/generateFadeOutSamples.ts
+function generateFadeOutSamples(lastSampleValue, fadeDurationMs, sampleRate) {
+  const fadeNumSamples = Math.ceil(fadeDurationMs / 1e3 * sampleRate);
+  const fadeSamples = new Int16Array(fadeNumSamples);
+  for (let i = 0; i < fadeNumSamples; i++) {
+    const progress = 1 - i / (fadeNumSamples - 1);
+    fadeSamples[i] = Math.round(lastSampleValue * progress);
+  }
+  return new Uint8Array(fadeSamples.buffer);
+}
+
+// src/helpers/resamplePcm.ts
+function resamplePcm(pcm, originalSampleRate, targetSampleRate) {
+  const ratio = originalSampleRate / targetSampleRate;
+  const newLength = Math.floor(pcm.length / ratio);
+  const newSamples = new Int16Array(newLength);
+  for (let i = 0; i < newSamples.length; i++) {
+    const exactPos = i * ratio;
+    const lowerIndex = Math.floor(exactPos);
+    const upperIndex = Math.min(lowerIndex + 1, pcm.length - 1);
+    const fraction = exactPos - lowerIndex;
+    const lowerSample = pcm[lowerIndex];
+    const upperSample = pcm[upperIndex];
+    newSamples[i] = Math.round(lowerSample + (upperSample - lowerSample) * fraction);
+  }
+  return newSamples;
+}
+
+export { bufferToInt16Array, decodeToPcm, decodeWAV, encodePcm, generateFadeOutSamples, identifyAudioFormat, int16ArrayToBuffer, mulawToPcm16, pcm16ToMulaw, resamplePcm };

package/dist/voice.d.mts

@@ -0,0 +1,146 @@
+import { A as AudioFormat } from './index-o4B-ThOL.mjs';
+import { DeepgramClient, LiveSchema } from '@deepgram/sdk';
+import { ElevenLabsClient } from '@elevenlabs/elevenlabs-js';
+import { StreamTextToSpeechRequest } from '@elevenlabs/elevenlabs-js/api/index.js';
+import { HumeClient } from 'hume';
+import OpenAI from 'openai';
+
+declare abstract class MagmaFlowSpeechToText {
+    abstract input(audio: Buffer): void;
+    abstract flush(): void;
+    abstract kill(): void;
+    onSpeechDetected(): void;
+    onOutput(text: string): void;
+    constructor();
+}
+
+declare abstract class MagmaFlowTextToSpeech {
+    abstract input(text: string): void;
+    abstract kill(): void;
+    onOutput(audio: Buffer | null): void;
+    constructor();
+}
+
+type MagmaFlowArgs = {
+    stt: MagmaFlowSpeechToText;
+    tts: MagmaFlowTextToSpeech;
+    inputFormat: AudioFormat;
+    outputFormat: AudioFormat;
+    onSpeechDetected: () => void;
+    onTextOutput: (text: string) => void;
+    onAudioOutput: (audio: Buffer) => void;
+};
+declare class MagmaFlow {
+    private stt;
+    private tts;
+    private inputFormat;
+    private outputFormat;
+    private onAudioOutput;
+    private textBuffer;
+    private textQueue;
+    private generatingAudio;
+    private audioBuffer;
+    constructor(args: MagmaFlowArgs);
+    inputAudio(audio: Buffer): void;
+    inputText(text: string): void;
+    private generateAudio;
+    private sendAudio;
+    kill(): void;
+}
+
+declare enum DeepgramModel {
+    NOVA_3 = "nova-3"
+}
+declare enum DeepgramLanguage {
+    EN_US = "en-US"
+}
+type DeepgramConfig = Omit<LiveSchema, 'model' | 'vad_events' | 'interim_results' | 'encoding' | 'sample_rate' | 'channels' | 'endpointing' | 'utterance_end_ms'>;
+type DeepgramSTTArgs = {
+    client?: DeepgramClient;
+    model: DeepgramModel;
+    config?: DeepgramConfig;
+};
+declare class DeepgramSTT extends MagmaFlowSpeechToText {
+    private client;
+    private connection;
+    private config;
+    private textBuffer;
+    constructor(args: DeepgramSTTArgs);
+    private setup;
+    input(audio: Buffer): void;
+    flush(): void;
+    kill(): void;
+    private handleTranscriptionEvent;
+    private onOpen;
+    private keepAlive;
+}
+
+type DeepgramTTSArgs = {
+    client?: DeepgramClient;
+};
+declare class DeepgramTTS extends MagmaFlowTextToSpeech {
+    private client;
+    constructor(args: DeepgramTTSArgs);
+    setup(): Promise<void>;
+    input(text: string | null): void;
+    private output;
+    kill(): void;
+    reset(): void;
+}
+
+declare enum ElevenVoice {
+    chris = "iP95p4xoKVk53GoZ742B",
+    josh = "TxGEqnHWrfWFTfGW9XjX",
+    rachel = "21m00Tcm4TlvDq8ikWAM",
+    laura = "FGY2WhTYpPnrIDTdsKH5",
+    felicity = "aTbnroHRGIomiKpqAQR8"
+}
+type ElevenLabsConfig = Omit<StreamTextToSpeechRequest, 'outputFormat' | 'text' | 'modelId'>;
+type ElevenLabsTTSArgs = {
+    client?: ElevenLabsClient;
+    model: string;
+    voice: ElevenVoice;
+    config?: ElevenLabsConfig;
+};
+declare class ElevenLabsTTS extends MagmaFlowTextToSpeech {
+    private client;
+    private model;
+    private voice;
+    private config;
+    constructor(args: ElevenLabsTTSArgs);
+    setup(): Promise<void>;
+    input(text: string | null): void;
+    private output;
+    kill(): void;
+    reset(): void;
+}
+
+type HumeTTSArgs = {
+    client?: HumeClient;
+};
+declare class HumeTTS extends MagmaFlowTextToSpeech {
+    private client;
+    constructor(args: HumeTTSArgs);
+    setup(): Promise<void>;
+    input(text: string | null): void;
+    private output;
+    kill(): void;
+    reset(): void;
+}
+
+type WhisperTTSArgs = {
+    client?: OpenAI;
+};
+declare class WhisperTTS extends MagmaFlowTextToSpeech {
+    private client;
+    constructor(args: WhisperTTSArgs);
+    setup(): Promise<void>;
+    input(text: string | null): void;
+    private output;
+    kill(): void;
+    reset(): void;
+}
+
+declare function splitTextIntoChunks(text: string, targetLength?: number): string[];
+
+export { DeepgramLanguage, DeepgramModel, DeepgramSTT, type DeepgramSTTArgs, DeepgramTTS, type DeepgramTTSArgs, ElevenLabsTTS, type ElevenLabsTTSArgs, ElevenVoice, HumeTTS, type HumeTTSArgs, MagmaFlow, type MagmaFlowArgs, MagmaFlowSpeechToText, MagmaFlowTextToSpeech, WhisperTTS, type WhisperTTSArgs, splitTextIntoChunks };