@m7mdxzx1/discord-video-strem 0.0.1 → 0.0.2

package/dist/media/newApi.js

@@ -11,6 +11,7 @@ import { isFiniteNonZero } from '../utils.js';
 import { AVCodecID } from './LibavCodecId.js';
 import { createDecoder } from './LibavDecoder.js';
 import LibAV from '@lng2004/libav.js-variant-webcodecs-avf-with-decoders';
+
 export function prepareStream(input, options = {}, cancelSignal) {
     cancelSignal?.throwIfAborted();
     const defaultOptions = {
@@ -34,6 +35,7 @@ export function prepareStream(input, options = {}, cancelSignal) {
         seekTime: 0,
         customFfmpegFlags: []
     };
+
     function mergeOptions(opts) {
         return {
             noTranscoding: opts.noTranscoding ?? defaultOptions.noTranscoding,
@@ -63,35 +65,45 @@ export function prepareStream(input, options = {}, cancelSignal) {
             customFfmpegFlags: opts.customFfmpegFlags ?? defaultOptions.customFfmpegFlags
         };
     }
+
     const mergedOptions = mergeOptions(options);
+
     let isHttpUrl = false;
     let isHls = false;
     if (typeof input === "string") {
         isHttpUrl = input.startsWith('http') || input.startsWith('https');
         isHls = input.includes('m3u');
     }
+
     const output = new PassThrough();
+
     // command creation
     const command = ffmpeg();
+
     // Seeking if applicable (Must be applied before input for fast seek)
     if (mergedOptions.seekTime && mergedOptions.seekTime > 0) {
         command.inputOption('-ss', String(mergedOptions.seekTime));
     }
+
     command.input(input)
         .addOption('-loglevel', 'info');
+
     // input options
     const { hardwareAcceleratedDecoding, minimizeLatency, customHeaders } = mergedOptions;
+
     if (hardwareAcceleratedDecoding)
         command.inputOption('-hwaccel', 'auto');
+
     if (minimizeLatency) {
         command.addOptions([
             '-fflags nobuffer',
             '-analyzeduration 0'
         ]);
     }
+
     if (isHttpUrl) {
-        command.inputOption('-headers', Object.entries(customHeaders).map(([k, v]) => `${k}: ${v}`).join("\\r\\n") // Corrected escape sequence
-        );
+        command.inputOption('-headers', Object.entries(customHeaders).map(([k, v]) => `${k}: ${v}`).join("\r\n"));
+
         if (!isHls) {
             command.inputOptions([
                 '-reconnect 1',
@@ -101,13 +113,17 @@ export function prepareStream(input, options = {}, cancelSignal) {
             ]);
         }
     }
+
     // general output options
     command
         .output(output)
         .outputFormat("matroska");
+
     // video setup
     const { noTranscoding, width, height, frameRate, bitrateVideo, bitrateVideoMax, videoCodec, h26xPreset } = mergedOptions;
+
     command.addOutputOption("-map 0:v");
+
     if (noTranscoding) {
         command.videoCodec("copy");
     }
@@ -115,6 +131,7 @@ export function prepareStream(input, options = {}, cancelSignal) {
         command.videoFilter(`scale=${width}:${height}`);
         if (frameRate)
             command.fpsOutput(frameRate);
+
         command.addOutputOption([
             "-b:v", `${bitrateVideo}k`,
             "-maxrate:v", `${bitrateVideoMax}k`,
@@ -122,6 +139,7 @@ export function prepareStream(input, options = {}, cancelSignal) {
             "-pix_fmt", "yuv420p",
             "-force_key_frames", "expr:gte(t,n_forced*1)"
         ]);
+
         switch (videoCodec) {
             case 'AV1':
                 command
@@ -141,24 +159,26 @@ export function prepareStream(input, options = {}, cancelSignal) {
                 command
                     .videoCodec("libx264")
                     .outputOptions([
-                    '-tune zerolatency',
-                    `-preset ${h26xPreset}`,
-                    '-profile:v baseline',
-                ]);
+                        '-tune zerolatency',
+                        `-preset ${h26xPreset}`,
+                        '-profile:v baseline',
+                    ]);
                 break;
             case 'H265':
                 command
                     .videoCodec("libx265")
                     .outputOptions([
-                    '-tune zerolatency',
-                    `-preset ${h26xPreset}`,
-                    '-profile:v main',
-                ]);
+                        '-tune zerolatency',
+                        `-preset ${h26xPreset}`,
+                        '-profile:v main',
+                    ]);
                 break;
         }
     }
+
     // audio setup
     const { includeAudio, bitrateAudio } = mergedOptions;
+
     if (includeAudio)
         command
             .addOutputOption("-map 0:a?")
@@ -173,15 +193,17 @@ export function prepareStream(input, options = {}, cancelSignal) {
             .audioCodec("libopus")
             .audioBitrate(`${bitrateAudio}k`)
             .audioFilters("volume@internal_lib=1.0");
+
     // Add custom ffmpeg flags
     if (mergedOptions.customFfmpegFlags && mergedOptions.customFfmpegFlags.length > 0) {
         command.addOptions(mergedOptions.customFfmpegFlags);
     }
+
     // exit handling
     const promise = new Promise((resolve, reject) => {
         command.on("error", (err) => {
             if (cancelSignal?.aborted)
-                /**
+                /*
                  * fluent-ffmpeg might throw an error when SIGTERM is sent to
                  * the process, so we check if the abort signal is triggered
                  * and throw that instead
@@ -190,24 +212,35 @@ export function prepareStream(input, options = {}, cancelSignal) {
             else
                 reject(err);
         });
+
         command.on("end", () => resolve());
     });
+
     promise.catch(() => { });
+
     cancelSignal?.addEventListener("abort", () => command.kill("SIGTERM"), { once: true });
+
     command.run();
+
     return { command, output, promise };
 }
+
 export async function playStream(input, streamer, options = {}, cancelSignal, existingUdp = null) {
     const logger = new Log("playStream");
     cancelSignal?.throwIfAborted();
+
     if (!streamer.voiceConnection)
         throw new Error("Bot is not connected to a voice channel");
+
     logger.debug("Initializing demuxer");
     const { video, audio } = await demux(input);
     cancelSignal?.throwIfAborted();
+
     if (!video)
         throw new Error("No video stream in media");
+
     const cleanupFuncs = [];
+
     const videoCodecMap = {
         [AVCodecID.AV_CODEC_ID_H264]: "H264",
         [AVCodecID.AV_CODEC_ID_H265]: "H265",
@@ -215,6 +248,7 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
         [AVCodecID.AV_CODEC_ID_VP9]: "VP9",
         [AVCodecID.AV_CODEC_ID_AV1]: "AV1"
     };
+
     const defaultOptions = {
         type: "go-live",
         width: video.width,
@@ -226,6 +260,7 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
         customHeaders: {},
         initialMuted: false,
     };
+
     function mergeOptions(opts) {
         return {
             type: opts.type ?? defaultOptions.type,
@@ -249,21 +284,35 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
             initialMuted: opts.initialMuted ?? defaultOptions.initialMuted,
         };
     }
+
     const mergedOptions = mergeOptions(options);
     logger.debug({ options: mergedOptions }, "Merged options");
+
     let udp;
     let stopStream;
+
     if (!existingUdp) {
-        udp = await streamer.createStream();
-    }
-    else {
+        if (mergedOptions.type === "go-live") {
+            udp = await streamer.createStream();
+            stopStream = () => streamer.stopStream();
+        } else {
+            udp = streamer.voiceConnection.udp;
+            streamer.signalVideo(true);
+            stopStream = () => streamer.signalVideo(false);
+        }
+    } else {
         udp = existingUdp;
         udp.mediaConnection.setSpeaking(false);
         udp.mediaConnection.setVideoAttributes(false);
         await delay(250);
+        // Determine stopStream based on type
+        if (mergedOptions.type === "go-live") {
+            stopStream = () => streamer.stopStream();
+        } else {
+            stopStream = () => streamer.signalVideo(false);
+        }
     }
-    // stopStream = () => streamer.stopStream();
-    stopStream = () => console.log("Aborted");
+
     udp.setPacketizer(videoCodecMap[video.codec]);
     udp.mediaConnection.setSpeaking(true);
     udp.mediaConnection.setVideoAttributes(true, {
@@ -271,14 +320,16 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
         height: mergedOptions.height,
         fps: mergedOptions.frameRate
     });
+
     const vStream = new VideoStream(udp);
     video.stream.pipe(vStream);
+
     let audioStreamInstance;
     if (audio) {
         audioStreamInstance = new AudioStream(udp, false, mergedOptions.initialMuted);
         audio.stream.pipe(audioStreamInstance);
         vStream.syncStream = audioStreamInstance;
-        audioStreamInstance.syncStream = vStream;
+
         const burstTime = mergedOptions.readrateInitialBurst;
         if (typeof burstTime === "number") {
             vStream.sync = false;
@@ -295,6 +346,7 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
             vStream.on("pts", stopBurst);
         }
     }
+
     if (mergedOptions.streamPreview && mergedOptions.type === "go-live") {
         (async () => {
             const logger = new Log("playStream:preview");
@@ -304,19 +356,24 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
                 logger.warn("Failed to initialize decoder. Stream preview will be disabled");
                 return;
             }
+
             cleanupFuncs.push(() => {
                 logger.debug("Freeing decoder");
                 decoder.free();
             });
+
             const updatePreview = pDebounce.promise(async (packet) => {
                 if (!(packet.flags !== undefined && packet.flags & LibAV.AV_PKT_FLAG_KEY))
                     return;
+
                 const decodeStart = performance.now();
                 const [frame] = await decoder.decode([packet]).catch(() => []);
                 if (!frame)
                     return;
+
                 const decodeEnd = performance.now();
                 logger.debug(`Decoding a frame took ${decodeEnd - decodeStart}ms`);
+
                 return sharp(frame.data, {
                     raw: {
                         width: frame.width ?? 0,
@@ -330,16 +387,19 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
                     .then(image => streamer.setStreamPreview(image))
                     .catch(() => { });
             });
+
             video.stream.on("data", updatePreview);
             cleanupFuncs.push(() => video.stream.off("data", updatePreview));
         })();
     }
+
     const streamPromise = new Promise((resolve, reject) => {
         cleanupFuncs.push(() => {
             stopStream();
             udp.mediaConnection.setSpeaking(false);
             udp.mediaConnection.setVideoAttributes(false);
         });
+
         let cleanedUp = false;
         const cleanup = () => {
             if (cleanedUp)
@@ -348,22 +408,26 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
             for (const f of cleanupFuncs)
                 f();
         };
+
         cancelSignal?.addEventListener("abort", () => {
             cleanup();
             reject(cancelSignal.reason);
         }, { once: true });
+
         vStream.once("finish", () => {
             if (cancelSignal?.aborted)
                 return;
             cleanup();
             resolve();
         });
+
         vStream.once("error", (err) => {
             if (cancelSignal?.aborted)
                 return;
             cleanup();
             reject(err);
         });
+
         if (audio) {
             audio.stream.once("error", (err) => {
                 if (cancelSignal?.aborted)
@@ -380,8 +444,9 @@ export async function playStream(input, streamer, options = {}, cancelSignal, ex
             throw err;
         }
     });
+
     return {
         audioController: audioStreamInstance,
         done: streamPromise,
     };
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@m7mdxzx1/discord-video-strem",
-    "version": "0.0.1",
+    "version": "0.0.2",
     "description": "A fork from dank to use self-bot to do video share",
     "exports": "./dist/index.js",
     "types": "dist/index.d.ts",