@m7mdxzx1/discord-video-strem 0.0.1

package/dist/media/LibavDemuxer.d.ts

@@ -0,0 +1,23 @@
+import { type CodecParameters } from "@lng2004/libav.js-variant-webcodecs-avf-with-decoders";
+import { AVCodecID } from "./LibavCodecId.js";
+import type { Readable } from "node:stream";
+export declare function demux(input: Readable, cancelSignal?: AbortSignal): Promise<{
+    video: {
+        stream: Readable;
+        index: number;
+        codec: AVCodecID;
+        codecpar: CodecParameters;
+        width: number;
+        height: number;
+        framerate_num: number;
+        framerate_den: number;
+        extradata?: unknown;
+    } | undefined;
+    audio: {
+        stream: Readable;
+        index: number;
+        codec: AVCodecID;
+        codecpar: CodecParameters;
+        sample_rate: number;
+    } | undefined;
+}>;

package/dist/media/LibavDemuxer.js

@@ -0,0 +1,295 @@
+import pDebounce from "p-debounce";
+import LibAV from "@lng2004/libav.js-variant-webcodecs-avf-with-decoders";
+import { Log } from "debug-level";
+import { uid } from "uid";
+import { AVCodecID } from "./LibavCodecId.js";
+import { H264Helpers, H264NalUnitTypes, H265Helpers, H265NalUnitTypes, splitNalu, mergeNalu } from "../client/processing/AnnexBHelper.js";
+import { PassThrough } from "node:stream";
+const allowedVideoCodec = new Set([
+    AVCodecID.AV_CODEC_ID_H264,
+    AVCodecID.AV_CODEC_ID_H265,
+    AVCodecID.AV_CODEC_ID_VP8,
+    AVCodecID.AV_CODEC_ID_VP9,
+    AVCodecID.AV_CODEC_ID_AV1
+]);
+const allowedAudioCodec = new Set([
+    AVCodecID.AV_CODEC_ID_OPUS
+]);
+// Parse the avcC atom, which contains SPS and PPS
+function parseavcC(input) {
+    let buf = input;
+    if (buf[0] !== 1)
+        throw new Error("Only configurationVersion 1 is supported");
+    // Skip a bunch of stuff we don't care about
+    buf = buf.subarray(5);
+    const sps = [];
+    const pps = [];
+    // Read the SPS
+    const spsCount = buf[0] & 0b11111;
+    buf = buf.subarray(1);
+    for (let i = 0; i < spsCount; ++i) {
+        const spsLength = buf.readUInt16BE();
+        buf = buf.subarray(2);
+        sps.push(buf.subarray(0, spsLength));
+        buf = buf.subarray(spsLength);
+    }
+    // Read the PPS
+    const ppsCount = buf[0];
+    buf = buf.subarray(1);
+    for (let i = 0; i < ppsCount; ++i) {
+        const ppsLength = buf.readUInt16BE();
+        buf = buf.subarray(2);
+        pps.push(buf.subarray(0, ppsLength));
+        buf = buf.subarray(ppsLength);
+    }
+    return { sps, pps };
+}
+// Parse the hvcC atom, which contains VPS, SPS, PPS
+function parsehvcC(input) {
+    let buf = input;
+    if (buf[0] !== 1)
+        throw new Error("Only configurationVersion 1 is supported");
+    // Skip a bunch of stuff we don't care about
+    buf = buf.subarray(22);
+    const vps = [];
+    const sps = [];
+    const pps = [];
+    const numOfArrays = buf[0];
+    buf = buf.subarray(1);
+    for (let i = 0; i < numOfArrays; ++i) {
+        const naluType = buf[0] & 0b111111;
+        buf = buf.subarray(1);
+        const naluCount = buf.readUInt16BE();
+        buf = buf.subarray(2);
+        for (let j = 0; j < naluCount; ++j) {
+            const naluLength = buf.readUInt16BE();
+            buf = buf.subarray(2);
+            const nalu = buf.subarray(0, naluLength);
+            buf = buf.subarray(naluLength);
+            if (naluType === H265NalUnitTypes.VPS_NUT)
+                vps.push(nalu);
+            else if (naluType === H265NalUnitTypes.SPS_NUT)
+                sps.push(nalu);
+            else if (naluType === H265NalUnitTypes.PPS_NUT)
+                pps.push(nalu);
+        }
+    }
+    return { vps, sps, pps };
+}
+function h264AddParamSets(frame, paramSets) {
+    const { sps, pps } = paramSets;
+    const nalus = splitNalu(frame);
+    // Technically non-IDR I frames exist ("open GOP"), but they're exceedingly
+    // rare in the wild, and no encoder produces it by default
+    let isIDR = false;
+    let hasSPS = false;
+    let hasPPS = false;
+    for (const nalu of nalus) {
+        const naluType = H264Helpers.getUnitType(nalu);
+        if (naluType === H264NalUnitTypes.CodedSliceIdr)
+            isIDR = true;
+        else if (naluType === H264NalUnitTypes.SPS)
+            hasSPS = true;
+        else if (naluType === H264NalUnitTypes.PPS)
+            hasPPS = true;
+    }
+    if (!isIDR) {
+        // Not an IDR, return as is
+        return frame;
+    }
+    const chunks = [];
+    if (!hasPPS)
+        chunks.push(...sps);
+    if (!hasSPS)
+        chunks.push(...pps);
+    return mergeNalu([...chunks, ...nalus]);
+}
+function h265AddParamSets(frame, paramSets) {
+    const { vps, sps, pps } = paramSets;
+    const nalus = splitNalu(frame);
+    // Technically non-IDR I frames exist ("open GOP"), but they're exceedingly
+    // rare in the wild, and no encoder produces it by default
+    let isIDR = false;
+    let hasVPS = false;
+    let hasSPS = false;
+    let hasPPS = false;
+    for (const nalu of nalus) {
+        const naluType = H265Helpers.getUnitType(nalu);
+        if (naluType === H265NalUnitTypes.IDR_N_LP || naluType === H265NalUnitTypes.IDR_W_RADL)
+            isIDR = true;
+        else if (naluType === H265NalUnitTypes.VPS_NUT)
+            hasVPS = true;
+        else if (naluType === H265NalUnitTypes.SPS_NUT)
+            hasSPS = true;
+        else if (naluType === H265NalUnitTypes.PPS_NUT)
+            hasPPS = true;
+    }
+    if (!isIDR) {
+        // Not an IDR, return as is
+        return frame;
+    }
+    const chunks = [];
+    if (!hasVPS)
+        chunks.push(...vps);
+    if (!hasPPS)
+        chunks.push(...sps);
+    if (!hasSPS)
+        chunks.push(...pps);
+    return mergeNalu([...chunks, ...nalus]);
+}
+const idToStream = new Map();
+const libavInstance = LibAV.LibAV();
+libavInstance.then((libav) => {
+    libav.onread = (id) => {
+        idToStream.get(id)?.resume();
+    };
+});
+export async function demux(input, cancelSignal) {
+    const loggerInput = new Log("demux:input");
+    const loggerFormat = new Log("demux:format");
+    const loggerFrameCommon = new Log("demux:frame:common");
+    const loggerFrameVideo = new Log("demux:frame:video");
+    const loggerFrameAudio = new Log("demux:frame:audio");
+    const libav = await libavInstance;
+    const filename = uid();
+    await libav.mkreaderdev(filename);
+    idToStream.set(filename, input);
+    const ondata = (chunk) => {
+        loggerInput.trace(`Received ${chunk.length} bytes of data for input ${filename}`);
+        libav.ff_reader_dev_send(filename, chunk);
+    };
+    const onend = () => {
+        loggerInput.trace(`Reached the end of input ${filename}`);
+        libav.ff_reader_dev_send(filename, null);
+    };
+    input.on("data", ondata);
+    input.on("end", onend);
+    const [fmt_ctx, streams] = await libav.ff_init_demuxer_file(filename, "matroska");
+    const pkt = await libav.av_packet_alloc();
+    const cleanup = () => {
+        vPipe.off("drain", readFrame);
+        aPipe.off("drain", readFrame);
+        input.off("data", ondata);
+        input.off("end", onend);
+        idToStream.delete(filename);
+        libav.avformat_close_input_js(fmt_ctx);
+        libav.av_packet_free(pkt);
+        libav.unlink(filename);
+    };
+    const vStream = streams.find((stream) => stream.codec_type === libav.AVMEDIA_TYPE_VIDEO);
+    const aStream = streams.find((stream) => stream.codec_type === libav.AVMEDIA_TYPE_AUDIO);
+    let vInfo;
+    let aInfo;
+    const vPipe = new PassThrough({ objectMode: true, writableHighWaterMark: 128 });
+    const aPipe = new PassThrough({ objectMode: true, writableHighWaterMark: 128 });
+    if (vStream) {
+        if (!allowedVideoCodec.has(vStream.codec_id)) {
+            const codecName = await libav.avcodec_get_name(vStream.codec_id);
+            cleanup();
+            throw new Error(`Video codec ${codecName} is not allowed`);
+        }
+        const codecpar = await libav.ff_copyout_codecpar(vStream.codecpar);
+        vInfo = {
+            index: vStream.index,
+            codec: vStream.codec_id,
+            codecpar,
+            width: codecpar.width ?? 0,
+            height: codecpar.height ?? 0,
+            framerate_num: await libav.AVCodecParameters_framerate_num(vStream.codecpar),
+            framerate_den: await libav.AVCodecParameters_framerate_den(vStream.codecpar),
+        };
+        if (vStream.codec_id === AVCodecID.AV_CODEC_ID_H264) {
+            const { extradata } = codecpar;
+            vInfo = {
+                ...vInfo,
+                // biome-ignore lint/style/noNonNullAssertion: will always be non-null for our use case
+                extradata: parseavcC(Buffer.from(extradata))
+            };
+        }
+        else if (vStream.codec_id === AVCodecID.AV_CODEC_ID_H265) {
+            const { extradata } = codecpar;
+            vInfo = {
+                ...vInfo,
+                // biome-ignore lint/style/noNonNullAssertion: will always be non-null for our use case
+                extradata: parsehvcC(Buffer.from(extradata))
+            };
+        }
+        loggerFormat.info({
+            info: vInfo
+        }, `Found video stream in input ${filename}`);
+    }
+    if (aStream) {
+        if (!allowedAudioCodec.has(aStream.codec_id)) {
+            const codecName = await libav.avcodec_get_name(aStream.codec_id);
+            cleanup();
+            throw new Error(`Audio codec ${codecName} is not allowed`);
+        }
+        const codecpar = await libav.ff_copyout_codecpar(aStream.codecpar);
+        aInfo = {
+            index: aStream.index,
+            codec: aStream.codec_id,
+            codecpar,
+            sample_rate: codecpar.sample_rate ?? 0
+        };
+        loggerFormat.info({
+            info: aInfo
+        }, `Found audio stream in input ${filename}`);
+    }
+    const readFrame = pDebounce.promise(async () => {
+        let resume = true;
+        while (resume) {
+            const [status, streams] = await libav.ff_read_frame_multi(fmt_ctx, pkt, {
+                limit: 1,
+                unify: true
+            });
+            for (const packet of streams[0] ?? []) {
+                if (vInfo && vInfo.index === packet.stream_index) {
+                    if (vInfo.codec === AVCodecID.AV_CODEC_ID_H264) {
+                        packet.data = h264AddParamSets(Buffer.from(packet.data), 
+                        // biome-ignore lint/style/noNonNullAssertion: will always be non-null for our use case
+                        vInfo.extradata);
+                    }
+                    else if (vInfo.codec === AVCodecID.AV_CODEC_ID_H265) {
+                        packet.data = h265AddParamSets(Buffer.from(packet.data), 
+                        // biome-ignore lint/style/noNonNullAssertion: will always be non-null for our use case
+                        vInfo.extradata);
+                    }
+                    resume &&= vPipe.write(packet);
+                    loggerFrameVideo.trace("Pushed a frame into the video pipe");
+                }
+                else if (aInfo && aInfo.index === packet.stream_index) {
+                    resume &&= aPipe.write(packet);
+                    loggerFrameAudio.trace("Pushed a frame into the audio pipe");
+                }
+            }
+            if (status < 0 && status !== -libav.EAGAIN) {
+                // End of file, or some error happened
+                cleanup();
+                vPipe.end();
+                aPipe.end();
+                if (status === LibAV.AVERROR_EOF)
+                    loggerFrameCommon.info("Reached end of stream. Stopping");
+                else
+                    loggerFrameCommon.info({ status }, "Received an error during frame extraction. Stopping");
+                return;
+            }
+            if (!resume) {
+                input.pause();
+                loggerInput.trace("Input stream paused");
+            }
+        }
+    });
+    vPipe.on("drain", () => {
+        loggerFrameVideo.trace("Video pipe drained");
+        readFrame();
+    });
+    aPipe.on("drain", () => {
+        loggerFrameAudio.trace("Audio pipe drained");
+        readFrame();
+    });
+    readFrame();
+    return {
+        video: vInfo ? { ...vInfo, stream: vPipe } : undefined,
+        audio: aInfo ? { ...aInfo, stream: aPipe } : undefined
+    };
+}

package/dist/media/VideoStream.d.ts

@@ -0,0 +1,7 @@
+import type { MediaUdp } from "../client/voice/MediaUdp.js";
+import { BaseMediaStream } from "./BaseMediaStream.js";
+export declare class VideoStream extends BaseMediaStream {
+    udp: MediaUdp;
+    constructor(udp: MediaUdp, noSleep?: boolean);
+    protected _sendFrame(frame: Buffer, frametime: number): Promise<void>;
+}

package/dist/media/VideoStream.js

@@ -0,0 +1,10 @@
+import { BaseMediaStream } from "./BaseMediaStream.js";
+export class VideoStream extends BaseMediaStream {
+    constructor(udp, noSleep = false) {
+        super("video", noSleep);
+        this.udp = udp;
+    }
+    async _sendFrame(frame, frametime) {
+        await this.udp.sendVideoFrame(frame, frametime);
+    }
+}

package/dist/media/index.d.ts

@@ -0,0 +1 @@
+export * from './LibavDemuxer.js';

package/dist/media/index.js

@@ -0,0 +1 @@
+export * from './LibavDemuxer.js';

package/dist/media/newApi.d.ts

@@ -0,0 +1,126 @@
+import ffmpeg from 'fluent-ffmpeg';
+import { PassThrough, type Readable } from "node:stream";
+import type { SupportedVideoCodec } from '../utils.js';
+import type { MediaUdp, Streamer } from '../client/index.js';
+export type EncoderOptions = {
+    /**
+     * Disable video transcoding
+     * If enabled, all video related settings have no effects, and the input
+     * video stream is used as-is.
+     *
+     * You need to ensure that the video stream has the right properties
+     * (keyframe every 1s, B-frames disabled). Failure to do so will result in
+     * a glitchy stream, or degraded performance
+     */
+    noTranscoding: boolean;
+    /**
+     * Video width
+     */
+    width: number;
+    /**
+     * Video height
+     */
+    height: number;
+    /**
+     * Video frame rate
+     */
+    frameRate?: number;
+    /**
+     * Video codec
+     */
+    videoCodec: SupportedVideoCodec;
+    /**
+     * Video average bitrate in kbps
+     */
+    bitrateVideo: number;
+    /**
+     * Video max bitrate in kbps
+     */
+    bitrateVideoMax: number;
+    /**
+     * Audio bitrate in kbps
+     */
+    bitrateAudio: number;
+    /**
+     * Enable audio output
+     */
+    includeAudio: boolean;
+    /**
+     * Enable hardware accelerated decoding
+     */
+    hardwareAcceleratedDecoding: boolean;
+    /**
+     * Add some options to minimize latency
+     */
+    minimizeLatency: boolean;
+    /**
+     * Preset for x264 and x265
+     */
+    h26xPreset: "ultrafast" | "superfast" | "veryfast" | "faster" | "fast" | "medium" | "slow" | "slower" | "veryslow" | "placebo";
+    /**
+     * Custom headers for HTTP requests
+     */
+    customHeaders: Record<string, string>;
+    /**
+     * Input for seeking time
+     */
+    seekTime?: number;
+    /**
+     * Custom ffmpeg flags/options to pass directly to ffmpeg
+     * These will be added to the command after other options
+     */
+    customFfmpegFlags: string[];
+};
+export interface AudioController {
+    mute(): void;
+    unmute(): void;
+    isMuted(): boolean;
+    setVolume(volume: number): void;
+    getVolume(): number;
+}
+export declare function prepareStream(input: string | Readable, options?: Partial<EncoderOptions>, cancelSignal?: AbortSignal): {
+    command: ffmpeg.FfmpegCommand;
+    output: PassThrough;
+    promise: Promise<void>;
+};
+export type PlayStreamOptions = {
+    /**
+     * Set stream type as \"Go Live\" or camera stream
+     */
+    type: "go-live" | "camera";
+    /**
+     * Override video width sent to Discord.
+     *
+     * DO NOT SPECIFY UNLESS YOU KNOW WHAT YOU'RE DOING!
+     */
+    width: number;
+    /**
+     * Override video height sent to Discord.
+     *
+     * DO NOT SPECIFY UNLESS YOU KNOW WHAT YOU'RE DOING!
+     */
+    height: number;
+    /**
+     * Override video frame rate sent to Discord.
+     *
+     * DO NOT SPECIFY UNLESS YOU KNOW WHAT YOU'RE DOING!
+     */
+    frameRate: number;
+    /**
+     * Same as ffmpeg's `readrate_initial_burst` command line flag
+     *
+     * See https://ffmpeg.org/ffmpeg.html#:~:text=%2Dreadrate_initial_burst
+     */
+    readrateInitialBurst: number | undefined;
+    /**
+     * Enable stream preview from input stream (experimental)
+     */
+    streamPreview: boolean;
+    seekTime?: number;
+    customHeaders?: Record<string, string>;
+    initialMuted?: boolean;
+};
+export declare function playStream(input: Readable, streamer: Streamer, options?: Partial<PlayStreamOptions>, cancelSignal?: AbortSignal, existingUdp?: MediaUdp | null): Promise<{
+    audioController?: AudioController;
+    done: Promise<void>;
+}>;