naudiodon

To play audio, create an instance of AudioIO providing an outOptions object. This instance acts as a Node.js Writable Stream.

Configuration options for outOptions:

• channelCount: Number of audio channels.
• sampleFormat: The bit depth (e.g., portAudio.SampleFormat16Bit).
• sampleRate: The sample rate (e.g., 48000).
• deviceId: The device ID to use. Use -1 or omit to use the default device.
• closeOnError: If true, the stream closes when an audio error is detected; if false, it just logs the error.

const fs = require('fs');
const portAudio = require('naudiodon');

// Create an instance of AudioIO with outOptions, which returns a WritableStream
var ao = new portAudio.AudioIO({
  outOptions: {
    channelCount: 2,
    sampleFormat: portAudio.SampleFormat16Bit,
    sampleRate: 48000,
    deviceId: -1, // Use -1 or omit the deviceId to select the default device
    closeOnError: true
  }
});

// Create a stream to pipe into the AudioOutput
var rs = fs.createReadStream('steam_48000.wav');

// Start piping data and start streaming
rs.pipe(ao);
ao.start();

To record audio, create an instance of AudioIO providing an inOptions object. This instance acts as a Node.js Readable Stream.

Configuration options for inOptions:

• channelCount: Number of audio channels.
• sampleFormat: The bit depth (e.g., portAudio.SampleFormat16Bit).
• sampleRate: The sample rate.
• deviceId: The device ID to use. Use -1 or omit to use the default device.
• closeOnError: If true, the stream closes when an audio error is detected; if false, it just logs the error.

Important Notes:

• Recording produces raw audio data. You must manually add headers (like WAV) if you want to create standard audio files.
• Each buffer emitted by the stream contains a timestamp property representing the time value for the first sample in that buffer.
• Call ai.quit() to stop the recording gracefully.

var fs = require('fs');
var portAudio = require('naudiodon');

// Create an instance of AudioIO with inOptions, which returns a ReadableStream
var ai = new portAudio.AudioIO({
  inOptions: {
    channelCount: 2,
    sampleFormat: portAudio.SampleFormat16Bit,
    sampleRate: 44100,
    deviceId: -1,
    closeOnError: true
  }
});

// Create a write stream to write out to a raw audio file
var ws = fs.createWriteStream('rawAudio.raw');

// Accessing the timestamp on data buffers
ai.on('data', buf => console.log(buf.timestamp));

// Start streaming
ai.pipe(ws);
ai.start();

// Stopping the recording
process.on('SIGINT', () => {
  console.log('Received SIGINT. Stopping recording.');
  ai.quit();
});

When using naudiodon, audio behavior is controlled by an options object. The underlying C++ implementation uses the following keys to configure audio streams. If a key is omitted, the specified default value is used.

The AudioIO function is the primary way to interact with audio hardware. It returns a Node.js stream (Readable, Writable, or Duplex) depending on the options provided.

Stream Types

• Duplex Stream: Created if both inOptions and outOptions are provided. Used for bi-directional audio.
• Readable Stream: Created if only inOptions is provided. Used for recording audio.
• Writable Stream: Created if only outOptions is provided. Used for playing audio.

Stream Control Methods

• ioStream.start(): Starts the audio I/O.
• ioStream.quit(callback): Gracefully stops the audio I/O using the 'WAIT' flag. If a callback is provided, it is executed after quitting.
• ioStream.abort(callback): Immediately stops the audio I/O using the 'ABORT' flag. If a callback is provided, it is executed after aborting.

Configuration Options

Both inOptions and outOptions can include a highwaterMark property to control the internal buffer size (defaults to 16384).

const { AudioIO, SampleFormatFloat32 } = require('naudiodon');

// Example: Creating a Duplex stream for bi-directional audio
const io = AudioIO({
  inOptions: {
    device: 1, // device index
    format: SampleFormatFloat32,
    channels: 2,
    sampleRate: 44100,
    highwaterMark: 16384
  },
  outOptions: {
    device: 1,
    format: SampleFormatFloat32,
    channels: 2,
    sampleRate: 44100,
    highwaterMark: 16384
  }
});

io.start();

// Handle stream lifecycle
io.on('finish', () => console.log('Stream finished'));
io.on('error', (err) => console.error('AudioIO Error:', err));

// To stop gracefully:
// await io.quit();