@audio/speaker 2.3.1

package/binding.gyp

@@ -0,0 +1,38 @@
+{
+  "targets": [{
+    "target_name": "speaker",
+    "sources": ["native/speaker.c"],
+    "include_dirs": ["native"],
+    "cflags": ["-std=c99", "-O2"],
+    "xcode_settings": {
+      "OTHER_CFLAGS": ["-std=c99", "-O2"],
+      "MACOSX_DEPLOYMENT_TARGET": "10.13"
+    },
+    "msvs_settings": {
+      "VCCLCompilerTool": {
+        "AdditionalOptions": ["/O2"]
+      }
+    },
+    "conditions": [
+      ["OS=='mac'", {
+        "libraries": [
+          "-framework CoreAudio",
+          "-framework AudioToolbox",
+          "-framework CoreFoundation"
+        ]
+      }],
+      ["OS=='linux'", {
+        "libraries": [
+          "-lpthread",
+          "-lm",
+          "-ldl"
+        ]
+      }],
+      ["OS=='win'", {
+        "libraries": [
+          "ole32.lib"
+        ]
+      }]
+    ]
+  }]
+}

package/browser.d.ts

@@ -0,0 +1,16 @@
+export interface BrowserSpeakerOptions {
+  sampleRate?: number
+  channels?: number
+  bitDepth?: 8 | 16 | 32
+  context?: AudioContext
+}
+
+export interface WriteFn {
+  (chunk: Uint8Array | null, cb?: (err: Error | null, frames?: number) => void): void
+  end(): void
+  flush(cb?: () => void): void
+  close(): void
+  backend: 'webaudio'
+}
+
+export default function Speaker(opts?: BrowserSpeakerOptions): WriteFn

package/browser.js

@@ -0,0 +1,84 @@
+/**
+ * @module audio-speaker/browser
+ *
+ * Browser audio output via Web Audio API.
+ */
+export default function Speaker(opts = {}) {
+  const ownCtx = !opts.context
+  const ctx = opts.context || new AudioContext({
+    sampleRate: opts.sampleRate || 44100
+  })
+  const channels = opts.channels || 2
+  const sampleRate = ctx.sampleRate
+  const bitDepth = opts.bitDepth || 16
+
+  let closed = false
+
+  write.end = () => close()
+  write.flush = (cb) => cb?.()
+  write.close = close
+  write.backend = 'webaudio'
+
+  return write
+
+  function write(chunk, cb) {
+    if (chunk == null || closed) {
+      cb?.(null)
+      return
+    }
+
+    // resume suspended context (autoplay policy)
+    const ready = ctx.state === 'suspended' ? ctx.resume() : Promise.resolve()
+    ready.then(() => playChunk(chunk, cb), cb)
+  }
+
+  function playChunk(chunk, cb) {
+    const bytesPerSample = bitDepth / 8
+    const frameCount = (chunk.length / bytesPerSample / channels) | 0
+    const audioBuffer = ctx.createBuffer(channels, frameCount, sampleRate)
+
+    for (let ch = 0; ch < channels; ch++) {
+      const out = audioBuffer.getChannelData(ch)
+      if (bitDepth === 16) {
+        for (let i = 0; i < frameCount; i++) {
+          const idx = (i * channels + ch) * 2
+          out[i] = ((chunk[idx] | (chunk[idx + 1] << 8)) << 16 >> 16) / 32768
+        }
+      } else if (bitDepth === 32) {
+        const f32 = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+        for (let i = 0; i < frameCount; i++) {
+          out[i] = f32.getFloat32((i * channels + ch) * 4, true)
+        }
+      }
+    }
+
+    const source = ctx.createBufferSource()
+    source.buffer = audioBuffer
+    source.connect(ctx.destination)
+    source.onended = () => cb?.(null, frameCount)
+    source.start()
+  }
+
+  function close() {
+    if (closed) return
+    closed = true
+    if (ownCtx) ctx.close?.()
+  }
+}
+
+/**
+ * Consume an async iterable of PCM chunks through the speaker.
+ * @param {AsyncIterable} source - async iterable yielding PCM buffers
+ * @param {object} opts - speaker options (sampleRate, channels, bitDepth, etc.)
+ * @returns {Promise<void>} resolves when source is exhausted
+ */
+Speaker.from = async function(source, opts) {
+  const write = Speaker(opts)
+  try {
+    for await (let chunk of source) {
+      await new Promise((resolve, reject) => write(chunk, err => err ? reject(err) : resolve()))
+    }
+  } finally {
+    write(null)
+  }
+}

package/index.d.ts

@@ -0,0 +1,22 @@
+export interface SpeakerOptions {
+  sampleRate?: number
+  channels?: number
+  bitDepth?: 8 | 16 | 24 | 32
+  bufferSize?: number
+  backend?: 'miniaudio' | 'process' | 'null'
+}
+
+export interface WriteFn {
+  (chunk: Buffer | Uint8Array | AudioBuffer | null, cb?: (err: Error | null, frames?: number) => void): void
+  end(): void
+  flush(cb?: () => void): void
+  close(): void
+  backend: string
+}
+
+export default function speaker(opts?: SpeakerOptions): WriteFn
+
+declare namespace speaker {
+  /** Consume an async iterable of PCM chunks through the speaker. */
+  function from(source: AsyncIterable<Buffer | Uint8Array | AudioBuffer>, opts?: SpeakerOptions): Promise<void>
+}

package/index.js

@@ -0,0 +1,82 @@
+/**
+ * @module audio-speaker
+ *
+ * Output audio data to speaker.
+ * let write = speaker({ sampleRate: 44100 })
+ * write(pcmBuffer, cb)
+ * write(null) // end
+ */
+import { open } from './src/backend.js'
+
+const defaults = {
+  sampleRate: 44100,
+  channels: 2,
+  bitDepth: 16,
+  bufferSize: 50
+}
+
+// detect AudioBuffer (has getChannelData + numberOfChannels + sampleRate)
+function isAudioBuffer(buf) {
+  return buf && typeof buf.getChannelData === 'function' && buf.numberOfChannels > 0
+}
+
+// convert AudioBuffer → interleaved int16 PCM Buffer
+function audioBufferToPCM(ab, bitDepth) {
+  const ch = ab.numberOfChannels
+  const len = ab.length
+  const bps = bitDepth / 8
+  const buf = Buffer.alloc(len * ch * bps)
+
+  for (let i = 0; i < len; i++) {
+    for (let c = 0; c < ch; c++) {
+      const sample = ab.getChannelData(c)[i]
+      const offset = (i * ch + c) * bps
+      if (bitDepth === 16) {
+        buf.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(sample * 32767))), offset)
+      } else if (bitDepth === 32) {
+        buf.writeFloatLE(sample, offset)
+      } else if (bitDepth === 8) {
+        buf[offset] = Math.max(0, Math.min(255, Math.round((sample + 1) * 127.5)))
+      }
+    }
+  }
+  return buf
+}
+
+export default function speaker(opts) {
+  const config = { ...defaults, ...opts }
+  const { name, device } = open(config, config.backend)
+
+  write.end = () => { device.close() }
+  write.flush = (cb) => { device.flush(cb) }
+  write.close = () => { device.close() }
+  write.backend = name
+
+  return write
+
+  function write(chunk, cb) {
+    if (chunk == null) {
+      device.flush(() => { device.close(); cb?.(null) })
+      return
+    }
+    const buf = isAudioBuffer(chunk) ? audioBufferToPCM(chunk, config.bitDepth) : chunk
+    device.write(buf, cb)
+  }
+}
+
+/**
+ * Consume an async iterable of PCM chunks through the speaker.
+ * @param {AsyncIterable} source - async iterable yielding PCM buffers
+ * @param {object} opts - speaker options (sampleRate, channels, bitDepth, etc.)
+ * @returns {Promise<void>} resolves when source is exhausted
+ */
+speaker.from = async function(source, opts) {
+  const write = speaker(opts)
+  try {
+    for await (let chunk of source) {
+      await new Promise((resolve, reject) => write(chunk, err => err ? reject(err) : resolve()))
+    }
+  } finally {
+    await new Promise(r => write(null, r))
+  }
+}