audio-mic 1.0.0

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "audio-mic",
+  "version": "1.0.0",
+  "description": "Capture audio from microphone in browser/node",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "browser": "./browser.js",
+      "default": "./index.js"
+    },
+    "./stream": {
+      "types": "./stream.d.ts",
+      "browser": "./browser.js",
+      "default": "./stream.js"
+    }
+  },
+  "browser": {
+    "./index.js": "./browser.js"
+  },
+  "scripts": {
+    "build": "node-gyp rebuild",
+    "build:x64": "npx node-gyp@latest rebuild --arch=x64 && mkdir -p packages/mic-darwin-x64 && cp build/Release/mic.node packages/mic-darwin-x64/",
+    "test": "node test.js",
+    "version": "node -e \"const v=require('./package.json').version,fs=require('fs');for(const d of fs.readdirSync('packages')){const f='packages/'+d+'/package.json',p=JSON.parse(fs.readFileSync(f));p.version=v;fs.writeFileSync(f,JSON.stringify(p,null,2)+'\\n')}\" && git add packages/*/package.json"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "browser.js",
+    "browser.d.ts",
+    "stream.js",
+    "stream.d.ts",
+    "src/",
+    "native/",
+    "binding.gyp",
+    "prebuilds/"
+  ],
+  "gypfile": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/audiojs/audio-mic"
+  },
+  "keywords": [
+    "audio",
+    "audiojs",
+    "pcm",
+    "microphone",
+    "mic",
+    "capture",
+    "record",
+    "input",
+    "web-audio",
+    "miniaudio"
+  ],
+  "author": "Dmitry Iv. <dfcreative@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/audiojs/audio-mic/issues"
+  },
+  "homepage": "https://github.com/audiojs/audio-mic",
+  "engines": {
+    "node": ">=18"
+  },
+  "optionalDependencies": {
+    "@audio/mic-darwin-x64": ">=0.0.0",
+    "@audio/mic-darwin-arm64": ">=0.0.0",
+    "@audio/mic-linux-x64": ">=0.0.0",
+    "@audio/mic-linux-arm64": ">=0.0.0",
+    "@audio/mic-win32-x64": ">=0.0.0"
+  },
+  "devDependencies": {
+    "prebuildify": "^6.0.1",
+    "tst": "^9.4.0"
+  }
+}

package/src/backend.js

@@ -0,0 +1,31 @@
+/**
+ * Backend detection — static imports, tries in priority order
+ */
+let miniaudio, process_, null_
+
+try { miniaudio = await import('./backends/miniaudio.js') } catch {}
+try { process_ = await import('./backends/process.js') } catch {}
+try { null_ = await import('./backends/null.js') } catch {}
+
+const backends = [
+  miniaudio && { name: 'miniaudio', open: miniaudio.open },
+  process_ && { name: 'process', open: process_.open },
+  null_ && { name: 'null', open: null_.open },
+].filter(Boolean)
+
+export function open(opts, preference) {
+  const order = preference
+    ? backends.filter(b => b.name === preference)
+    : backends
+  let lastErr
+
+  for (const { name, open } of order) {
+    try { return { name, device: open(opts) } }
+    catch (e) { lastErr = e }
+  }
+
+  throw new Error(
+    'No audio backend available. Install @audio/mic-* for your platform or run npm run build.' +
+    (lastErr ? ` Last error: ${lastErr.message}` : '')
+  )
+}

package/src/backends/miniaudio.js

@@ -0,0 +1,54 @@
+/**
+ * Miniaudio backend — N-API addon wrapping miniaudio.h capture
+ *
+ * Read strategy:
+ * - readAsync: blocks on worker thread until capture data available
+ * - Callback fires with each captured chunk — true push from hardware
+ *
+ * Load order:
+ * 1. @audio/mic-{platform}-{arch} (platform package)
+ * 2. packages/mic-{platform}-{arch}/
+ * 3. prebuilds/{platform}-{arch}/
+ * 4. build/Release/ or build/Debug/ (local node-gyp)
+ */
+import { createRequire } from 'node:module'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { arch, platform } from 'node:os'
+
+const require = createRequire(import.meta.url)
+const root = join(dirname(fileURLToPath(import.meta.url)), '../..')
+const plat = `${platform()}-${arch()}`
+
+let addon
+const loaders = [
+  () => require(`@audio/mic-${plat}`),
+  () => require(join(root, 'packages', `mic-${plat}`, 'mic.node')),
+  () => require(join(root, 'prebuilds', plat, 'audio-mic.node')),
+  () => require(join(root, 'prebuilds', plat, 'mic.node')),
+  () => require(join(root, 'build', 'Release', 'mic.node')),
+  () => require(join(root, 'build', 'Debug', 'mic.node')),
+]
+for (const load of loaders) {
+  try { addon = load(); break } catch {}
+}
+if (!addon) throw new Error('miniaudio addon not found — install @audio/mic-' + plat + ' or run npm run build')
+
+export function open({ sampleRate = 44100, channels = 1, bitDepth = 16, bufferSize = 50 } = {}) {
+  const handle = addon.open(sampleRate, channels, bitDepth, bufferSize)
+  const bpf = channels * (bitDepth / 8)
+
+  return {
+    read(cb) {
+      const buf = Buffer.alloc(Math.round(sampleRate * bufferSize / 1000) * bpf)
+      addon.readAsync(handle, buf, (err, frames) => {
+        if (frames > 0) cb?.(err, buf.subarray(0, frames * bpf))
+        else cb?.(err, null)
+      })
+    },
+
+    close() {
+      addon.close(handle)
+    }
+  }
+}

package/src/backends/null.js

@@ -0,0 +1,22 @@
+/**
+ * Null backend — silent fallback for headless/CI environments.
+ * Maintains timing contract: callback fires after audio duration,
+ * delivering silence buffers at real-time rate.
+ */
+export function open({ sampleRate = 44100, channels = 1, bitDepth = 16, bufferSize = 50 } = {}) {
+  const bpf = channels * (bitDepth / 8)
+  const chunkFrames = Math.round(sampleRate * bufferSize / 1000)
+  const chunkBytes = chunkFrames * bpf
+  let closed = false
+
+  return {
+    read(cb) {
+      if (closed) return cb?.(null, null)
+      setTimeout(() => {
+        if (closed) return cb?.(null, null)
+        cb?.(null, Buffer.alloc(chunkBytes))
+      }, bufferSize)
+    },
+    close() { closed = true }
+  }
+}

package/src/backends/process.js

@@ -0,0 +1,68 @@
+/**
+ * Process backend — capture PCM from system audio tools (last resort)
+ */
+import { spawn, execSync } from 'node:child_process'
+import { platform } from 'node:os'
+
+function tryExec(cmd) {
+  try { execSync(cmd, { stdio: 'ignore' }); return true } catch { return false }
+}
+
+function findRecorder(sampleRate, channels, bitDepth) {
+  const os = platform()
+  const fmt = bitDepth === 8 ? 'u8' : bitDepth === 32 ? 'f32le' : `s${bitDepth}le`
+
+  if (os === 'darwin' && tryExec('ffmpeg -version'))
+    return ['ffmpeg', ['-f', 'avfoundation', '-i', ':default', '-f', fmt, '-ar', sampleRate, '-ac', channels, '-']]
+
+  if (os === 'linux' && tryExec('ffmpeg -version'))
+    return ['ffmpeg', ['-f', 'pulse', '-i', 'default', '-f', fmt, '-ar', sampleRate, '-ac', channels, '-']]
+
+  if (tryExec('sox --version'))
+    return ['sox', ['-d', '-t', 'raw', '-r', sampleRate, '-c', channels, '-b', bitDepth, '-e', 'signed-integer', '-L', '-']]
+
+  if (os === 'linux' && tryExec('arecord --version')) {
+    const afmt = bitDepth === 8 ? 'U8' : bitDepth === 32 ? 'FLOAT_LE' : `S${bitDepth}_LE`
+    return ['arecord', ['-f', afmt, '-r', sampleRate, '-c', channels, '-t', 'raw']]
+  }
+
+  return null
+}
+
+export function open({ sampleRate = 44100, channels = 1, bitDepth = 16 } = {}) {
+  const recorder = findRecorder(sampleRate, channels, bitDepth)
+  if (!recorder) throw new Error('No audio recorder found (install ffmpeg or sox)')
+
+  const [cmd, args] = recorder
+  const proc = spawn(cmd, args.map(String), { stdio: ['ignore', 'pipe', 'ignore'] })
+
+  let closed = false
+  let pending = null
+
+  proc.on('close', () => { closed = true })
+
+  proc.stdout.on('data', (chunk) => {
+    if (pending) {
+      const cb = pending
+      pending = null
+      cb(null, chunk)
+    }
+  })
+
+  proc.stdout.on('error', () => {})
+
+  return {
+    read(cb) {
+      if (closed) return cb?.(new Error('Process exited'), null)
+      pending = cb
+    },
+
+    close() {
+      if (closed) return
+      closed = true
+      pending = null
+      proc.stdout.destroy()
+      proc.kill()
+    }
+  }
+}

package/stream.d.ts

@@ -0,0 +1,4 @@
+import { Readable } from 'node:stream'
+import { MicOptions } from './index.js'
+
+export default function readable(opts?: MicOptions): Readable

package/stream.js

@@ -0,0 +1,28 @@
+/**
+ * @module audio-mic/stream
+ *
+ * Node.js Readable stream for audio capture.
+ */
+import { Readable } from 'node:stream'
+import mic from './index.js'
+
+export default function readable(opts) {
+  const { sampleRate = 44100, channels = 1, bitDepth = 16, bufferSize = 50 } = opts || {}
+  const read = mic(opts)
+
+  return new Readable({
+    highWaterMark: Math.round(sampleRate * channels * (bitDepth / 8) * bufferSize / 1000),
+    read() { pull(this) },
+    destroy(err, cb) { read.close(); cb(err) }
+  })
+
+  function pull(stream) {
+    if (stream.destroyed) return
+    read((err, chunk) => {
+      if (stream.destroyed) return
+      if (err) return stream.destroy(err)
+      if (!chunk) return stream.push(null)
+      if (stream.push(chunk)) pull(stream)
+    })
+  }
+}