rockcord 4.0.0-dev.4

package/src/client/voice/util/Function.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const dgram = require('dgram');
+const { setImmediate } = require('node:timers');
+
+/**
+ * @typedef {Object} InterfaceAddresses
+ * @property {string} [udp4] - IPv4 address
+ * @property {string} [udp6] - IPv6 address
+ */
+
+/**
+ * Get the interface address for a given socket type.
+ * @param {"udp4"|"udp6"} type - The socket type.
+ * @param {InterfaceAddresses} [interfaceAddresses] - The interface addresses mapping.
+ * @returns {string|undefined} The interface address if available.
+ */
+function interfaceAddress(type, interfaceAddresses) {
+  return interfaceAddresses ? interfaceAddresses[type] : undefined;
+}
+
+/**
+ * Get a random available port.
+ * @param {"udp4"|"udp6"} [protocol="udp4"] - The socket type.
+ * @param {InterfaceAddresses} [interfaceAddresses] - The interface addresses mapping.
+ * @returns {Promise<number>} The assigned random port.
+ */
+async function randomPort(protocol = 'udp4', interfaceAddresses) {
+  const socket = dgram.createSocket(protocol);
+
+  setImmediate(() =>
+    socket.bind({
+      port: 0,
+      address: interfaceAddress(protocol, interfaceAddresses),
+    }),
+  );
+
+  await new Promise((resolve, reject) => {
+    socket.once('error', reject);
+    socket.once('listening', resolve);
+  });
+
+  const port = socket.address()?.port;
+  await new Promise(resolve => socket.close(resolve));
+  return port;
+}
+
+/**
+ * Get multiple random available ports.
+ * @param {number} num - Number of ports to find.
+ * @param {"udp4"|"udp6"} [protocol="udp4"] - The socket type.
+ * @param {InterfaceAddresses} [interfaceAddresses] - The interface addresses mapping.
+ * @returns {Promise<number[]>} An array of assigned random ports.
+ */
+async function randomPorts(num, protocol = 'udp4', interfaceAddresses) {
+  return Promise.all(Array.from({ length: num }).map(() => randomPort(protocol, interfaceAddresses)));
+}
+
+/**
+ * Find an available port within a given range.
+ * @param {number} min - The minimum port number.
+ * @param {number} max - The maximum port number.
+ * @param {"udp4"|"udp6"} [protocol="udp4"] - The socket type.
+ * @param {InterfaceAddresses} [interfaceAddresses] - The interface addresses mapping.
+ * @returns {Promise<number>} The available port within range.
+ * @throws {Error} If no port is found within the range.
+ */
+async function findPort(min, max, protocol = 'udp4', interfaceAddresses) {
+  let port;
+
+  for (let i = min; i <= max; i++) {
+    const socket = dgram.createSocket(protocol);
+
+    setImmediate(() =>
+      socket.bind({
+        port: i,
+        address: interfaceAddress(protocol, interfaceAddresses),
+      }),
+    );
+
+    const error = await new Promise(resolve => {
+      socket.once('error', resolve);
+      socket.once('listening', () => resolve(null));
+    });
+
+    if (error) {
+      try {
+        socket.close();
+      } catch {
+        /* A failed bind may have already closed the socket. */
+      }
+      continue;
+    }
+
+    const addressInfo = socket.address();
+    await new Promise(resolve => socket.close(resolve));
+    if (addressInfo && addressInfo.port >= min && addressInfo.port <= max) {
+      port = addressInfo.port;
+      break;
+    }
+  }
+
+  if (!port) throw new Error('port not found');
+  return port;
+}
+
+function parseStreamKey(key) {
+  const Arr = key.split(':');
+  const type = Arr[0];
+  const guildId = type == 'guild' ? Arr[1] : null;
+  const channelId = type == 'guild' ? Arr[2] : Arr[1];
+  const userId = type == 'guild' ? Arr[3] : Arr[2];
+  return { type, guildId, channelId, userId };
+}
+
+module.exports = {
+  randomPort,
+  randomPorts,
+  findPort,
+  interfaceAddress,
+  parseStreamKey,
+};

package/src/client/voice/util/PlayInterface.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const { Readable } = require('stream');
+const prism = require('prism-media');
+const { Error } = require('../../../errors');
+
+/**
+ * Options that can be passed to stream-playing methods:
+ * @typedef {Object} StreamOptions
+ * @property {StreamType} [type='unknown'] The type of stream.
+ * @property {number} [seek=0] The time to seek to, will be ignored when playing `ogg/opus` or `webm/opus` streams
+ * @property {number|boolean} [volume=1] The volume to play at. Set this to false to disable volume transforms for
+ * this stream to improve performance.
+ * @property {number} [plp] Expected packet loss percentage
+ * @property {boolean} [fec] Enabled forward error correction
+ * @property {number|string} [bitrate=96] The bitrate (quality) of the audio in kbps.
+ * If set to 'auto', the voice channel's bitrate will be used
+ * @property {number} [highWaterMark=12] The maximum number of opus packets to make and store before they are
+ * actually needed. See https://nodejs.org/en/docs/guides/backpressuring-in-streams/. Setting this value to
+ * 1 means that changes in volume will be more instant.
+ */
+
+/**
+ * An option passed as part of `StreamOptions` specifying the type of the stream.
+ * * `unknown`: The default type, streams/input will be passed through to ffmpeg before encoding.
+ * Will play most streams.
+ * * `converted`: Play a stream of 16bit signed stereo PCM data, skipping ffmpeg.
+ * * `opus`: Play a stream of opus packets, skipping ffmpeg. You lose the ability to alter volume.
+ * * `ogg/opus`: Play an ogg file with the opus encoding, skipping ffmpeg. You lose the ability to alter volume.
+ * * `webm/opus`: Play a webm file with opus audio, skipping ffmpeg. You lose the ability to alter volume.
+ * @typedef {string} StreamType
+ */
+
+/**
+ * An interface class to allow you to play audio over VoiceConnections.
+ */
+class PlayInterface {
+  constructor(player) {
+    this.player = player;
+  }
+
+  /**
+   * Play an audio resource.
+   * @param {ReadableStream|string} resource The resource to play.
+   * @param {StreamOptions} [options] The options to play.
+   * @example
+   * // Play a local audio file
+   * connection.playAudio('/home/hydrabolt/audio.mp3', { volume: 0.5 });
+   * @example
+   * // Play a ReadableStream
+   * connection.playAudio(ytdl('https://www.youtube.com/watch?v=ZlAU_w7-Xp8', { quality: 'highestaudio' }));
+   * @example
+   * // Using different protocols: https://ffmpeg.org/ffmpeg-protocols.html
+   * connection.playAudio('http://www.sample-videos.com/audio/mp3/wave.mp3');
+   * @returns {AudioDispatcher}
+   */
+  playAudio(resource, options = {}) {
+    if (resource instanceof Readable || typeof resource === 'string') {
+      const type = options.type || 'unknown';
+      if (type === 'unknown') {
+        return this.player.playUnknown(resource, options);
+      } else if (type === 'converted') {
+        return this.player.playPCMStream(resource, options);
+      } else if (type === 'opus') {
+        return this.player.playOpusStream(resource, options);
+      } else if (type === 'ogg/opus') {
+        if (!(resource instanceof Readable)) throw new Error('VOICE_PRISM_DEMUXERS_NEED_STREAM');
+        return this.player.playOpusStream(resource.pipe(new prism.opus.OggDemuxer()), options);
+      } else if (type === 'webm/opus') {
+        if (!(resource instanceof Readable)) throw new Error('VOICE_PRISM_DEMUXERS_NEED_STREAM');
+        return this.player.playOpusStream(resource.pipe(new prism.opus.WebmDemuxer()), options);
+      }
+    }
+    throw new Error('VOICE_PLAY_INTERFACE_BAD_TYPE');
+  }
+
+  /**
+   * Options that can be passed to stream-playing methods:
+   * @typedef {Object} VideoOptions
+   * @property {number} [seek=0] The time to seek to
+   * @property {number} [fps] Video fps
+   * @property {number} [highWaterMark=12] The maximum number of opus packets to make and store before they are
+   * actually needed. See https://nodejs.org/en/docs/guides/backpressuring-in-streams/. Setting this value to
+   * 1 means that changes in volume will be more instant.
+   * @property {'ultrafast' | 'superfast' | 'veryfast' | 'faster' | 'fast' | 'medium' | 'slow' | 'slower' | 'veryslow'} [presetH26x='veryfast'] ffmpeg preset h264
+   * @property {boolean} [hwAccel=false]  Enables hardware accelerated video decoding. Enabling this option might result in an exception
+   * being thrown by Ffmpeg process if your system does not support hardware acceleration
+   * @property {string[]} [inputFFmpegArgs] input ffmpeg
+   * Ex: ['-config1', 'value1', '-config2', 'value2']
+   * @property {string[]} [outputFFmpegArgs] output ffmpeg
+   * Ex: ['-config1', 'value1', '-config2', 'value2']
+   * @property {number|'auto'} [bitrate=2000] The bitrate (quality) of the video in kbps.
+   * If set to 'auto', ffmpeg will automatically select
+   */
+
+  /**
+   * Play a video resource.
+   * @param {ReadableStream|string} resource The resource to play.
+   * @param {VideoOptions} [options] The options to play.
+   * @example
+   * // Play a local video file
+   * connection.playVideo('/home/hydrabolt/video.mp4');
+   * @example
+   * // Using different protocols: https://ffmpeg.org/ffmpeg-protocols.html
+   * connection.playVideo('http://www.sample-videos.com/video/mp4/wave.mp4');
+   * @returns {VideoDispatcher}
+   */
+  playVideo(resource, options = {}) {
+    if (resource instanceof Readable || typeof resource === 'string') {
+      return this.player.playUnknownVideo(resource, options);
+    }
+    throw new Error('VOICE_PLAY_INTERFACE_BAD_TYPE');
+  }
+
+  static applyToClass(structure) {
+    for (const prop of ['playAudio', 'playVideo']) {
+      Object.defineProperty(structure.prototype, prop, Object.getOwnPropertyDescriptor(PlayInterface.prototype, prop));
+    }
+  }
+}
+
+module.exports = PlayInterface;

package/src/client/voice/util/Secretbox.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const libs = {
+  sodium: sodium => ({
+    crypto_aead_xchacha20poly1305_ietf_encrypt: (plaintext, additionalData, nonce, key) =>
+      sodium.api.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, null, nonce, key),
+    crypto_aead_xchacha20poly1305_ietf_decrypt: (plaintext, additionalData, nonce, key) =>
+      sodium.api.crypto_aead_xchacha20poly1305_ietf_decrypt(plaintext, additionalData, null, nonce, key),
+  }),
+  'libsodium-wrappers': sodium => ({
+    crypto_aead_xchacha20poly1305_ietf_encrypt: (plaintext, additionalData, nonce, key) =>
+      sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(plaintext, additionalData, null, nonce, key),
+    crypto_aead_xchacha20poly1305_ietf_decrypt: (plaintext, additionalData, nonce, key) =>
+      sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(null, plaintext, additionalData, nonce, key),
+  }),
+  '@stablelib/xchacha20poly1305': stablelib => ({
+    crypto_aead_xchacha20poly1305_ietf_encrypt(cipherText, additionalData, nonce, key) {
+      const crypto = new stablelib.XChaCha20Poly1305(key);
+      return crypto.seal(nonce, cipherText, additionalData);
+    },
+    crypto_aead_xchacha20poly1305_ietf_decrypt(plaintext, additionalData, nonce, key) {
+      const crypto = new stablelib.XChaCha20Poly1305(key);
+      return crypto.open(nonce, plaintext, additionalData);
+    },
+  }),
+};
+
+function NoLib() {
+  throw new Error(
+    'Cannot play audio as no valid encryption package is installed.\n- Install sodium, libsodium-wrappers, or @stablelib/xchacha20poly1305.',
+  );
+}
+
+exports.methods = {
+  crypto_aead_xchacha20poly1305_ietf_encrypt: NoLib,
+  crypto_aead_xchacha20poly1305_ietf_decrypt: NoLib,
+};
+
+async function importModule(name, usingImport = false) {
+  try {
+    if (usingImport) {
+      return await import(name);
+    } else {
+      return require(name);
+    }
+  } catch (e) {
+    if (e.code == 'ERR_REQUIRE_ESM') {
+      return importModule(name, true);
+    } else {
+      throw e;
+    }
+  }
+}
+
+(async () => {
+  for (const libName of Object.keys(libs)) {
+    try {
+      const lib = await importModule(libName);
+      if (libName === 'libsodium-wrappers' && lib.ready) await lib.ready; // eslint-disable-line no-await-in-loop
+      exports.methods = libs[libName](lib);
+      break;
+    } catch {} // eslint-disable-line no-empty
+  }
+})();

package/src/client/voice/util/Silence.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const { Readable } = require('stream');
+
+const SILENCE_FRAME = Buffer.from([0xf8, 0xff, 0xfe]);
+
+class Silence extends Readable {
+  _read() {
+    this.push(SILENCE_FRAME);
+  }
+}
+
+Silence.SILENCE_FRAME = SILENCE_FRAME;
+
+module.exports = Silence;

package/src/client/voice/util/Socket.js

@@ -0,0 +1,68 @@
+'use strict';
+
+/*
+Credit: https://github.com/dank074/Discord-video-stream
+The use of video streaming in this library is an incomplete implementation with many bugs, primarily aimed at lazy users.
+The video streaming features in this library are sourced from https://github.com/dank074/Discord-video-stream.
+
+Please use the @dank074/discord-video-stream library to access all advanced and professional features,
+along with comprehensive support. I will not actively fix bugs related to streaming and encourage everyone to
+use https://github.com/dank074/Discord-video-stream for stable and smooth streaming.
+
+To reiterate: This is an incomplete implementation of the library https://github.com/dank074/Discord-video-stream.
+
+Thanks to dank074 and longnguyen2004 for implementing new codecs (H264, H265).
+Thanks to mrjvs for discovering how Discord transmits data and the VP8 codec.
+
+Please use the @dank074/discord-video-stream library for the best support.
+*/
+
+const net = require('net');
+const { randomUUID } = require('node:crypto');
+const os = require('node:os');
+const path = require('path');
+const process = require('process');
+
+let counter = 0;
+
+class UnixStream {
+  constructor(stream, onSocket) {
+    if (process.platform === 'win32') {
+      const pipePrefix = '\\\\.\\pipe\\';
+      const pipeName = `node-webrtc.${++counter}.sock`;
+      this.socketPath = path.join(pipePrefix, pipeName);
+      this.url = this.socketPath;
+    } else {
+      this.socketPath = path.join(os.tmpdir(), `djs-${randomUUID()}.sock`);
+      this.url = `unix:${this.socketPath}`;
+    }
+
+    const server = net.createServer(onSocket);
+    this.server = server;
+    this.connections = new Set();
+    server.on('connection', socket => {
+      this.connections.add(socket);
+      socket.once('close', () => this.connections.delete(socket));
+    });
+    server.on('error', error => stream.destroy(error));
+    stream.on('finish', () => {
+      server.close();
+    });
+    server.listen(this.socketPath);
+  }
+
+  destroy() {
+    for (const socket of this.connections) socket.destroy();
+    this.server.close();
+  }
+}
+
+function StreamInput(stream) {
+  return new UnixStream(stream, socket => stream.pipe(socket));
+}
+
+function StreamOutput(stream) {
+  return new UnixStream(stream, socket => socket.pipe(stream));
+}
+
+module.exports = { StreamOutput, StreamInput, UnixStream };

package/src/client/voice/util/VideoFrames.js

@@ -0,0 +1,183 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+
+const START = Buffer.from([0, 0, 0, 1]);
+const MAX_FRAME = 32 * 1024 * 1024;
+
+function lengthPrefixedToAnnexB(frame) {
+  const nalus = [];
+  let offset = 0;
+  while (offset < frame.length) {
+    if (offset + 4 > frame.length) throw new RangeError('Truncated NAL length');
+    const size = frame.readUInt32BE(offset);
+    offset += 4;
+    if (!size || offset + size > frame.length) throw new RangeError('Invalid NAL length');
+    nalus.push(START, frame.subarray(offset, offset + size));
+    offset += size;
+  }
+  return Buffer.concat(nalus);
+}
+
+function annexBNalus(frame) {
+  const starts = [];
+  for (let i = 0; i + 3 < frame.length; i++) {
+    if (frame[i] || frame[i + 1]) continue;
+    const size = frame[i + 2] === 1 ? 3 : frame[i + 2] === 0 && frame[i + 3] === 1 ? 4 : 0;
+    if (size) {
+      starts.push({ offset: i, size });
+      i += size - 1;
+    }
+  }
+  if (!starts.length || starts[0].offset !== 0) throw new RangeError('Missing Annex B start code');
+  return starts.map((start, i) => frame.subarray(start.offset + start.size, starts[i + 1]?.offset ?? frame.length));
+}
+
+function packetize(frame, codec, mtu = 1200, pictureId = 0) {
+  if (!Number.isInteger(mtu) || mtu < 16) throw new RangeError('Invalid video MTU');
+  const output = [];
+  if (codec === 'VP8') {
+    for (let offset = 0; offset < frame.length; offset += mtu - 4) {
+      const descriptor = Buffer.from([offset ? 0x80 : 0x90, 0x80, 0x80 | ((pictureId >> 8) & 0x7f), pictureId & 0xff]);
+      output.push(Buffer.concat([descriptor, frame.subarray(offset, offset + mtu - 4)]));
+    }
+    return output;
+  }
+  if (!['H264', 'H265'].includes(codec)) throw new RangeError(`Unsupported video codec: ${codec}`);
+  for (const nalu of annexBNalus(frame)) {
+    if (nalu.length <= mtu) {
+      output.push(nalu);
+      continue;
+    }
+    const headerSize = codec === 'H264' ? 1 : 2;
+    const fuSize = headerSize + 1;
+    const type = codec === 'H264' ? nalu[0] & 31 : (nalu[0] >> 1) & 63;
+    for (let offset = headerSize; offset < nalu.length; offset += mtu - fuSize) {
+      const end = Math.min(nalu.length, offset + mtu - fuSize);
+      const flags = (offset === headerSize ? 0x80 : 0) | (end === nalu.length ? 0x40 : 0);
+      const fu =
+        codec === 'H264'
+          ? Buffer.from([(nalu[0] & 0xe0) | 28, flags | type])
+          : Buffer.from([(nalu[0] & 0x81) | (49 << 1), nalu[1], flags | type]);
+      output.push(Buffer.concat([fu, nalu.subarray(offset, end)]));
+    }
+  }
+  return output;
+}
+
+function depacketize(payloads, codec) {
+  const parts = [];
+  let fragment = false;
+  for (const payload of payloads) {
+    if (!payload.length) throw new RangeError('Empty video payload');
+    if (codec === 'VP8') {
+      if (!parts.length && !(payload[0] & 0x10)) throw new RangeError('Missing first VP8 partition');
+      let offset = 1;
+      if (payload[0] & 0x80) {
+        const flags = payload[offset++];
+        if (flags & 0x80) offset += payload[offset] & 0x80 ? 2 : 1;
+        if (flags & 0x40) offset++;
+        if (flags & 0x30) offset++;
+      }
+      if (offset >= payload.length) throw new RangeError('Truncated VP8 descriptor');
+      parts.push(payload.subarray(offset));
+      continue;
+    }
+    const h265 = codec === 'H265';
+    const type = h265 ? (payload[0] >> 1) & 63 : payload[0] & 31;
+    const fuType = h265 ? 49 : 28;
+    const aggregateType = h265 ? 48 : 24;
+    if (type === aggregateType) {
+      if (fragment) throw new RangeError('Incomplete fragmented NAL');
+      let offset = h265 ? 2 : 1;
+      while (offset < payload.length) {
+        if (offset + 2 > payload.length) throw new RangeError('Truncated aggregation packet');
+        const size = payload.readUInt16BE(offset);
+        offset += 2;
+        if (!size || offset + size > payload.length) throw new RangeError('Invalid aggregation length');
+        parts.push(START, payload.subarray(offset, offset + size));
+        offset += size;
+      }
+    } else if (type === fuType) {
+      const size = h265 ? 3 : 2;
+      if (payload.length <= size) throw new RangeError('Truncated fragmentation unit');
+      const flags = payload[size - 1];
+      if (flags & 0x80) {
+        if (fragment) throw new RangeError('Incomplete fragmented NAL');
+        fragment = true;
+        parts.push(
+          START,
+          h265
+            ? Buffer.from([(payload[0] & 0x81) | ((flags & 63) << 1), payload[1]])
+            : Buffer.from([(payload[0] & 0xe0) | (flags & 31)]),
+        );
+      } else if (!fragment) {
+        throw new RangeError('Missing first fragmentation unit');
+      }
+      parts.push(payload.subarray(size));
+      if (flags & 0x40) fragment = false;
+    } else {
+      if (fragment) throw new RangeError('Incomplete fragmented NAL');
+      if (type >= aggregateType || (!h265 && type === 0)) throw new RangeError('Unsupported NAL packet');
+      parts.push(START, payload);
+    }
+  }
+  if (fragment) throw new RangeError('Incomplete fragmented NAL');
+  return Buffer.concat(parts);
+}
+
+class VideoFrames {
+  constructor() {
+    this.frames = new Map();
+    this.completed = new Map();
+  }
+
+  push(packet, codec) {
+    const { ssrc, timestamp, sequenceNumber: seq, marker } = packet.header;
+    const now = Date.now();
+    const key = `${ssrc}:${timestamp}:${codec}`;
+    for (const [id, time] of this.completed) {
+      if (now - time > 2000) this.completed.delete(id);
+    }
+    if (this.completed.has(key)) return null;
+    for (const [id, frame] of this.frames) {
+      if (now - frame.time > 2000) this.frames.delete(id);
+    }
+    let frame = this.frames.get(key);
+    if (!frame || frame.timestamp !== timestamp || frame.codec !== codec) {
+      if (this.frames.size >= 32) this.frames.delete(this.frames.keys().next().value);
+      frame = { timestamp, codec, time: now, packets: new Map(), bytes: 0, first: seq, last: null };
+      this.frames.set(key, frame);
+    }
+    if (frame.packets.has(seq)) return null;
+    if (((frame.first - seq) & 65535) < 4096) frame.first = seq;
+    frame.bytes += packet.payload.length;
+    if (frame.bytes > MAX_FRAME || frame.packets.size >= 4096) {
+      this.frames.delete(key);
+      return null;
+    }
+    frame.packets.set(seq, packet.payload);
+    if (marker) frame.last = seq;
+    if (frame.last === null) return null;
+    const count = ((frame.last - frame.first) & 65535) + 1;
+    if (count > 4096 || count !== frame.packets.size) return null;
+    const payloads = [];
+    for (let i = 0; i < count; i++) {
+      const payload = frame.packets.get((frame.first + i) & 65535);
+      if (!payload) return null;
+      payloads.push(payload);
+    }
+    try {
+      const complete = depacketize(payloads, codec);
+      this.frames.delete(key);
+      if (this.completed.size >= 128) this.completed.delete(this.completed.keys().next().value);
+      this.completed.set(key, now);
+      return complete;
+    } catch {
+      // The marker can arrive before the first fragment. Retain bounded state for late packets.
+      return null;
+    }
+  }
+}
+
+module.exports = { VideoFrames, packetize, depacketize, lengthPrefixedToAnnexB, annexBNalus };

package/src/client/voice/util/VolumeInterface.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const EventEmitter = require('events');
+const { Buffer } = require('node:buffer');
+
+/**
+ * An interface class for volume transformation.
+ * @extends {EventEmitter}
+ */
+class VolumeInterface extends EventEmitter {
+  constructor({ volume = 1 } = {}) {
+    super();
+    this.setVolume(volume);
+  }
+
+  /**
+   * Whether or not the volume of this stream is editable
+   * @type {boolean}
+   * @readonly
+   */
+  get volumeEditable() {
+    return true;
+  }
+
+  /**
+   * The current volume of the stream
+   * @type {number}
+   * @readonly
+   */
+  get volume() {
+    return this._volume;
+  }
+
+  /**
+   * The current volume of the stream in decibels
+   * @type {number}
+   * @readonly
+   */
+  get volumeDecibels() {
+    return Math.log10(this.volume) * 20;
+  }
+
+  /**
+   * The current volume of the stream from a logarithmic scale
+   * @type {number}
+   * @readonly
+   */
+  get volumeLogarithmic() {
+    return Math.pow(this.volume, 1 / 1.660964);
+  }
+
+  applyVolume(buffer, volume) {
+    volume = volume || this._volume;
+    if (volume === 1) return buffer;
+
+    const out = Buffer.alloc(buffer.length);
+    for (let i = 0; i < buffer.length; i += 2) {
+      if (i >= buffer.length - 1) break;
+      const uint = Math.min(32767, Math.max(-32767, Math.floor(volume * buffer.readInt16LE(i))));
+      out.writeInt16LE(uint, i);
+    }
+
+    return out;
+  }
+
+  /**
+   * Sets the volume relative to the input stream - i.e. 1 is normal, 0.5 is half, 2 is double.
+   * @param {number} volume The volume that you want to set
+   */
+  setVolume(volume) {
+    /**
+     * Emitted when the volume of this interface changes.
+     * @event VolumeInterface#volumeChange
+     * @param {number} oldVolume The old volume of this interface
+     * @param {number} newVolume The new volume of this interface
+     */
+    this.emit('volumeChange', this._volume, volume);
+    this._volume = volume;
+  }
+
+  /**
+   * Sets the volume in decibels.
+   * @param {number} db The decibels
+   */
+  setVolumeDecibels(db) {
+    this.setVolume(Math.pow(10, db / 20));
+  }
+
+  /**
+   * Sets the volume so that a perceived value of 0.5 is half the perceived volume etc.
+   * @param {number} value The value for the volume
+   */
+  setVolumeLogarithmic(value) {
+    this.setVolume(Math.pow(value, 1.660964));
+  }
+}
+
+const props = ['volumeDecibels', 'volumeLogarithmic', 'setVolumeDecibels', 'setVolumeLogarithmic'];
+exports.VolumeInterface = VolumeInterface;
+
+exports.applyToClass = function applyToClass(structure) {
+  for (const prop of props) {
+    Object.defineProperty(structure.prototype, prop, Object.getOwnPropertyDescriptor(VolumeInterface.prototype, prop));
+  }
+};