rockcord 4.0.0-dev.4

package/src/client/voice/player/processing/AnnexBNalSplitter.js

@@ -0,0 +1,267 @@
+'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 { Buffer } = require('buffer');
+const { Transform } = require('stream');
+
+const H264NalUnitTypes = {
+  Unspecified: 0,
+  CodedSliceNonIDR: 1,
+  CodedSlicePartitionA: 2,
+  CodedSlicePartitionB: 3,
+  CodedSlicePartitionC: 4,
+  CodedSliceIdr: 5,
+  SEI: 6,
+  SPS: 7,
+  PPS: 8,
+  AccessUnitDelimiter: 9,
+  EndOfSequence: 10,
+  EndOfStream: 11,
+  FillerData: 12,
+  SEIExtenstion: 13,
+  PrefixNalUnit: 14,
+  SubsetSPS: 15,
+};
+
+const H265NalUnitTypes = {
+  TRAIL_N: 0,
+  TRAIL_R: 1,
+  TSA_N: 2,
+  TSA_R: 3,
+  STSA_N: 4,
+  STSA_R: 5,
+  RADL_N: 6,
+  RADL_R: 7,
+  RASL_N: 8,
+  RASL_R: 9,
+  RSV_VCL_N10: 10,
+  RSV_VCL_R11: 11,
+  RSV_VCL_N12: 12,
+  RSV_VCL_R13: 13,
+  RSV_VCL_N14: 14,
+  RSV_VCL_R15: 15,
+  BLA_W_LP: 16,
+  BLA_W_RADL: 17,
+  BLA_N_LP: 18,
+  IDR_W_RADL: 19,
+  IDR_N_LP: 20,
+  CRA_NUT: 21,
+  RSV_IRAP_VCL22: 22,
+  RSV_IRAP_VCL23: 23,
+  RSV_VCL24: 24,
+  RSV_VCL25: 25,
+  RSV_VCL26: 26,
+  RSV_VCL27: 27,
+  RSV_VCL28: 28,
+  RSV_VCL29: 29,
+  RSV_VCL30: 30,
+  RSV_VCL31: 31,
+  VPS_NUT: 32,
+  SPS_NUT: 33,
+  PPS_NUT: 34,
+  AUD_NUT: 35,
+  EOS_NUT: 36,
+  EOB_NUT: 37,
+  FD_NUT: 38,
+  PREFIX_SEI_NUT: 39,
+  SUFFIX_SEI_NUT: 40,
+  RSV_NVCL41: 41,
+  RSV_NVCL42: 42,
+  RSV_NVCL43: 43,
+  RSV_NVCL44: 44,
+  RSV_NVCL45: 45,
+  RSV_NVCL46: 46,
+  RSV_NVCL47: 47,
+  UNSPEC48: 48,
+  UNSPEC49: 49,
+  UNSPEC50: 50,
+  UNSPEC51: 51,
+  UNSPEC52: 52,
+  UNSPEC53: 53,
+  UNSPEC54: 54,
+  UNSPEC55: 55,
+  UNSPEC56: 56,
+  UNSPEC57: 57,
+  UNSPEC58: 58,
+  UNSPEC59: 59,
+  UNSPEC60: 60,
+  UNSPEC61: 61,
+  UNSPEC62: 62,
+  UNSPEC63: 63,
+};
+
+const H264Helpers = {
+  getUnitType(frame) {
+    return frame[0] & 0x1f;
+  },
+  splitHeader(frame) {
+    return [frame.subarray(0, 1), frame.subarray(1)];
+  },
+  isAUD(unitType) {
+    return unitType === H264NalUnitTypes.AccessUnitDelimiter;
+  },
+};
+
+const H265Helpers = {
+  getUnitType(frame) {
+    return (frame[0] >> 1) & 0x3f;
+  },
+  splitHeader(frame) {
+    return [frame.subarray(0, 2), frame.subarray(2)];
+  },
+  isAUD(unitType) {
+    return unitType === H265NalUnitTypes.AUD_NUT;
+  },
+};
+
+const emptyBuffer = Buffer.allocUnsafe(0);
+const epbPrefix = Buffer.from([0x00, 0x00, 0x03]);
+const nalSuffix = Buffer.from([0x00, 0x00, 0x01]);
+
+class AnnexBNalSplitter extends Transform {
+  constructor(nalFunctions) {
+    super();
+    this._buffer = emptyBuffer;
+    this._started = false;
+    this._accessUnit = [];
+    this._nalFunctions = nalFunctions;
+  }
+
+  rbsp(data) {
+    const newData = Buffer.allocUnsafe(data.length);
+    let newLength = 0;
+
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const epbsPos = data.indexOf(epbPrefix);
+      if (epbsPos === -1) {
+        data.copy(newData, newLength);
+        newLength += data.length;
+        break;
+      }
+      const copyRange = data[epbsPos + 3] <= 0x03 ? epbsPos + 2 : epbsPos + 3;
+      data.copy(newData, newLength, 0, copyRange);
+      newLength += copyRange;
+      data = data.subarray(epbsPos + 3);
+    }
+
+    return newData.subarray(0, newLength);
+  }
+
+  findNalStart(buf) {
+    const pos = buf.indexOf(nalSuffix);
+    if (pos === -1) return null;
+    return pos > 0 && buf[pos - 1] === 0 ? { index: pos - 1, length: 4 } : { index: pos, length: 3 };
+  }
+
+  processFrame(frame) {
+    if (frame.length === 0) return;
+
+    const unitType = this._nalFunctions.getUnitType(frame);
+    if (this._nalFunctions.isAUD(unitType) && this._accessUnit.length > 0) {
+      const sizeOfAccessUnit = this._accessUnit.reduce((acc, nalu) => acc + nalu.length + 4, 0);
+      const accessUnitBuf = Buffer.allocUnsafe(sizeOfAccessUnit);
+
+      let offset = 0;
+      this._accessUnit.forEach(nalu => {
+        accessUnitBuf.writeUint32BE(nalu.length, offset);
+        offset += 4;
+        nalu.copy(accessUnitBuf, offset);
+        offset += nalu.length;
+      });
+
+      this.push(accessUnitBuf);
+      this._accessUnit = [];
+    }
+    if (!this._nalFunctions.isAUD(unitType)) {
+      this._accessUnit.push(this.removeEpbs(frame, unitType));
+    }
+  }
+
+  _transform(chunk, encoding, callback) {
+    chunk = Buffer.concat([this._buffer, chunk]);
+    let nalStart = this.findNalStart(chunk);
+    if (!this._started) {
+      if (!nalStart) {
+        this._buffer = chunk.subarray(Math.max(0, chunk.length - 3));
+        callback();
+        return;
+      }
+      chunk = chunk.subarray(nalStart.index + nalStart.length);
+      this._started = true;
+    }
+
+    while ((nalStart = this.findNalStart(chunk))) {
+      const frame = chunk.subarray(0, nalStart.index);
+      this.processFrame(frame);
+      chunk = chunk.subarray(nalStart.index + nalStart.length);
+    }
+    this._buffer = chunk;
+    callback();
+  }
+
+  _flush(callback) {
+    if (this._started) this.processFrame(this._buffer);
+    if (this._accessUnit.length) {
+      this.push(
+        Buffer.concat(
+          this._accessUnit.flatMap(nalu => {
+            const length = Buffer.alloc(4);
+            length.writeUInt32BE(nalu.length);
+            return [length, nalu];
+          }),
+        ),
+      );
+    }
+    this._buffer = emptyBuffer;
+    this._accessUnit = [];
+    callback();
+  }
+}
+
+class H264NalSplitter extends AnnexBNalSplitter {
+  constructor() {
+    super(H264Helpers);
+  }
+
+  removeEpbs(frame) {
+    // Preserve encoded NAL bytes. Removing emulation prevention inserts false start codes
+    // and corrupts both DAVE whole-frame processing and decoder input.
+    return frame;
+  }
+}
+
+class H265NalSplitter extends AnnexBNalSplitter {
+  constructor() {
+    super(H265Helpers);
+  }
+
+  removeEpbs(frame) {
+    return frame; // No specific processing for H265
+  }
+}
+
+module.exports = {
+  H264NalUnitTypes,
+  H265NalUnitTypes,
+  H264Helpers,
+  H265Helpers,
+  H264NalSplitter,
+  H265NalSplitter,
+};

package/src/client/voice/player/processing/IvfSplitter.js

@@ -0,0 +1,106 @@
+'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 { Buffer } = require('buffer');
+const { Transform } = require('stream');
+
+class IvfTransformer extends Transform {
+  constructor(options) {
+    super(options);
+    this.headerSize = 32;
+    this.frameHeaderSize = 12;
+
+    this.header = null;
+    this.buf = null;
+    this.retFullFrame = options && options.fullframe ? options.fullframe : false;
+  }
+
+  _parseHeader(header) {
+    this.header = {
+      signature: header.subarray(0, 4).toString(),
+      version: header.readUIntLE(4, 2),
+      headerLength: header.readUIntLE(6, 2),
+      codec: header.subarray(8, 12).toString(),
+      width: header.readUIntLE(12, 2),
+      height: header.readUIntLE(14, 2),
+      timeDenominator: header.readUIntLE(16, 4),
+      timeNumerator: header.readUIntLE(20, 4),
+      frameCount: header.readUIntLE(24, 4),
+    };
+  }
+
+  _getFrameSize(buf) {
+    return buf.readUIntLE(0, 4);
+  }
+
+  _parseFrame(frame) {
+    const size = this._getFrameSize(frame);
+
+    if (this.retFullFrame) return this.push(frame.subarray(0, 12 + size));
+
+    const out = {
+      size: size,
+      timestamp: frame.readBigUInt64LE(4),
+      data: frame.subarray(12, 12 + size),
+    };
+
+    return this.push(out.data);
+  }
+
+  _appendChunkToBuf(chunk) {
+    if (this.buf) this.buf = Buffer.concat([this.buf, chunk]);
+    else this.buf = chunk;
+  }
+
+  _updateBufLen(size) {
+    if (this.buf.length > size) this.buf = this.buf.subarray(size, this.buf.length);
+    else this.buf = null;
+  }
+
+  _transform(chunk, encoding, callback) {
+    this._appendChunkToBuf(chunk);
+
+    if (!this.header) {
+      if (this.buf.length >= this.headerSize) {
+        this._parseHeader(this.buf.subarray(0, this.headerSize));
+        this._updateBufLen(this.headerSize);
+      } else {
+        callback();
+        return;
+      }
+    }
+
+    while (this.buf && this.buf.length >= this.frameHeaderSize) {
+      const size = this._getFrameSize(this.buf) + this.frameHeaderSize;
+
+      if (this.buf.length >= size) {
+        this._parseFrame(this.buf.subarray(0, size));
+        this._updateBufLen(size);
+      } else {
+        break;
+      }
+    }
+
+    callback();
+  }
+}
+
+module.exports = {
+  IvfTransformer,
+};

package/src/client/voice/player/processing/PCMInsertSilence.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { Buffer } = require('node:buffer');
+const { Transform } = require('node:stream');
+
+class PCMInsertSilence extends Transform {
+  constructor(options) {
+    super(options);
+    // 48Khz, 2 channels, 16-bit (2 bytes per channel)
+    this.sampleRate = 48000;
+    this.channels = 2;
+    // 4 bytes per frame (2 channels * 2 bytes)
+    this.bytesPerFrame = this.channels * 2;
+    this.lastChunkTime = Date.now();
+    this.silenceThresholdMs = 50;
+  }
+
+  _transform(chunk, encoding, callback) {
+    const now = Date.now();
+    const gap = now - this.lastChunkTime;
+
+    if (gap >= this.silenceThresholdMs) {
+      const missingFrames = Math.floor((gap / 1000) * this.sampleRate);
+      const silenceBuffer = Buffer.alloc(missingFrames * this.bytesPerFrame, 0);
+      this.push(silenceBuffer);
+    }
+
+    this.lastChunkTime = now;
+
+    this.push(chunk);
+    callback();
+  }
+}
+
+module.exports = {
+  PCMInsertSilence,
+};