https://github.com/symbitic/node-mic

Cross-platform Node.js package for recording audio streams from a microphone.
https://github.com/symbitic/node-mic

Last synced: about 1 month ago
JSON representation

Cross-platform Node.js package for recording audio streams from a microphone.

• Host: GitHub
• URL: https://github.com/symbitic/node-mic
• Owner: Symbitic
• License: mit
• Created: 2021-11-11T22:50:59.000Z (about 3 years ago)
• Default Branch: main
• Last Pushed: 2021-11-11T23:10:34.000Z (about 3 years ago)
• Last Synced: 2024-11-18T11:45:29.480Z (about 1 month ago)
• Language: TypeScript
• Size: 13.7 KB
• Stars: 9
• Watchers: 3
• Forks: 4
• Open Issues: 1
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# node-mic

A cross-platform Node.js package for recording audio streams from a microphone.

## Installation

Node-mic uses [arecord](https://alsa-project.org/) on Linux and [sox](http://sox.sourceforge.net/) on Windows and macOS.

If sox is not already installed, node-mic will attempt to download the latest version.

On the new M1 Mac, that requires installing [brew.sh](https://brew.sh/) (Intel Macs should work fine without it).

On Linux, it will warn if arecord is not found and remind you to install it using your package manager.

On Debian-based distros, try running this:

    sudo apt-get update && sudo apt-get install alsa-utils

On RedHat-based distros, try running this:

    sudo dnf install alsa-utils

After that's done, you can try testing it to make sure your microphone is detected.

    arecord temp.wav

## Example

```js

import fs from 'fs';

import NodeMic from 'node-mic';

const mic = new NodeMic({

    rate: 16000,

    channels: 1,

    threshold: 6

});

const micInputStream = mic.getAudioStream();

const outputFileStream = fs.createWriteStream('output.raw');

micInputStream.pipe(outputFileStream);

micInputStream.on('data', (data) => {

    // Do something with the data.

});

micInputStream.on('error', (err) => {

    console.log(`Error: ${err.message}`);

});

micInputStream.on('started', () => {

    console.log('Started');

    setTimeout(() => {

        mic.pause();

    }, 5000);

});

micInputStream.on('stopped', () => {

    console.log('Stopped');

});

micInputStream.on('paused', () => {

    console.log('Paused');

    setTimeout(() => {

        mic.resume();

    }, 5000);

});

micInputStream.on('unpaused', () => {

    console.log('Unpaused');

    setTimeout(() => {

        mic.stop();

    }, 5000);

});

micInputStream.on('silence', () => {

    console.log('Silence');

});

micInputStream.on('exit', (code) => {

    console.log(`Exited with code: ${code}`);

});

mic.start();

```

The above example should save the output to a file named `output.raw`. Note that arecord pipes the 44 byte WAV header, whereas SOX does not. So we need to provide the file format details to the player:

    aplay -f S16_LE -r 16000 -c 1 output.raw # Linux

or

    play -b 16 -e signed -c 1 -r 16000 output.raw # Windows/Mac

## API

### Mic(options)

Creates a new microphone object. It inherits all the events from [stream.Transform](http://nodejs.org/api/stream.html#stream_class_stream_transform).

Accepts the following parameters (all optional):

* `options`

    * `endian`: Endian format. (default `little`)

    * `bitwidth`: Bit size. (default: `16`)

    * `encoding`: Signed or unsigned. (default: `signed-integer`)

    * `rate`: Bit rate. (default: `16000`)

    * `channels`: Number of channels. (default: `1`)

    * `device`: Which device to use. Linux only. (default: `plughw:0,0`)

    * `threshold`: The `'silence'` signal is raised after reaching these many consecutive frames. (default: `0`)

    * `fileType`: Recording format. `raw` or `wav`. (default: `raw`)

    * `debug`: If `true` then extra debug information is printed. (default: `false`)

### mic.start()

Starts the recording. Emits the `'started'` signal.

### mic.stop()

Stops the recording. Emits the `'stopped'` signal.

### mic.pause()

Pauses the recording. Emits the `'paused'` signal.

### mic.resume()

Resumes the recording. Emits the `'unpaused'` signal.

### mic.getAudioStream()

This returns a simple `Transform` stream that contains the data. The stream can be directly piped to a speaker or a file.

### mic.on('data')

This signal is emitted every time data is available. `data` is an audio waveform.

### mic.on('exit')

This signal is emitted when the recording process has finished.

### mic.on('error')

This signal is emitted whenever an error occurs.

## License

The MIT License (MIT). See [LICENSE](LICENSE) for more information.

Copyright (c) 2021 Alex Shaw 

Forked from [mic](https://github.com/ran-j/mic6).

Copyright (c) 2016 Ashish Bajaj