700 lines
69 KiB
JavaScript
700 lines
69 KiB
JavaScript
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
|
|
// src/index.ts
|
|
var src_exports = {};
|
|
__export(src_exports, {
|
|
CTL: () => CTL,
|
|
OggDemuxer: () => OggDemuxer,
|
|
OpusDecoder: () => OpusDecoder,
|
|
OpusEncoder: () => OpusEncoder,
|
|
OpusStream: () => OpusStream,
|
|
WebmDemuxer: () => WebmDemuxer,
|
|
addLibopusProvider: () => addLibopusProvider,
|
|
removeLibopusProvider: () => removeLibopusProvider,
|
|
setLibopusProvider: () => setLibopusProvider,
|
|
version: () => version
|
|
});
|
|
module.exports = __toCommonJS(src_exports);
|
|
|
|
// src/OggDemuxer.ts
|
|
var import_node_stream = require("stream");
|
|
var OGG_PAGE_HEADER_SIZE = 26;
|
|
var STREAM_STRUCTURE_VERSION = 0;
|
|
var charCode = /* @__PURE__ */ __name((x) => x.charCodeAt(0), "charCode");
|
|
var OGGS_HEADER = Buffer.from([..."OggS"].map(charCode));
|
|
var OPUS_HEAD = Buffer.from([..."OpusHead"].map(charCode));
|
|
var OPUS_TAGS = Buffer.from([..."OpusTags"].map(charCode));
|
|
var _OggDemuxer = class _OggDemuxer extends import_node_stream.Transform {
|
|
/**
|
|
* Creates a new OggOpus demuxer.
|
|
* @param {Object} [options] options that you would pass to a regular Transform stream.
|
|
* @memberof opus
|
|
*/
|
|
constructor(options = {}) {
|
|
super(Object.assign({ readableObjectMode: true }, options));
|
|
__publicField(this, "_remainder", null);
|
|
__publicField(this, "_head", null);
|
|
__publicField(this, "_bitstream", null);
|
|
this._remainder = null;
|
|
this._head = null;
|
|
this._bitstream = null;
|
|
}
|
|
_transform(chunk, encoding, done) {
|
|
if (this._remainder) {
|
|
chunk = Buffer.concat([this._remainder, chunk]);
|
|
this._remainder = null;
|
|
}
|
|
try {
|
|
while (chunk) {
|
|
const result = this._readPage(chunk);
|
|
if (result) chunk = result;
|
|
else
|
|
break;
|
|
}
|
|
} catch (error) {
|
|
done(error);
|
|
return;
|
|
}
|
|
this._remainder = chunk;
|
|
done();
|
|
}
|
|
/**
|
|
* Reads a page from a buffer
|
|
* @private
|
|
* @param {Buffer} chunk the chunk containing the page
|
|
* @returns {boolean|Buffer} if a buffer, it will be a slice of the excess data of the original, otherwise it will be
|
|
* false and would indicate that there is not enough data to go ahead with reading this page.
|
|
*/
|
|
_readPage(chunk) {
|
|
if (chunk.length < OGG_PAGE_HEADER_SIZE) {
|
|
return false;
|
|
}
|
|
if (!chunk.subarray(0, 4).equals(OGGS_HEADER)) {
|
|
throw Error(`capture_pattern is not ${OGGS_HEADER}`);
|
|
}
|
|
if (chunk.readUInt8(4) !== STREAM_STRUCTURE_VERSION) {
|
|
throw Error(
|
|
`stream_structure_version is not ${STREAM_STRUCTURE_VERSION}`
|
|
);
|
|
}
|
|
if (chunk.length < 27) return false;
|
|
const pageSegments = chunk.readUInt8(26);
|
|
if (chunk.length < 27 + pageSegments) return false;
|
|
const table = chunk.subarray(27, 27 + pageSegments);
|
|
const bitstream = chunk.readUInt32BE(14);
|
|
const sizes = [];
|
|
let totalSize = 0;
|
|
for (let i = 0; i < pageSegments; ) {
|
|
let size = 0, x = 255;
|
|
while (x === 255) {
|
|
if (i >= table.length) return false;
|
|
x = table.readUInt8(i);
|
|
i++;
|
|
size += x;
|
|
}
|
|
sizes.push(size);
|
|
totalSize += size;
|
|
}
|
|
if (chunk.length < 27 + pageSegments + totalSize) return false;
|
|
let start = 27 + pageSegments;
|
|
for (const size of sizes) {
|
|
const segment = chunk.subarray(start, start + size);
|
|
const header = segment.subarray(0, 8);
|
|
if (this._head) {
|
|
if (header.equals(OPUS_TAGS)) this.emit("tags", segment);
|
|
else if (this._bitstream === bitstream) this.push(segment);
|
|
} else if (header.equals(OPUS_HEAD)) {
|
|
this.emit("head", segment);
|
|
this._head = segment;
|
|
this._bitstream = bitstream;
|
|
} else {
|
|
this.emit("unknownSegment", segment);
|
|
}
|
|
start += size;
|
|
}
|
|
return chunk.subarray(start);
|
|
}
|
|
_destroy(err, cb) {
|
|
this._cleanup();
|
|
return cb ? cb(err) : void 0;
|
|
}
|
|
_final(cb) {
|
|
this._cleanup();
|
|
cb();
|
|
}
|
|
/**
|
|
* Cleans up the demuxer when it is no longer required.
|
|
* @private
|
|
*/
|
|
_cleanup() {
|
|
this._remainder = null;
|
|
this._head = null;
|
|
this._bitstream = null;
|
|
}
|
|
};
|
|
__name(_OggDemuxer, "OggDemuxer");
|
|
var OggDemuxer = _OggDemuxer;
|
|
|
|
// src/OpusEncoder.ts
|
|
var import_node_stream2 = require("stream");
|
|
var loadModule = /* @__PURE__ */ __name((modules) => {
|
|
const errors = [];
|
|
for (const [name, fn] of modules) {
|
|
try {
|
|
return {
|
|
// eslint-disable-next-line @typescript-eslint/no-var-requires
|
|
...fn(require(name)),
|
|
name
|
|
};
|
|
} catch (e) {
|
|
errors.push(`Failed to load ${name}: ${e}`);
|
|
continue;
|
|
}
|
|
}
|
|
throw new Error(
|
|
`Could not load opus module, tried ${modules.length} different modules. Errors: ${errors.join("\n")}`
|
|
);
|
|
}, "loadModule");
|
|
var CTL = {
|
|
BITRATE: 4002,
|
|
FEC: 4012,
|
|
PLP: 4014
|
|
};
|
|
var OPUS_MOD_REGISTRY = [
|
|
[
|
|
"mediaplex",
|
|
(mod) => {
|
|
if (!mod.OpusEncoder) throw new Error("Unsupported mediaplex version");
|
|
return { Encoder: mod.OpusEncoder };
|
|
}
|
|
],
|
|
["@discordjs/opus", (opus) => ({ Encoder: opus.OpusEncoder })],
|
|
["opusscript", (opus) => ({ Encoder: opus })],
|
|
[
|
|
"@evan/opus",
|
|
(opus) => {
|
|
const { Encoder, Decoder } = opus;
|
|
const _OpusEncoder2 = class _OpusEncoder2 {
|
|
constructor(_rate, _channels, _application) {
|
|
this._rate = _rate;
|
|
this._channels = _channels;
|
|
this._application = _application;
|
|
__publicField(this, "_encoder");
|
|
__publicField(this, "_decoder");
|
|
}
|
|
_ensureEncoder() {
|
|
if (this._encoder) return;
|
|
this._encoder = new Encoder({
|
|
channels: this._channels,
|
|
sample_rate: this._rate,
|
|
application: {
|
|
2048: "voip",
|
|
2049: "audio",
|
|
2051: "restricted_lowdelay"
|
|
}[this._application]
|
|
});
|
|
}
|
|
_ensureDecoder() {
|
|
if (this._decoder) return;
|
|
this._decoder = new Decoder({
|
|
channels: this._channels,
|
|
sample_rate: this._rate
|
|
});
|
|
}
|
|
encode(buffer) {
|
|
this._ensureEncoder();
|
|
return Buffer.from(this._encoder.encode(buffer));
|
|
}
|
|
decode(buffer) {
|
|
this._ensureDecoder();
|
|
return Buffer.from(this._decoder.decode(buffer));
|
|
}
|
|
applyEncoderCTL(ctl, value) {
|
|
this._ensureEncoder();
|
|
this._encoder.ctl(ctl, value);
|
|
}
|
|
delete() {
|
|
this._encoder = null;
|
|
this._decoder = null;
|
|
}
|
|
};
|
|
__name(_OpusEncoder2, "OpusEncoder");
|
|
let OpusEncoder2 = _OpusEncoder2;
|
|
return { Encoder: OpusEncoder2 };
|
|
}
|
|
],
|
|
["node-opus", (opus) => ({ Encoder: opus.OpusEncoder })]
|
|
];
|
|
var Opus = {};
|
|
var addLibopusProvider = /* @__PURE__ */ __name((provider) => {
|
|
if (OPUS_MOD_REGISTRY.some(([, fn]) => fn === provider[1])) return;
|
|
OPUS_MOD_REGISTRY.push(provider);
|
|
}, "addLibopusProvider");
|
|
var removeLibopusProvider = /* @__PURE__ */ __name((name) => {
|
|
const index = OPUS_MOD_REGISTRY.findIndex((o) => o[0] === name);
|
|
if (index === -1) return false;
|
|
OPUS_MOD_REGISTRY.splice(index, 1);
|
|
return true;
|
|
}, "removeLibopusProvider");
|
|
var setLibopusProvider = /* @__PURE__ */ __name((provider, name) => {
|
|
Opus = { Encoder: provider, name };
|
|
}, "setLibopusProvider");
|
|
function loadOpus(refresh = false) {
|
|
if (Opus.Encoder && !refresh) return Opus;
|
|
Opus = loadModule(OPUS_MOD_REGISTRY);
|
|
return Opus;
|
|
}
|
|
__name(loadOpus, "loadOpus");
|
|
var charCode2 = /* @__PURE__ */ __name((x) => x.charCodeAt(0), "charCode");
|
|
var OPUS_HEAD2 = Buffer.from([..."OpusHead"].map(charCode2));
|
|
var OPUS_TAGS2 = Buffer.from([..."OpusTags"].map(charCode2));
|
|
var _OpusStream = class _OpusStream extends import_node_stream2.Transform {
|
|
/**
|
|
* Creates a new Opus transformer.
|
|
* @private
|
|
* @memberof opus
|
|
* @param {Object} [options] options that you would pass to a regular Transform stream
|
|
*/
|
|
constructor(options = {}) {
|
|
if (!loadOpus().Encoder) {
|
|
throw Error(
|
|
`Could not find an Opus module! Please install one of ${OPUS_MOD_REGISTRY.map(
|
|
(o) => o[0]
|
|
).join(", ")}.`
|
|
);
|
|
}
|
|
super(Object.assign({ readableObjectMode: true }, options));
|
|
__publicField(this, "encoder", null);
|
|
__publicField(this, "_options");
|
|
__publicField(this, "_required");
|
|
const lib = Opus;
|
|
if (lib.name === "opusscript") {
|
|
options.application = lib.Encoder.Application[options.application];
|
|
}
|
|
this.encoder = new lib.Encoder(
|
|
options.rate,
|
|
options.channels,
|
|
options.application
|
|
);
|
|
this._options = options;
|
|
this._required = this._options.frameSize * this._options.channels * 2;
|
|
}
|
|
_encode(buffer) {
|
|
if (Opus.name === "opusscript") {
|
|
return this.encoder.encode(buffer, this._options.frameSize);
|
|
} else {
|
|
return this.encoder.encode(buffer);
|
|
}
|
|
}
|
|
_decode(buffer) {
|
|
if (Opus.name === "opusscript") {
|
|
return this.encoder.decode(buffer, this._options.frameSize);
|
|
} else {
|
|
return this.encoder.decode(buffer);
|
|
}
|
|
}
|
|
/**
|
|
* Returns the Opus module being used - `mediaplex`, `opusscript`, `node-opus`, or `@discordjs/opus`.
|
|
* @type {string}
|
|
* @readonly
|
|
* @example
|
|
* console.log(`Using Opus module ${OpusEncoder.type}`);
|
|
*/
|
|
static get type() {
|
|
return Opus.name;
|
|
}
|
|
/**
|
|
* Sets the bitrate of the stream.
|
|
* @param {number} bitrate the bitrate to use use, e.g. 48000
|
|
* @public
|
|
*/
|
|
setBitrate(bitrate) {
|
|
(this.encoder.applyEncoderCTL || this.encoder.encoderCTL).apply(
|
|
this.encoder,
|
|
[CTL.BITRATE, Math.min(128e3, Math.max(16e3, bitrate))]
|
|
);
|
|
}
|
|
/**
|
|
* Enables or disables forward error correction.
|
|
* @param {boolean} enabled whether or not to enable FEC.
|
|
* @public
|
|
*/
|
|
setFEC(enabled) {
|
|
(this.encoder.applyEncoderCTL || this.encoder.encoderCTL).apply(
|
|
this.encoder,
|
|
[CTL.FEC, enabled ? 1 : 0]
|
|
);
|
|
}
|
|
/**
|
|
* Sets the expected packet loss over network transmission.
|
|
* @param {number} [percentage] a percentage (represented between 0 and 1)
|
|
*/
|
|
setPLP(percentage) {
|
|
(this.encoder.applyEncoderCTL || this.encoder.encoderCTL).apply(
|
|
this.encoder,
|
|
[CTL.PLP, Math.min(100, Math.max(0, percentage * 100))]
|
|
);
|
|
}
|
|
_final(cb) {
|
|
this._cleanup();
|
|
cb();
|
|
}
|
|
_destroy(err, cb) {
|
|
this._cleanup();
|
|
return cb ? cb(err) : void 0;
|
|
}
|
|
/**
|
|
* Cleans up the Opus stream when it is no longer needed
|
|
* @private
|
|
*/
|
|
_cleanup() {
|
|
if (typeof this.encoder?.delete === "function") this.encoder.delete();
|
|
this.encoder = null;
|
|
}
|
|
};
|
|
__name(_OpusStream, "OpusStream");
|
|
var OpusStream = _OpusStream;
|
|
var _OpusEncoder = class _OpusEncoder extends OpusStream {
|
|
/**
|
|
* Creates a new Opus encoder stream.
|
|
* @memberof opus
|
|
* @param {Object} options options that you would pass to a regular OpusStream, plus a few more:
|
|
* @param {number} options.frameSize the frame size in bytes to use (e.g. 960 for stereo audio at 48KHz with a frame
|
|
* duration of 20ms)
|
|
* @param {number} options.channels the number of channels to use
|
|
* @param {number} options.rate the sampling rate in Hz
|
|
*/
|
|
constructor(options = {}) {
|
|
super(options);
|
|
__publicField(this, "_buffer", Buffer.allocUnsafe(0));
|
|
}
|
|
_transform(newChunk, encoding, done) {
|
|
const chunk = Buffer.concat([this._buffer, newChunk]);
|
|
let i = 0;
|
|
while (chunk.length >= i + this._required) {
|
|
const pcm = chunk.slice(i, i + this._required);
|
|
let opus;
|
|
try {
|
|
opus = this.encoder.encode(pcm);
|
|
} catch (error) {
|
|
done(error);
|
|
return;
|
|
}
|
|
this.push(opus);
|
|
i += this._required;
|
|
}
|
|
if (i > 0) this._buffer = chunk.slice(i);
|
|
done();
|
|
}
|
|
_destroy(err, cb) {
|
|
super._destroy(err, cb);
|
|
this._buffer = Buffer.allocUnsafe(0);
|
|
}
|
|
};
|
|
__name(_OpusEncoder, "OpusEncoder");
|
|
var OpusEncoder = _OpusEncoder;
|
|
var _OpusDecoder = class _OpusDecoder extends OpusStream {
|
|
_transform(chunk, encoding, done) {
|
|
const signature = chunk.slice(0, 8);
|
|
if (chunk.length >= 8 && signature.equals(OPUS_HEAD2)) {
|
|
this.emit("format", {
|
|
channels: this._options.channels,
|
|
sampleRate: this._options.rate,
|
|
bitDepth: 16,
|
|
float: false,
|
|
signed: true,
|
|
version: chunk.readUInt8(8),
|
|
preSkip: chunk.readUInt16LE(10),
|
|
gain: chunk.readUInt16LE(16)
|
|
});
|
|
return done();
|
|
}
|
|
if (chunk.length >= 8 && signature.equals(OPUS_TAGS2)) {
|
|
this.emit("tags", chunk);
|
|
return done();
|
|
}
|
|
try {
|
|
this.push(this._decode(chunk));
|
|
} catch (e) {
|
|
return done(e);
|
|
}
|
|
return done();
|
|
}
|
|
};
|
|
__name(_OpusDecoder, "OpusDecoder");
|
|
var OpusDecoder = _OpusDecoder;
|
|
|
|
// src/WebmBase.ts
|
|
var import_node_stream3 = require("stream");
|
|
var _WebmBaseDemuxer = class _WebmBaseDemuxer extends import_node_stream3.Transform {
|
|
/**
|
|
* Creates a new Webm demuxer.
|
|
* @param {Object} [options] options that you would pass to a regular Transform stream.
|
|
*/
|
|
constructor(options = {}) {
|
|
super(Object.assign({ readableObjectMode: true }, options));
|
|
__publicField(this, "_remainder", null);
|
|
__publicField(this, "_length", 0);
|
|
__publicField(this, "_count", 0);
|
|
__publicField(this, "_skipUntil", null);
|
|
__publicField(this, "_track", null);
|
|
__publicField(this, "_incompleteTrack", {});
|
|
__publicField(this, "_ebmlFound", false);
|
|
this._remainder = null;
|
|
this._length = 0;
|
|
this._count = 0;
|
|
this._skipUntil = null;
|
|
this._track = null;
|
|
this._incompleteTrack = {};
|
|
this._ebmlFound = false;
|
|
}
|
|
_checkHead(data) {
|
|
}
|
|
_transform(chunk, encoding, done) {
|
|
this._length += chunk.length;
|
|
if (this._remainder) {
|
|
chunk = Buffer.concat([this._remainder, chunk]);
|
|
this._remainder = null;
|
|
}
|
|
let offset = 0;
|
|
if (this._skipUntil && this._length > this._skipUntil) {
|
|
offset = this._skipUntil - this._count;
|
|
this._skipUntil = null;
|
|
} else if (this._skipUntil) {
|
|
this._count += chunk.length;
|
|
done();
|
|
return;
|
|
}
|
|
let result;
|
|
while (result !== _WebmBaseDemuxer.TOO_SHORT) {
|
|
try {
|
|
result = this._readTag(chunk, offset);
|
|
} catch (error) {
|
|
done(error);
|
|
return;
|
|
}
|
|
if (result === _WebmBaseDemuxer.TOO_SHORT) break;
|
|
if (result._skipUntil) {
|
|
this._skipUntil = result._skipUntil;
|
|
break;
|
|
}
|
|
if (result.offset) offset = result.offset;
|
|
else
|
|
break;
|
|
}
|
|
this._count += offset;
|
|
this._remainder = chunk.subarray(offset);
|
|
done();
|
|
return;
|
|
}
|
|
/**
|
|
* Reads an EBML ID from a buffer.
|
|
* @private
|
|
* @param {Buffer} chunk the buffer to read from.
|
|
* @param {number} offset the offset in the buffer.
|
|
* @returns {Object|Symbol} contains an `id` property (buffer) and the new `offset` (number).
|
|
* Returns the TOO_SHORT symbol if the data wasn't big enough to facilitate the request.
|
|
*/
|
|
_readEBMLId(chunk, offset) {
|
|
const idLength = vintLength(chunk, offset);
|
|
if (idLength === _WebmBaseDemuxer.TOO_SHORT)
|
|
return _WebmBaseDemuxer.TOO_SHORT;
|
|
return {
|
|
id: chunk.subarray(offset, offset + idLength),
|
|
offset: offset + idLength
|
|
};
|
|
}
|
|
/**
|
|
* Reads a size variable-integer to calculate the length of the data of a tag.
|
|
* @private
|
|
* @param {Buffer} chunk the buffer to read from.
|
|
* @param {number} offset the offset in the buffer.
|
|
* @returns {Object|Symbol} contains property `offset` (number), `dataLength` (number) and `sizeLength` (number).
|
|
* Returns the TOO_SHORT symbol if the data wasn't big enough to facilitate the request.
|
|
*/
|
|
_readTagDataSize(chunk, offset) {
|
|
const sizeLength = vintLength(chunk, offset);
|
|
if (sizeLength === _WebmBaseDemuxer.TOO_SHORT)
|
|
return _WebmBaseDemuxer.TOO_SHORT;
|
|
const dataLength = expandVint(chunk, offset, offset + sizeLength);
|
|
return { offset: offset + sizeLength, dataLength, sizeLength };
|
|
}
|
|
/**
|
|
* Takes a buffer and attempts to read and process a tag.
|
|
* @private
|
|
* @param {Buffer} chunk the buffer to read from.
|
|
* @param {number} offset the offset in the buffer.
|
|
* @returns {Object|Symbol} contains the new `offset` (number) and optionally the `_skipUntil` property,
|
|
* indicating that the stream should ignore any data until a certain length is reached.
|
|
* Returns the TOO_SHORT symbol if the data wasn't big enough to facilitate the request.
|
|
*/
|
|
_readTag(chunk, offset) {
|
|
const idData = this._readEBMLId(chunk, offset);
|
|
if (idData === _WebmBaseDemuxer.TOO_SHORT) return _WebmBaseDemuxer.TOO_SHORT;
|
|
const ebmlID = idData.id.toString("hex");
|
|
if (!this._ebmlFound) {
|
|
if (ebmlID === "1a45dfa3") this._ebmlFound = true;
|
|
else
|
|
throw Error("Did not find the EBML tag at the start of the stream");
|
|
}
|
|
offset = idData.offset;
|
|
const sizeData = this._readTagDataSize(chunk, offset);
|
|
if (sizeData === _WebmBaseDemuxer.TOO_SHORT)
|
|
return _WebmBaseDemuxer.TOO_SHORT;
|
|
const { dataLength } = sizeData;
|
|
offset = sizeData.offset;
|
|
if (typeof _WebmBaseDemuxer.TAGS[ebmlID] === "undefined") {
|
|
if (chunk.length > offset + dataLength) {
|
|
return { offset: offset + dataLength };
|
|
}
|
|
return {
|
|
offset,
|
|
_skipUntil: this._count + offset + dataLength
|
|
};
|
|
}
|
|
const tagHasChildren = _WebmBaseDemuxer.TAGS[ebmlID];
|
|
if (tagHasChildren) {
|
|
return { offset };
|
|
}
|
|
if (offset + dataLength > chunk.length)
|
|
return _WebmBaseDemuxer.TOO_SHORT;
|
|
const data = chunk.subarray(
|
|
offset,
|
|
offset + dataLength
|
|
);
|
|
if (!this._track) {
|
|
if (ebmlID === "ae") this._incompleteTrack = {};
|
|
if (ebmlID === "d7") this._incompleteTrack.number = data[0];
|
|
if (ebmlID === "83") this._incompleteTrack.type = data[0];
|
|
if (this._incompleteTrack.type === 2 && typeof this._incompleteTrack.number !== "undefined") {
|
|
this._track = this._incompleteTrack;
|
|
}
|
|
}
|
|
if (ebmlID === "63a2") {
|
|
this._checkHead(data);
|
|
this.emit("head", data);
|
|
} else if (ebmlID === "a3") {
|
|
if (!this._track) throw Error("No audio track in this webm!");
|
|
if ((data[0] & 15) === this._track.number) {
|
|
this.push(data.subarray(4));
|
|
}
|
|
}
|
|
return { offset: offset + dataLength };
|
|
}
|
|
_destroy(err, cb) {
|
|
this._cleanup();
|
|
return cb ? cb(err) : void 0;
|
|
}
|
|
_final(cb) {
|
|
this._cleanup();
|
|
cb();
|
|
}
|
|
/**
|
|
* Cleans up the demuxer when it is no longer required.
|
|
* @private
|
|
*/
|
|
_cleanup() {
|
|
this._remainder = null;
|
|
this._incompleteTrack = {};
|
|
}
|
|
};
|
|
__name(_WebmBaseDemuxer, "WebmBaseDemuxer");
|
|
__publicField(_WebmBaseDemuxer, "TAGS", {
|
|
// value is true if the element has children
|
|
"1a45dfa3": true,
|
|
// EBML
|
|
"18538067": true,
|
|
// Segment
|
|
"1f43b675": true,
|
|
// Cluster
|
|
"1654ae6b": true,
|
|
// Tracks
|
|
ae: true,
|
|
// TrackEntry
|
|
d7: false,
|
|
// TrackNumber
|
|
"83": false,
|
|
// TrackType
|
|
a3: false,
|
|
// SimpleBlock
|
|
"63a2": false
|
|
});
|
|
__publicField(_WebmBaseDemuxer, "TOO_SHORT", Symbol("TOO_SHORT"));
|
|
var WebmBaseDemuxer = _WebmBaseDemuxer;
|
|
function vintLength(buffer, index) {
|
|
if (index < 0 || index > buffer.length - 1) {
|
|
return WebmBaseDemuxer.TOO_SHORT;
|
|
}
|
|
let i = 0;
|
|
for (; i < 8; i++) if (1 << 7 - i & buffer[index]) break;
|
|
i++;
|
|
if (index + i > buffer.length) {
|
|
return WebmBaseDemuxer.TOO_SHORT;
|
|
}
|
|
return i;
|
|
}
|
|
__name(vintLength, "vintLength");
|
|
function expandVint(buffer, start, end) {
|
|
const length = vintLength(buffer, start);
|
|
if (end > buffer.length || length === WebmBaseDemuxer.TOO_SHORT)
|
|
return WebmBaseDemuxer.TOO_SHORT;
|
|
const mask = (1 << 8 - length) - 1;
|
|
let value = buffer[start] & mask;
|
|
for (let i = start + 1; i < end; i++) {
|
|
value = (value << 8) + buffer[i];
|
|
}
|
|
return value;
|
|
}
|
|
__name(expandVint, "expandVint");
|
|
|
|
// src/WebmDemuxer.ts
|
|
var OPUS_HEAD3 = Buffer.from([..."OpusHead"].map((x) => x.charCodeAt(0)));
|
|
var _WebmDemuxer = class _WebmDemuxer extends WebmBaseDemuxer {
|
|
_checkHead(data) {
|
|
if (!data.subarray(0, 8).equals(OPUS_HEAD3)) {
|
|
throw Error("Audio codec is not Opus!");
|
|
}
|
|
}
|
|
};
|
|
__name(_WebmDemuxer, "WebmDemuxer");
|
|
var WebmDemuxer = _WebmDemuxer;
|
|
|
|
// src/version.ts
|
|
var version = (
|
|
/* @__MACRO__ getVersion */
|
|
"7.2.0"
|
|
);
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
CTL,
|
|
OggDemuxer,
|
|
OpusDecoder,
|
|
OpusEncoder,
|
|
OpusStream,
|
|
WebmDemuxer,
|
|
addLibopusProvider,
|
|
removeLibopusProvider,
|
|
setLibopusProvider,
|
|
version
|
|
});
|
|
//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.ts", "../src/OggDemuxer.ts", "../src/OpusEncoder.ts", "../src/WebmBase.ts", "../src/WebmDemuxer.ts", "../src/version.ts"],
  "sourcesContent": ["export * from './OggDemuxer';\nexport * from './OpusEncoder';\nexport * from './WebmDemuxer';\n\nexport { version } from './version';", "// based on https://github.com/amishshah/prism-media/blob/4ef1d6f9f53042c085c1f68627e889003e248d77/src/opus/OggDemuxer.js\n\nimport { Transform, TransformCallback } from 'node:stream';\n\nconst OGG_PAGE_HEADER_SIZE = 26;\nconst STREAM_STRUCTURE_VERSION = 0;\n\nconst charCode = (x: string) => x.charCodeAt(0);\nconst OGGS_HEADER = Buffer.from([...'OggS'].map(charCode));\nconst OPUS_HEAD = Buffer.from([...'OpusHead'].map(charCode));\nconst OPUS_TAGS = Buffer.from([...'OpusTags'].map(charCode));\n\n/**\n * Demuxes an Ogg stream (containing Opus audio) to output an Opus stream.\n */\nexport class OggDemuxer extends Transform {\n  private _remainder: Buffer | null = null;\n  private _head: Buffer | null = null;\n  private _bitstream: number | null = null;\n\n  /**\n   * Creates a new OggOpus demuxer.\n   * @param {Object} [options] options that you would pass to a regular Transform stream.\n   * @memberof opus\n   */\n  public constructor(options = {}) {\n    super(Object.assign({ readableObjectMode: true }, options));\n    this._remainder = null;\n    this._head = null;\n    this._bitstream = null;\n  }\n\n  _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback) {\n    if (this._remainder) {\n      chunk = Buffer.concat([this._remainder, chunk]);\n      this._remainder = null;\n    }\n\n    try {\n      while (chunk) {\n        const result = this._readPage(chunk);\n        if (result) chunk = result;else\n        break;\n      }\n    } catch (error) {\n      done(error as Error);\n      return;\n    }\n\n    this._remainder = chunk;\n    done();\n  }\n\n  /**\n   * Reads a page from a buffer\n   * @private\n   * @param {Buffer} chunk the chunk containing the page\n   * @returns {boolean|Buffer} if a buffer, it will be a slice of the excess data of the original, otherwise it will be\n   * false and would indicate that there is not enough data to go ahead with reading this page.\n   */\n  _readPage(chunk: Buffer) {\n    if (chunk.length < OGG_PAGE_HEADER_SIZE) {\n      return false;\n    }\n    if (!chunk.subarray(0, 4).equals(OGGS_HEADER)) {\n      throw Error(`capture_pattern is not ${OGGS_HEADER}`);\n    }\n    if (chunk.readUInt8(4) !== STREAM_STRUCTURE_VERSION) {\n      throw Error(\n        `stream_structure_version is not ${STREAM_STRUCTURE_VERSION}`\n      );\n    }\n\n    if (chunk.length < 27) return false;\n    const pageSegments = chunk.readUInt8(26);\n    if (chunk.length < 27 + pageSegments) return false;\n    const table = chunk.subarray(27, 27 + pageSegments);\n    const bitstream = chunk.readUInt32BE(14);\n\n    const sizes: number[] = [];\n    let totalSize = 0;\n\n    for (let i = 0; i < pageSegments;) {\n      let size = 0,\n        x = 255;\n      while (x === 255) {\n        if (i >= table.length) return false;\n        x = table.readUInt8(i);\n        i++;\n        size += x;\n      }\n      sizes.push(size);\n      totalSize += size;\n    }\n\n    if (chunk.length < 27 + pageSegments + totalSize) return false;\n\n    let start = 27 + pageSegments;\n    for (const size of sizes) {\n      const segment = chunk.subarray(start, start + size);\n      const header = segment.subarray(0, 8);\n      if (this._head) {\n        if (header.equals(OPUS_TAGS)) this.emit('tags', segment);else\n        if (this._bitstream === bitstream) this.push(segment);\n      } else if (header.equals(OPUS_HEAD)) {\n        this.emit('head', segment);\n        this._head = segment;\n        this._bitstream = bitstream;\n      } else {\n        this.emit('unknownSegment', segment);\n      }\n      start += size;\n    }\n    return chunk.subarray(start);\n  }\n\n  _destroy(err: Error, cb: (error: Error | null) => void) {\n    this._cleanup();\n    return cb ? cb(err) : undefined;\n  }\n\n  _final(cb: TransformCallback) {\n    this._cleanup();\n    cb();\n  }\n\n  /**\n   * Cleans up the demuxer when it is no longer required.\n   * @private\n   */\n  _cleanup() {\n    this._remainder = null;\n    this._head = null;\n    this._bitstream = null;\n  }\n}", "// based on https://github.com/amishshah/prism-media/blob/4ef1d6f9f53042c085c1f68627e889003e248d77/src/opus/Opus.js\n\nimport { Transform, type TransformCallback } from 'node:stream';\n\nexport type IEncoder = {\n  new (rate: number, channels: number, application: number): {\n    encode(buffer: Buffer): Buffer;\n    encode(buffer: Buffer, frameSize: number): Buffer;\n    encode(buffer: Buffer, frameSize?: number): Buffer;\n    decode(buffer: Buffer): Buffer;\n    decode(buffer: Buffer, frameSize: number): Buffer;\n    decode(buffer: Buffer, frameSize?: number): Buffer;\n    applyEncoderCTL?(ctl: number, value: number): void;\n    encoderCTL?(ctl: number, value: number): void;\n    delete?(): void;\n  };\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Application?: any;\n};\n\ntype IMod = [\n  string,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (mod: any) => {\n    Encoder: IEncoder;\n  }];\n\n\nconst loadModule = (\nmodules: IMod[])\n: {\n  Encoder: IEncoder;\n  name: string;\n} => {\n  const errors: string[] = [];\n\n  for (const [name, fn] of modules) {\n    try {\n      return {\n        // eslint-disable-next-line @typescript-eslint/no-var-requires\n        ...fn(require(name)),\n        name\n      };\n    } catch (e) {\n      errors.push(`Failed to load ${name}: ${e}`);\n      continue;\n    }\n  }\n\n  throw new Error(\n    `Could not load opus module, tried ${\n    modules.length} different modules. Errors: ${\n    errors.join('\\n')}`\n  );\n};\n\nexport const CTL = {\n  BITRATE: 0xfa2,\n  FEC: 0xfac,\n  PLP: 0xfae\n} as const;\n\nconst OPUS_MOD_REGISTRY: IMod[] = [\n[\n'mediaplex',\n(mod) => {\n  if (!mod.OpusEncoder) throw new Error('Unsupported mediaplex version');\n  return { Encoder: mod.OpusEncoder };\n}],\n\n['@discordjs/opus', (opus) => ({ Encoder: opus.OpusEncoder })],\n['opusscript', (opus) => ({ Encoder: opus })],\n[\n'@evan/opus',\n(opus) => {\n  const { Encoder, Decoder } = opus as typeof import('@evan/opus');\n\n  class OpusEncoder {\n    private _encoder!: InstanceType<typeof Encoder> | null;\n    private _decoder!: InstanceType<typeof Decoder> | null;\n\n    public constructor(\n    private _rate: number,\n    private _channels: number,\n    private _application: number)\n    {}\n\n    private _ensureEncoder() {\n      if (this._encoder) return;\n      this._encoder = new Encoder({\n        channels: this._channels as 2,\n        sample_rate: this._rate as 48000,\n        application: (<const> {\n          2048: 'voip',\n          2049: 'audio',\n          2051: 'restricted_lowdelay'\n        })[this._application]\n      });\n    }\n\n    private _ensureDecoder() {\n      if (this._decoder) return;\n      this._decoder = new Decoder({\n        channels: this._channels as 2,\n        sample_rate: this._rate as 48000\n      });\n    }\n\n    public encode(buffer: Buffer) {\n      this._ensureEncoder();\n      return Buffer.from(this._encoder!.encode(buffer));\n    }\n\n    public decode(buffer: Buffer) {\n      this._ensureDecoder();\n      return Buffer.from(this._decoder!.decode(buffer));\n    }\n\n    public applyEncoderCTL(ctl: number, value: number) {\n      this._ensureEncoder();\n      this._encoder!.ctl(ctl, value);\n    }\n\n    public delete() {\n      this._encoder = null;\n      this._decoder = null;\n    }\n  }\n\n  return { Encoder: OpusEncoder };\n}],\n\n['node-opus', (opus) => ({ Encoder: opus.OpusEncoder })]];\n\n\nlet Opus: {Encoder?: IEncoder;name?: string;} = {};\n\n/**\n * Add a new Opus provider to the registry. This will be tried to load in order at runtime.\n * @param provider - The provider to add\n */\nexport const addLibopusProvider = (provider: IMod) => {\n  if (OPUS_MOD_REGISTRY.some(([, fn]) => fn === provider[1])) return;\n  OPUS_MOD_REGISTRY.push(provider);\n};\n\n/**\n * Remove an Opus provider from the registry.\n * @param name - The name of the provider to remove\n */\nexport const removeLibopusProvider = (name: string) => {\n  const index = OPUS_MOD_REGISTRY.findIndex((o) => o[0] === name);\n  if (index === -1) return false;\n  OPUS_MOD_REGISTRY.splice(index, 1);\n  return true;\n};\n\n/**\n * Set the Opus provider to use. This will override the automatic provider selection.\n * @param provider - The provider to use\n */\nexport const setLibopusProvider = (provider: IEncoder, name: string) => {\n  Opus = { Encoder: provider, name };\n};\n\nfunction loadOpus(refresh = false) {\n  if (Opus.Encoder && !refresh) return Opus;\n\n  Opus = loadModule(OPUS_MOD_REGISTRY);\n  return Opus;\n}\n\nconst charCode = (x: string) => x.charCodeAt(0);\nconst OPUS_HEAD = Buffer.from([...'OpusHead'].map(charCode));\nconst OPUS_TAGS = Buffer.from([...'OpusTags'].map(charCode));\n\nexport interface IOpusStreamInit {\n  frameSize: number;\n  channels: number;\n  rate: number;\n  application?: number;\n}\n\n// frame size = (channels * rate * frame_duration) / 1000\n\n/**\n * Takes a stream of Opus data and outputs a stream of PCM data, or the inverse.\n * **You shouldn't directly instantiate this class, see opus.Encoder and opus.Decoder instead!**\n * @memberof opus\n * @extends TransformStream\n * @protected\n */\nexport class OpusStream extends Transform {\n  public encoder: InstanceType<IEncoder> | null = null;\n  public _options: IOpusStreamInit;\n  public _required: number;\n  /**\n   * Creates a new Opus transformer.\n   * @private\n   * @memberof opus\n   * @param {Object} [options] options that you would pass to a regular Transform stream\n   */\n  constructor(options = {} as IOpusStreamInit) {\n    if (!loadOpus().Encoder) {\n      throw Error(\n        `Could not find an Opus module! Please install one of ${OPUS_MOD_REGISTRY.map(\n          (o) => o[0]\n        ).join(', ')}.`\n      );\n    }\n    super(Object.assign({ readableObjectMode: true }, options));\n\n    const lib = Opus as Required<typeof Opus>;\n\n    if (lib.name === 'opusscript') {\n      options.application = lib.Encoder.Application![options.application!];\n    }\n\n    this.encoder = new lib.Encoder(\n      options.rate,\n      options.channels,\n      options.application!\n    );\n\n    this._options = options;\n    this._required = this._options.frameSize * this._options.channels * 2;\n  }\n\n  _encode(buffer: Buffer) {\n    if (Opus.name === 'opusscript') {\n      return this.encoder!.encode(buffer, this._options.frameSize);\n    } else {\n      return this.encoder!.encode(buffer);\n    }\n  }\n\n  _decode(buffer: Buffer) {\n    if (Opus.name === 'opusscript') {\n      return this.encoder!.decode(buffer, this._options.frameSize);\n    } else {\n      return this.encoder!.decode(buffer);\n    }\n  }\n\n  /**\n   * Returns the Opus module being used - `mediaplex`, `opusscript`, `node-opus`, or `@discordjs/opus`.\n   * @type {string}\n   * @readonly\n   * @example\n   * console.log(`Using Opus module ${OpusEncoder.type}`);\n   */\n  static get type() {\n    return Opus.name;\n  }\n\n  /**\n   * Sets the bitrate of the stream.\n   * @param {number} bitrate the bitrate to use use, e.g. 48000\n   * @public\n   */\n  setBitrate(bitrate: number) {\n    (this.encoder!.applyEncoderCTL! || this.encoder!.encoderCTL).apply(\n      this.encoder!,\n      [CTL.BITRATE, Math.min(128e3, Math.max(16e3, bitrate))]\n    );\n  }\n\n  /**\n   * Enables or disables forward error correction.\n   * @param {boolean} enabled whether or not to enable FEC.\n   * @public\n   */\n  setFEC(enabled: boolean) {\n    (this.encoder!.applyEncoderCTL! || this.encoder!.encoderCTL).apply(\n      this.encoder!,\n      [CTL.FEC, enabled ? 1 : 0]\n    );\n  }\n\n  /**\n   * Sets the expected packet loss over network transmission.\n   * @param {number} [percentage] a percentage (represented between 0 and 1)\n   */\n  setPLP(percentage: number) {\n    (this.encoder!.applyEncoderCTL! || this.encoder!.encoderCTL).apply(\n      this.encoder!,\n      [CTL.PLP, Math.min(100, Math.max(0, percentage * 100))]\n    );\n  }\n\n  _final(cb: () => void) {\n    this._cleanup();\n    cb();\n  }\n\n  _destroy(err: Error | null, cb: (err: Error | null) => void) {\n    this._cleanup();\n    return cb ? cb(err) : undefined;\n  }\n\n  /**\n   * Cleans up the Opus stream when it is no longer needed\n   * @private\n   */\n  _cleanup() {\n    if (typeof this.encoder?.delete === 'function') this.encoder!.delete!();\n    this.encoder = null;\n  }\n}\n\n/**\n * An Opus encoder stream.\n *\n * Outputs opus packets in [object mode.](https://nodejs.org/api/stream.html#stream_object_mode)\n * @extends opus.OpusStream\n * @memberof opus\n * @example\n * const encoder = new prism.opus.Encoder({ frameSize: 960, channels: 2, rate: 48000 });\n * pcmAudio.pipe(encoder);\n * // encoder will now output Opus-encoded audio packets\n */\nexport class OpusEncoder extends OpusStream {\n  _buffer: Buffer = Buffer.allocUnsafe(0);\n\n  /**\n   * Creates a new Opus encoder stream.\n   * @memberof opus\n   * @param {Object} options options that you would pass to a regular OpusStream, plus a few more:\n   * @param {number} options.frameSize the frame size in bytes to use (e.g. 960 for stereo audio at 48KHz with a frame\n   * duration of 20ms)\n   * @param {number} options.channels the number of channels to use\n   * @param {number} options.rate the sampling rate in Hz\n   */\n  constructor(options = {} as IOpusStreamInit) {\n    super(options);\n  }\n\n  public _transform(\n  newChunk: Buffer,\n  encoding: BufferEncoding,\n  done: TransformCallback)\n  : void {\n    const chunk = Buffer.concat([this._buffer, newChunk]);\n\n    let i = 0;\n    while (chunk.length >= i + this._required) {\n      const pcm = chunk.slice(i, i + this._required);\n      let opus: Buffer | undefined;\n      try {\n        opus = this.encoder!.encode(pcm);\n      } catch (error) {\n        done(error as Error);\n        return;\n      }\n      this.push(opus);\n      i += this._required;\n    }\n\n    if (i > 0) this._buffer = chunk.slice(i);\n    done();\n  }\n\n  _destroy(err: Error, cb: (err: Error | null) => void) {\n    super._destroy(err, cb);\n    this._buffer = Buffer.allocUnsafe(0);\n  }\n}\n\n/**\n * An Opus decoder stream.\n *\n * Note that any stream you pipe into this must be in\n * [object mode](https://nodejs.org/api/stream.html#stream_object_mode) and should output Opus packets.\n * @extends opus.OpusStream\n * @memberof opus\n * @example\n * const decoder = new OpusDecoder({ frameSize: 960, channels: 2, rate: 48000 });\n * input.pipe(decoder);\n * // decoder will now output PCM audio\n */\nexport class OpusDecoder extends OpusStream {\n  _transform(\n  chunk: Buffer,\n  encoding: BufferEncoding,\n  done: (e?: Error | null, chunk?: Buffer) => void)\n  {\n    const signature = chunk.slice(0, 8);\n    if (chunk.length >= 8 && signature.equals(OPUS_HEAD)) {\n      this.emit('format', {\n        channels: this._options.channels,\n        sampleRate: this._options.rate,\n        bitDepth: 16,\n        float: false,\n        signed: true,\n        version: chunk.readUInt8(8),\n        preSkip: chunk.readUInt16LE(10),\n        gain: chunk.readUInt16LE(16)\n      });\n      return done();\n    }\n    if (chunk.length >= 8 && signature.equals(OPUS_TAGS)) {\n      this.emit('tags', chunk);\n      return done();\n    }\n    try {\n      this.push(this._decode(chunk));\n    } catch (e) {\n      return done(e as Error);\n    }\n    return done();\n  }\n}", "// based on https://github.com/amishshah/prism-media/blob/4ef1d6f9f53042c085c1f68627e889003e248d77/src/core/WebmBase.js\n\nimport { Transform, TransformCallback } from 'node:stream';\n\nexport class WebmBaseDemuxer extends Transform {\n  public static readonly TAGS = {\n    // value is true if the element has children\n    '1a45dfa3': true, // EBML\n    '18538067': true, // Segment\n    '1f43b675': true, // Cluster\n    '1654ae6b': true, // Tracks\n    ae: true, // TrackEntry\n    d7: false, // TrackNumber\n    '83': false, // TrackType\n    a3: false, // SimpleBlock\n    '63a2': false\n  };\n\n  public static readonly TOO_SHORT = Symbol('TOO_SHORT');\n\n  private _remainder: Buffer | null = null;\n  private _length = 0;\n  private _count = 0;\n  private _skipUntil: number | null = null;\n  private _track: {number: number;type: number;} | null = null;\n  private _incompleteTrack: {number?: number;type?: number;} = {};\n  private _ebmlFound = false;\n\n  /**\n   * Creates a new Webm demuxer.\n   * @param {Object} [options] options that you would pass to a regular Transform stream.\n   */\n  constructor(options = {}) {\n    super(Object.assign({ readableObjectMode: true }, options));\n    this._remainder = null;\n    this._length = 0;\n    this._count = 0;\n    this._skipUntil = null;\n    this._track = null;\n    this._incompleteTrack = {};\n    this._ebmlFound = false;\n  }\n\n  public _checkHead(data: Buffer) {\n    void data;\n  }\n\n  _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback) {\n    this._length += chunk.length;\n    if (this._remainder) {\n      chunk = Buffer.concat([this._remainder, chunk]);\n      this._remainder = null;\n    }\n    let offset = 0;\n    if (this._skipUntil && this._length > this._skipUntil) {\n      offset = this._skipUntil - this._count;\n      this._skipUntil = null;\n    } else if (this._skipUntil) {\n      this._count += chunk.length;\n      done();\n      return;\n    }\n\n    let result;\n    // @ts-ignore\n    while (result !== WebmBaseDemuxer.TOO_SHORT) {\n      try {\n        result = this._readTag(chunk, offset);\n      } catch (error) {\n        done(error as Error);\n        return;\n      }\n      if (result === WebmBaseDemuxer.TOO_SHORT) break;\n      if (result._skipUntil) {\n        this._skipUntil = result._skipUntil;\n        break;\n      }\n      if (result.offset) offset = result.offset;else\n      break;\n    }\n    this._count += offset;\n    this._remainder = chunk.subarray(offset);\n    done();\n    return;\n  }\n\n  /**\n   * Reads an EBML ID from a buffer.\n   * @private\n   * @param {Buffer} chunk the buffer to read from.\n   * @param {number} offset the offset in the buffer.\n   * @returns {Object|Symbol} contains an `id` property (buffer) and the new `offset` (number).\n   * Returns the TOO_SHORT symbol if the data wasn't big enough to facilitate the request.\n   */\n  _readEBMLId(chunk: Buffer, offset: number) {\n    const idLength = vintLength(chunk, offset);\n    if (idLength === WebmBaseDemuxer.TOO_SHORT)\n    return WebmBaseDemuxer.TOO_SHORT;\n    return {\n      id: chunk.subarray(offset, offset + idLength),\n      offset: offset + idLength\n    };\n  }\n\n  /**\n   * Reads a size variable-integer to calculate the length of the data of a tag.\n   * @private\n   * @param {Buffer} chunk the buffer to read from.\n   * @param {number} offset the offset in the buffer.\n   * @returns {Object|Symbol} contains property `offset` (number), `dataLength` (number) and `sizeLength` (number).\n   * Returns the TOO_SHORT symbol if the data wasn't big enough to facilitate the request.\n   */\n  _readTagDataSize(chunk: Buffer, offset: number) {\n    const sizeLength = vintLength(chunk, offset);\n    if (sizeLength === WebmBaseDemuxer.TOO_SHORT)\n    return WebmBaseDemuxer.TOO_SHORT;\n    const dataLength = expandVint(chunk, offset, offset + sizeLength);\n    return { offset: offset + sizeLength, dataLength, sizeLength };\n  }\n\n  /**\n   * Takes a buffer and attempts to read and process a tag.\n   * @private\n   * @param {Buffer} chunk the buffer to read from.\n   * @param {number} offset the offset in the buffer.\n   * @returns {Object|Symbol} contains the new `offset` (number) and optionally the `_skipUntil` property,\n   * indicating that the stream should ignore any data until a certain length is reached.\n   * Returns the TOO_SHORT symbol if the data wasn't big enough to facilitate the request.\n   */\n  _readTag(chunk: Buffer, offset: number) {\n    const idData = this._readEBMLId(chunk, offset);\n    if (idData === WebmBaseDemuxer.TOO_SHORT) return WebmBaseDemuxer.TOO_SHORT;\n    const ebmlID = idData.id.toString('hex');\n    if (!this._ebmlFound) {\n      if (ebmlID === '1a45dfa3') this._ebmlFound = true;else\n      throw Error('Did not find the EBML tag at the start of the stream');\n    }\n    offset = idData.offset;\n    const sizeData = this._readTagDataSize(chunk, offset);\n    if (sizeData === WebmBaseDemuxer.TOO_SHORT)\n    return WebmBaseDemuxer.TOO_SHORT;\n    const { dataLength } = sizeData;\n    offset = sizeData.offset;\n    // If this tag isn't useful, tell the stream to stop processing data until the tag ends\n    if (\n    typeof WebmBaseDemuxer.TAGS[\n    ebmlID as keyof (typeof WebmBaseDemuxer)['TAGS']] ===\n    'undefined')\n    {\n      if (chunk.length > offset + (dataLength as number)) {\n        return { offset: offset + (dataLength as number) };\n      }\n      return {\n        offset,\n        _skipUntil: this._count + (offset as number) + (dataLength as number)\n      };\n    }\n\n    const tagHasChildren =\n    WebmBaseDemuxer.TAGS[ebmlID as keyof (typeof WebmBaseDemuxer)['TAGS']];\n    if (tagHasChildren) {\n      return { offset };\n    }\n\n    if ((offset as number) + (dataLength as number) > chunk.length)\n    return WebmBaseDemuxer.TOO_SHORT;\n    const data = chunk.subarray(\n      offset,\n      (offset as number) + (dataLength as number)\n    );\n    if (!this._track) {\n      if (ebmlID === 'ae') this._incompleteTrack = {};\n      if (ebmlID === 'd7') this._incompleteTrack.number = data[0];\n      if (ebmlID === '83') this._incompleteTrack.type = data[0];\n      if (\n      this._incompleteTrack.type === 2 &&\n      typeof this._incompleteTrack.number !== 'undefined')\n      {\n        // @ts-ignore\n        this._track = this._incompleteTrack;\n      }\n    }\n    if (ebmlID === '63a2') {\n      this._checkHead(data);\n      this.emit('head', data);\n    } else if (ebmlID === 'a3') {\n      if (!this._track) throw Error('No audio track in this webm!');\n      if ((data[0] & 0xf) === this._track.number) {\n        this.push(data.subarray(4));\n      }\n    }\n    return { offset: (offset as number) + (dataLength as number) };\n  }\n\n  _destroy(err: Error, cb: (error: Error | null) => void) {\n    this._cleanup();\n    return cb ? cb(err) : undefined;\n  }\n\n  _final(cb: TransformCallback) {\n    this._cleanup();\n    cb();\n  }\n\n  /**\n   * Cleans up the demuxer when it is no longer required.\n   * @private\n   */\n  _cleanup() {\n    this._remainder = null;\n    this._incompleteTrack = {};\n  }\n}\n\nfunction vintLength(buffer: Buffer, index: number) {\n  if (index < 0 || index > buffer.length - 1) {\n    return WebmBaseDemuxer.TOO_SHORT;\n  }\n  let i = 0;\n  for (; i < 8; i++) if (1 << 7 - i & buffer[index]) break;\n  i++;\n  if (index + i > buffer.length) {\n    return WebmBaseDemuxer.TOO_SHORT;\n  }\n  return i;\n}\n\nfunction expandVint(buffer: Buffer, start: number, end: number) {\n  const length = vintLength(buffer, start);\n  if (end > buffer.length || length === WebmBaseDemuxer.TOO_SHORT)\n  return WebmBaseDemuxer.TOO_SHORT;\n  // @ts-ignore\n  const mask = (1 << 8 - length) - 1;\n  let value = buffer[start] & mask;\n  for (let i = start + 1; i < end; i++) {\n    value = (value << 8) + buffer[i];\n  }\n  return value;\n}", "// based on https://github.com/amishshah/prism-media/blob/4ef1d6f9f53042c085c1f68627e889003e248d77/src/opus/WebmDemuxer.js\n\nimport { WebmBaseDemuxer } from './WebmBase';\n\nconst OPUS_HEAD = Buffer.from([...'OpusHead'].map((x) => x.charCodeAt(0)));\n\n/**\n * Demuxes a Webm stream (containing Opus audio) to output an Opus stream.\n * @example\n * const fs = require('fs');\n * const file = fs.createReadStream('./audio.webm');\n * const demuxer = new WebmDemuxer();\n * const opus = file.pipe(demuxer);\n * // opus is now a ReadableStream in object mode outputting Opus packets\n */\nexport class WebmDemuxer extends WebmBaseDemuxer {\n  _checkHead(data: Buffer) {\n    if (!data.subarray(0, 8).equals(OPUS_HEAD)) {\n      throw Error('Audio codec is not Opus!');\n    }\n  }\n}", "\n\n\n\n\n\nexport const version = /* @__MACRO__ getVersion */\"7.2.0\";"],
  "mappings": "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",
  "names": ["import_node_stream", "_OpusEncoder", "OpusEncoder", "charCode", "OPUS_HEAD", "OPUS_TAGS", "import_node_stream", "OPUS_HEAD"]
}

|