@m7mdxzx1/discord-video-strem 0.0.1

package/dist/client/voice/VoiceOpCodes.d.ts

@@ -0,0 +1,21 @@
+export declare enum VoiceOpCodes {
+    IDENTIFY = 0,
+    SELECT_PROTOCOL = 1,
+    READY = 2,
+    HEARTBEAT = 3,
+    SELECT_PROTOCOL_ACK = 4,
+    SPEAKING = 5,
+    HEARTBEAT_ACK = 6,
+    RESUME = 7,
+    HELLO = 8,
+    RESUMED = 9,
+    VIDEO = 12,
+    CLIENT_DISCONNECT = 13,
+    SESSION_UPDATE = 14,
+    MEDIA_SINK_WANTS = 15,
+    VOICE_BACKEND_VERSION = 16,
+    CHANNEL_OPTIONS_UPDATE = 17,
+    FLAGS = 18,
+    SPEED_TEST = 19,
+    PLATFORM = 20
+}

package/dist/client/voice/VoiceOpCodes.js

@@ -0,0 +1,22 @@
+export var VoiceOpCodes;
+(function (VoiceOpCodes) {
+    VoiceOpCodes[VoiceOpCodes["IDENTIFY"] = 0] = "IDENTIFY";
+    VoiceOpCodes[VoiceOpCodes["SELECT_PROTOCOL"] = 1] = "SELECT_PROTOCOL";
+    VoiceOpCodes[VoiceOpCodes["READY"] = 2] = "READY";
+    VoiceOpCodes[VoiceOpCodes["HEARTBEAT"] = 3] = "HEARTBEAT";
+    VoiceOpCodes[VoiceOpCodes["SELECT_PROTOCOL_ACK"] = 4] = "SELECT_PROTOCOL_ACK";
+    VoiceOpCodes[VoiceOpCodes["SPEAKING"] = 5] = "SPEAKING";
+    VoiceOpCodes[VoiceOpCodes["HEARTBEAT_ACK"] = 6] = "HEARTBEAT_ACK";
+    VoiceOpCodes[VoiceOpCodes["RESUME"] = 7] = "RESUME";
+    VoiceOpCodes[VoiceOpCodes["HELLO"] = 8] = "HELLO";
+    VoiceOpCodes[VoiceOpCodes["RESUMED"] = 9] = "RESUMED";
+    VoiceOpCodes[VoiceOpCodes["VIDEO"] = 12] = "VIDEO";
+    VoiceOpCodes[VoiceOpCodes["CLIENT_DISCONNECT"] = 13] = "CLIENT_DISCONNECT";
+    VoiceOpCodes[VoiceOpCodes["SESSION_UPDATE"] = 14] = "SESSION_UPDATE";
+    VoiceOpCodes[VoiceOpCodes["MEDIA_SINK_WANTS"] = 15] = "MEDIA_SINK_WANTS";
+    VoiceOpCodes[VoiceOpCodes["VOICE_BACKEND_VERSION"] = 16] = "VOICE_BACKEND_VERSION";
+    VoiceOpCodes[VoiceOpCodes["CHANNEL_OPTIONS_UPDATE"] = 17] = "CHANNEL_OPTIONS_UPDATE";
+    VoiceOpCodes[VoiceOpCodes["FLAGS"] = 18] = "FLAGS";
+    VoiceOpCodes[VoiceOpCodes["SPEED_TEST"] = 19] = "SPEED_TEST";
+    VoiceOpCodes[VoiceOpCodes["PLATFORM"] = 20] = "PLATFORM";
+})(VoiceOpCodes || (VoiceOpCodes = {}));

package/dist/client/voice/index.d.ts

@@ -0,0 +1,5 @@
+export * from './VoiceConnection.js';
+export * from './VoiceOpCodes.js';
+export * from './MediaUdp.js';
+export * from './StreamConnection.js';
+export * from './BaseMediaConnection.js';

package/dist/client/voice/index.js

@@ -0,0 +1,5 @@
+export * from './VoiceConnection.js';
+export * from './VoiceOpCodes.js';
+export * from './MediaUdp.js';
+export * from './StreamConnection.js';
+export * from './BaseMediaConnection.js';

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client/index.js';
+export * from './media/index.js';
+export * from './media/newApi.js';
+export * as NewApi from './media/newApi.js';
+export * as Utils from './utils.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './client/index.js';
+export * from './media/index.js';
+export * from './media/newApi.js';
+export * as NewApi from './media/newApi.js';
+export * as Utils from './utils.js';

package/dist/media/AudioStream.d.ts

@@ -0,0 +1,25 @@
+import type { MediaUdp } from "../client/voice/MediaUdp.js";
+import { BaseMediaStream } from "./BaseMediaStream.js";
+export declare class AudioStream extends BaseMediaStream {
+    udp: MediaUdp;
+    private _isMuted;
+    private _volume;
+    private _opusEncoder;
+    constructor(udp: MediaUdp, noSleep?: boolean, initialMuted?: boolean);
+    /**
+     * Mutes the audio stream. No audio frames will be sent.
+     */
+    mute(): void;
+    /**
+     * Unmutes the audio stream. Audio frames will resume sending.
+     */
+    unmute(): void;
+    /**
+     * Checks if the audio stream is currently muted.
+     * @returns True if muted, false otherwise.
+     */
+    isMuted(): boolean;
+    setVolume(volume: number): void;
+    getVolume(): number;
+    protected _sendFrame(frame: Buffer, frametime: number): Promise<void>;
+}

package/dist/media/AudioStream.js

@@ -0,0 +1,63 @@
+import OpusScript from "opusscript";
+import { BaseMediaStream } from "./BaseMediaStream.js";
+export class AudioStream extends BaseMediaStream {
+    constructor(udp, noSleep = false, initialMuted = false) {
+        super("audio", noSleep);
+        this._volume = 1.0;
+        this.udp = udp;
+        this._isMuted = initialMuted; // Initialize mute state
+        this._opusEncoder = new OpusScript(48000, 2, 2048);
+    }
+    /**
+     * Mutes the audio stream. No audio frames will be sent.
+     */
+    mute() {
+        this._isMuted = true;
+    }
+    /**
+     * Unmutes the audio stream. Audio frames will resume sending.
+     */
+    unmute() {
+        this._isMuted = false;
+    }
+    /**
+     * Checks if the audio stream is currently muted.
+     * @returns True if muted, false otherwise.
+     */
+    isMuted() {
+        return this._isMuted;
+    }
+    setVolume(volume) {
+        if (volume < 0) {
+            this._volume = 0;
+        }
+        else {
+            this._volume = Math.min(volume, 2.0);
+        }
+    }
+    getVolume() {
+        return this._volume;
+    }
+    async _sendFrame(frame, frametime) {
+        if (this._isMuted) {
+            return;
+        }
+        let processedFrame = frame;
+        if (this._volume !== 1.0) {
+            try {
+                const pcmData = this._opusEncoder.decode(frame);
+                for (let i = 0; i < pcmData.length; i += 2) {
+                    const sample = pcmData.readInt16LE(i);
+                    const newSample = Math.max(-32768, Math.min(32767, Math.floor(sample * this._volume)));
+                    pcmData.writeInt16LE(newSample, i);
+                }
+                processedFrame = this._opusEncoder.encode(pcmData, 960);
+            }
+            catch (error) {
+                console.error("[AudioStream] Error processing audio frame:", error);
+                processedFrame = frame;
+            }
+        }
+        await this.udp.sendAudioFrame(processedFrame, frametime);
+    }
+}

package/dist/media/BaseMediaStream.d.ts

@@ -0,0 +1,31 @@
+import { Writable } from "node:stream";
+import type { Packet } from "@lng2004/libav.js-variant-webcodecs-avf-with-decoders";
+export declare class BaseMediaStream extends Writable {
+    private _pts?;
+    private _syncTolerance;
+    private _loggerSend;
+    private _loggerSync;
+    private _loggerSleep;
+    private _noSleep;
+    private _startTime?;
+    private _startPts?;
+    private _sync;
+    private _syncStream?;
+    constructor(type: string, noSleep?: boolean);
+    get sync(): boolean;
+    set sync(val: boolean);
+    get syncStream(): BaseMediaStream | undefined;
+    set syncStream(stream: BaseMediaStream | undefined);
+    get noSleep(): boolean;
+    set noSleep(val: boolean);
+    get pts(): number | undefined;
+    get syncTolerance(): number;
+    set syncTolerance(n: number);
+    protected _sendFrame(frame: Buffer, frametime: number): Promise<void>;
+    private ptsDelta;
+    private isAhead;
+    private isBehind;
+    private resetTimingCompensation;
+    _write(frame: Packet, _: BufferEncoding, callback: (error?: Error | null) => void): Promise<void>;
+    _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
+}

package/dist/media/BaseMediaStream.js

@@ -0,0 +1,145 @@
+import { Log } from "debug-level";
+import { setTimeout } from "node:timers/promises";
+import { Writable } from "node:stream";
+import { combineLoHi } from "./utils.js";
+export class BaseMediaStream extends Writable {
+    constructor(type, noSleep = false) {
+        super({ objectMode: true, highWaterMark: 0 });
+        this._syncTolerance = 20;
+        this._sync = true;
+        this._loggerSend = new Log(`stream:${type}:send`);
+        this._loggerSync = new Log(`stream:${type}:sync`);
+        this._loggerSleep = new Log(`stream:${type}:sleep`);
+        this._noSleep = noSleep;
+    }
+    get sync() {
+        return this._sync;
+    }
+    set sync(val) {
+        this._sync = val;
+        if (val)
+            this._loggerSync.debug("Sync enabled");
+        else
+            this._loggerSync.debug("Sync disabled");
+    }
+    get syncStream() {
+        return this._syncStream;
+    }
+    set syncStream(stream) {
+        if (stream === this)
+            throw new Error("A stream cannot sync with itself");
+        this._syncStream = stream;
+    }
+    get noSleep() {
+        return this._noSleep;
+    }
+    set noSleep(val) {
+        this._noSleep = val;
+        if (!val)
+            this.resetTimingCompensation();
+    }
+    get pts() {
+        return this._pts;
+    }
+    get syncTolerance() {
+        return this._syncTolerance;
+    }
+    set syncTolerance(n) {
+        if (n < 0)
+            return;
+        this._syncTolerance = n;
+    }
+    async _sendFrame(frame, frametime) {
+        throw new Error("Not implemented");
+    }
+    ptsDelta() {
+        if (this.pts !== undefined && this.syncStream?.pts !== undefined)
+            return this.pts - this.syncStream.pts;
+        return undefined;
+    }
+    isAhead() {
+        const delta = this.ptsDelta();
+        return this.syncStream?.writableEnded === false && delta !== undefined && delta > this.syncTolerance;
+    }
+    isBehind() {
+        const delta = this.ptsDelta();
+        return this.syncStream?.writableEnded === false && delta !== undefined && delta < -this.syncTolerance;
+    }
+    resetTimingCompensation() {
+        this._startTime = this._startPts = undefined;
+    }
+    async _write(frame, _, callback) {
+        const { data, ptshi, pts, durationhi, duration, time_base_num, time_base_den } = frame;
+        // biome-ignore lint/style/noNonNullAssertion: this will never happen with our media stream
+        const frametime = combineLoHi(durationhi, duration) / time_base_den * time_base_num * 1000;
+        const start_sendFrame = performance.now();
+        await this._sendFrame(Buffer.from(data), frametime);
+        const end_sendFrame = performance.now();
+        // biome-ignore lint/style/noNonNullAssertion: this will never happen with our media stream
+        this._pts = combineLoHi(ptshi, pts) / time_base_den * time_base_num * 1000;
+        this.emit("pts", this._pts);
+        const sendTime = end_sendFrame - start_sendFrame;
+        const ratio = sendTime / frametime;
+        this._loggerSend.debug({
+            stats: {
+                pts: this._pts,
+                frame_size: data.length,
+                duration: sendTime,
+                frametime
+            }
+        }, `Frame sent in ${sendTime.toFixed(2)}ms (${(ratio * 100).toFixed(2)}% frametime)`);
+        if (ratio > 1) {
+            this._loggerSend.warn({
+                frame_size: data.length,
+                duration: sendTime,
+                frametime
+            }, `Frame takes too long to send (${(ratio * 100).toFixed(2)}% frametime)`);
+        }
+        this._startTime ??= start_sendFrame;
+        this._startPts ??= this._pts;
+        const sleep = Math.max(0, this._pts - this._startPts + frametime - (end_sendFrame - this._startTime));
+        if (this._noSleep || sleep === 0) {
+            callback(null);
+        }
+        else if (this.sync && this.isBehind()) {
+            this._loggerSync.debug({
+                stats: {
+                    pts: this.pts,
+                    pts_other: this.syncStream?.pts
+                }
+            }, "Stream is behind. Not sleeping for this frame");
+            this.resetTimingCompensation();
+            callback(null);
+        }
+        else if (this.sync && this.isAhead()) {
+            do {
+                this._loggerSync.debug({
+                    stats: {
+                        pts: this.pts,
+                        pts_other: this.syncStream?.pts,
+                        frametime
+                    }
+                }, `Stream is ahead. Waiting for ${frametime}ms`);
+                await setTimeout(frametime);
+            } while (this.sync && this.isAhead());
+            this.resetTimingCompensation();
+            callback(null);
+        }
+        else {
+            this._loggerSleep.debug({
+                stats: {
+                    pts: this._pts,
+                    startPts: this._startPts,
+                    time: end_sendFrame,
+                    startTime: this._startTime,
+                    frametime
+                }
+            }, `Sleeping for ${sleep}ms`);
+            setTimeout(sleep).then(() => callback(null));
+        }
+    }
+    _destroy(error, callback) {
+        super._destroy(error, callback);
+        this.syncStream = undefined;
+    }
+}