@audio/mic 1.1.0

package/README.md

@@ -0,0 +1,120 @@
+# @audio/mic
+
+Capture audio from microphone in node or browser.
+
+## Usage
+
+```js
+import mic from '@audio/mic'
+
+let read = mic({
+  sampleRate: 44100,
+  channels: 1,
+  bitDepth: 16,
+  // bufferSize: 50,       // ring buffer ms (default 50)
+  // backend: 'miniaudio', // force backend
+})
+
+read((err, pcmBuffer) => {
+  // process chunk
+})
+read(null) // stop capture
+```
+
+### Async iterable
+
+```js
+import mic from '@audio/mic'
+
+let read = mic({ sampleRate: 44100, channels: 1 })
+for await (let chunk of read) {
+  // process PCM chunk
+}
+```
+
+### Node Readable
+
+```js
+import MicReadable from '@audio/mic/stream'
+
+MicReadable({ sampleRate: 44100, channels: 1 }).pipe(dest)
+```
+
+## Backends
+
+Tried in order; first successful one wins.
+
+| Backend | How | Latency | Install |
+|---|---|---|---|
+| `miniaudio` | N-API addon wrapping [miniaudio.h](https://github.com/mackron/miniaudio) | Low | Prebuilt via `@audio/mic-*` packages |
+| `process` | Pipes from ffmpeg/sox/arecord | High | System tool must be installed |
+| `null` | Silent, maintains timing contract | — | Built-in (CI/headless fallback) |
+| `mediastream` | getUserMedia + AudioWorklet (browser) | Low | Built-in |
+
+## API
+
+### `read = mic(opts?)`
+
+Returns a source function. Options:
+
+- `sampleRate` — default `44100`
+- `channels` — default `1`
+- `bitDepth` — `8`, `16` (default), `24`, `32`
+- `bufferSize` — ring buffer in ms, default `50`
+- `backend` — force a specific backend
+
+### `read(cb)`
+
+Read PCM data. Callback fires with each captured chunk: `(err, buffer) => {}`.
+
+### `read(null)`
+
+Stop capture. Closes the audio device.
+
+### `read.close()`
+
+Immediately close the audio device.
+
+### `read.backend`
+
+Name of the active backend (`'miniaudio'`, `'process'`, `'null'`, `'mediastream'`).
+
+## Building
+
+```sh
+npm run build          # compile native addon locally
+npm test               # run tests
+```
+
+## Publishing
+
+```sh
+# JS-only change (no native code changed):
+npm version patch && git push && git push --tags
+npm publish
+
+# Native code changed — rebuild platform packages:
+npm version patch && git push && git push --tags
+gh run watch                    # wait for CI
+rm -rf artifacts
+gh run download --dir artifacts \
+  -n mic-darwin-arm64 -n mic-darwin-x64 \
+  -n mic-linux-x64 -n mic-linux-arm64 -n mic-win32-x64
+
+# (fallback) If darwin-x64 CI is unavailable, cross-compile locally:
+npx node-gyp@latest rebuild --arch=x64
+mkdir -p artifacts/mic-darwin-x64
+cp build/Release/mic.node artifacts/mic-darwin-x64/
+
+for pkg in packages/mic-*/; do
+  cp artifacts/$(basename $pkg)/mic.node $pkg/
+  (cd $pkg && npm publish)
+done
+npm publish
+```
+
+## License
+
+MIT
+
+<a href="https://github.com/krishnized/license/">ॐ</a>

package/binding.gyp

@@ -0,0 +1,38 @@
+{
+  "targets": [{
+    "target_name": "mic",
+    "sources": ["native/mic.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,19 @@
+export interface BrowserMicOptions {
+  sampleRate?: number
+  channels?: number
+  bitDepth?: 8 | 16 | 32
+  context?: AudioContext
+  echoCancellation?: boolean
+  noiseSuppression?: boolean
+  autoGainControl?: boolean
+}
+
+export interface ReadFn {
+  (cb: (err: Error | null, chunk?: Uint8Array | null) => void): void
+  (cb: null): void
+  end(): void
+  close(): void
+  backend: 'mediastream'
+}
+
+export default function mic(opts?: BrowserMicOptions): Promise<ReadFn>

package/browser.js

@@ -0,0 +1,142 @@
+/**
+ * @module audio-mic/browser
+ *
+ * Browser audio capture via getUserMedia + AudioWorklet.
+ * Falls back to ScriptProcessorNode if AudioWorklet unavailable.
+ *
+ * Note: unlike node, browser mic() is async because getUserMedia requires permission.
+ */
+export default async function mic(opts = {}) {
+  const channels = opts.channels || 1
+  const sampleRate = opts.sampleRate || 44100
+  const bitDepth = opts.bitDepth || 16
+
+  const constraints = {
+    audio: {
+      sampleRate: { ideal: sampleRate },
+      channelCount: { ideal: channels },
+      echoCancellation: opts.echoCancellation ?? false,
+      noiseSuppression: opts.noiseSuppression ?? false,
+      autoGainControl: opts.autoGainControl ?? false,
+    }
+  }
+
+  const stream = await navigator.mediaDevices.getUserMedia(constraints)
+
+  const ownCtx = !opts.context
+  const ctx = opts.context || new AudioContext({ sampleRate })
+  const source = ctx.createMediaStreamSource(stream)
+
+  let closed = false
+  let pending = null
+
+  // try AudioWorklet, fall back to ScriptProcessor
+  let node
+  if (ctx.audioWorklet) {
+    const workletCode = `
+      class MicProcessor extends AudioWorkletProcessor {
+        process(inputs) {
+          const input = inputs[0]
+          if (input && input.length > 0) {
+            const channels = []
+            for (let i = 0; i < input.length; i++) channels.push(input[i].slice())
+            this.port.postMessage(channels)
+          }
+          return true
+        }
+      }
+      registerProcessor('mic-processor', MicProcessor)
+    `
+    const blob = new Blob([workletCode], { type: 'application/javascript' })
+    const url = URL.createObjectURL(blob)
+    await ctx.audioWorklet.addModule(url)
+    URL.revokeObjectURL(url)
+
+    node = new AudioWorkletNode(ctx, 'mic-processor', {
+      numberOfInputs: 1,
+      numberOfOutputs: 0,
+      channelCount: channels
+    })
+    source.connect(node)
+
+    node.port.onmessage = (e) => {
+      if (closed || !pending) return
+      const cb = pending
+      pending = null
+      cb(null, float32ToPCM(e.data, bitDepth))
+    }
+  } else {
+    // ScriptProcessorNode fallback (deprecated but wider support)
+    const bufSize = 2048
+    node = ctx.createScriptProcessor(bufSize, channels, 1)
+    source.connect(node)
+    node.connect(ctx.destination) // required for processing to run
+
+    node.onaudioprocess = (e) => {
+      if (closed || !pending) return
+      const cb = pending
+      pending = null
+      const chans = []
+      for (let i = 0; i < channels; i++) chans.push(e.inputBuffer.getChannelData(i).slice())
+      cb(null, float32ToPCM(chans, bitDepth))
+    }
+  }
+
+  read.close = close
+  read.end = close
+  read.backend = 'mediastream'
+  read[Symbol.asyncIterator] = () => ({
+    next: () => new Promise((resolve) => {
+      if (closed) return resolve({ done: true, value: undefined })
+      if (ctx.state === 'suspended') ctx.resume()
+      pending = (err, chunk) => {
+        if (err || !chunk) return resolve({ done: true, value: undefined })
+        resolve({ done: false, value: chunk })
+      }
+    })
+  })
+
+  return read
+
+  function read(cb) {
+    if (cb == null || closed) {
+      close()
+      return
+    }
+    // resume suspended context (autoplay policy)
+    if (ctx.state === 'suspended') ctx.resume()
+    pending = cb
+  }
+
+  function close() {
+    if (closed) return
+    closed = true
+    pending = null
+    source.disconnect()
+    stream.getTracks().forEach(t => t.stop())
+    if (ownCtx) ctx.close?.()
+  }
+
+  function float32ToPCM(channelData, bits) {
+    const ch = channelData.length
+    const len = channelData[0].length
+    const bps = bits / 8
+    const buf = new Uint8Array(len * ch * bps)
+    const view = new DataView(buf.buffer)
+
+    for (let i = 0; i < len; i++) {
+      for (let c = 0; c < ch; c++) {
+        const sample = channelData[c][i]
+        const offset = (i * ch + c) * bps
+        if (bits === 16) {
+          view.setInt16(offset, Math.max(-32768, Math.min(32767, Math.round(sample * 32767))), true)
+        } else if (bits === 32) {
+          view.setFloat32(offset, sample, true)
+        } else if (bits === 8) {
+          buf[offset] = Math.max(0, Math.min(255, Math.round((sample + 1) * 127.5)))
+        }
+      }
+    }
+    return buf
+  }
+}

package/index.d.ts

@@ -0,0 +1,18 @@
+export interface MicOptions {
+  sampleRate?: number
+  channels?: number
+  bitDepth?: 8 | 16 | 24 | 32
+  bufferSize?: number
+  backend?: 'miniaudio' | 'process' | 'null'
+}
+
+export interface ReadFn {
+  (cb: (err: Error | null, chunk?: Buffer | Uint8Array | null) => void): void
+  (cb: null): void
+  end(): void
+  close(): void
+  backend: string
+  [Symbol.asyncIterator](): AsyncIterator<Buffer | Uint8Array>
+}
+
+export default function mic(opts?: MicOptions): ReadFn

package/index.js

@@ -0,0 +1,44 @@
+/**
+ * @module audio-mic
+ *
+ * Capture audio data from microphone.
+ * let read = mic({ sampleRate: 44100 })
+ * read((err, chunk) => {})
+ * read(null) // stop
+ */
+import { open } from './src/backend.js'
+
+const defaults = {
+  sampleRate: 44100,
+  channels: 1,
+  bitDepth: 16,
+  bufferSize: 50
+}
+
+export default function mic(opts) {
+  const config = { ...defaults, ...opts }
+  const { name, device } = open(config, config.backend)
+
+  read.close = () => { device.close() }
+  read.end = () => { device.close() }
+  read.backend = name
+  read[Symbol.asyncIterator] = () => ({
+    next: () => new Promise((resolve, reject) => {
+      device.read((err, chunk) => {
+        if (err) return reject(err)
+        if (!chunk) return resolve({ done: true, value: undefined })
+        resolve({ done: false, value: chunk })
+      })
+    })
+  })
+
+  return read
+
+  function read(cb) {
+    if (cb == null) {
+      device.close()
+      return
+    }
+    device.read(cb)
+  }
+}