@scrypted/prebuffer-mixin 0.9.43 → 0.9.44

package/src/rfc4571.ts

@@ -1,224 +0,0 @@
-import { cloneDeep } from "@scrypted/common/src/clone-deep";
-import { ParserOptions, ParserSession, setupActivityTimer } from "@scrypted/common/src/ffmpeg-rebroadcast";
-import { read16BELengthLoop } from "@scrypted/common/src/read-stream";
-import { findH264NaluType, H264_NAL_TYPE_SPS, RTSP_FRAME_MAGIC } from "@scrypted/common/src/rtsp-server";
-import { parseSdp } from "@scrypted/common/src/sdp-utils";
-import { sleep } from "@scrypted/common/src/sleep";
-import { StreamChunk } from "@scrypted/common/src/stream-parser";
-import { MediaStreamOptions, ResponseMediaStreamOptions } from "@scrypted/sdk";
-import { parse as spsParse } from "h264-sps-parser";
-import net from 'net';
-import { EventEmitter, Readable } from "stream";
-import { getSpsResolution } from "./sps-resolution";
-
-export function negotiateMediaStream(sdp: string, mediaStreamOptions: MediaStreamOptions, inputVideoCodec: string, inputAudioCodec: string, requestMediaStream: MediaStreamOptions) {
-    const parsedSdp = parseSdp(sdp);
-    const ret: ResponseMediaStreamOptions = cloneDeep(mediaStreamOptions) || {
-        id: undefined,
-        name: undefined,
-    };
-
-    // if the source doesn't provide a video codec, dummy one up
-    if (ret.video === undefined)
-        ret.video = {};
-
-    // the requests does not want video
-    if (requestMediaStream?.video === null)
-        ret.video = null;
-
-    if (ret.video)
-        ret.video.codec = inputVideoCodec;
-
-    // some rtsp like unifi offer alternate audio tracks (aac and opus).
-    if (requestMediaStream?.audio?.codec && requestMediaStream?.audio?.codec !== inputAudioCodec) {
-        const alternateAudio = parsedSdp.msections.find(msection => msection.type === 'audio' && msection.codec === requestMediaStream?.audio?.codec);
-        if (alternateAudio) {
-            ret.audio = {
-                codec: requestMediaStream?.audio?.codec,
-            };
-
-            return ret;
-        }
-    }
-
-    // reported codecs may be wrong/cached/etc, so before blindly copying the audio codec info,
-    // verify what was found.
-    if (ret?.audio?.codec === inputAudioCodec) {
-        ret.audio = mediaStreamOptions?.audio;
-    }
-    else {
-        ret.audio = {
-            codec: inputAudioCodec,
-        }
-    }
-
-    return ret;
-}
-
-export function connectRFC4571Parser(url: string) {
-    const u = new URL(url);
-    if (!u.protocol.startsWith('tcp'))
-        throw new Error('rfc4751 url must be tcp');
-
-    const socket = net.connect(parseInt(u.port), u.hostname);
-    return socket;
-}
-
-export function startRFC4571Parser(console: Console, socket: Readable, sdp: string, mediaStreamOptions: ResponseMediaStreamOptions, options?: ParserOptions<"rtsp">): ParserSession<"rtsp"> {
-    let isActive = true;
-    const events = new EventEmitter();
-    // need this to prevent kill from throwing due to uncaught Error during cleanup
-    events.on('error', e => console.error('rebroadcast error', e));
-
-    const parsedSdp = parseSdp(sdp);
-    const audioSection = parsedSdp.msections.find(msection => msection.type === 'audio');
-    const videoSection = parsedSdp.msections.find(msection => msection.type === 'video');
-    const audioPt = audioSection?.payloadTypes?.[0];
-    const videoPt = videoSection?.payloadTypes?.[0];
-
-    const inputAudioCodec = audioSection?.codec;
-    const inputVideoCodec = videoSection.codec;
-
-    let sessionKilled: any;
-    const killed = new Promise<void>(resolve => {
-        sessionKilled = resolve;
-    });
-
-    const kill = (error?: Error) => {
-        if (isActive) {
-            events.emit('killed');
-            events.emit('error', error || new Error('killed'));
-        }
-        isActive = false;
-        sessionKilled();
-        socket.destroy();
-    };
-
-    socket.on('close', () => {
-        kill(new Error('rfc4751 socket closed'));
-    });
-    socket.on('error', e => {
-        kill(e);
-    });
-
-    const { resetActivityTimer } = setupActivityTimer('rtsp', kill, events, options?.timeout);
-
-    let inputVideoResolution: {
-        width: number;
-        height: number;
-    };
-
-    const sprop = videoSection
-        ?.fmtp?.[0]?.parameters?.['sprop-parameter-sets'];
-    const sdpSps = sprop?.split(',')?.[0];
-    // const sdpPps = sprop?.split(',')?.[1];
-
-    if (sdpSps) {
-        try {
-            const sps = Buffer.from(sdpSps, 'base64');
-            const parsedSps = spsParse(sps);
-            inputVideoResolution = getSpsResolution(parsedSps);
-            console.log('parsed sdp sps', parsedSps);
-        }
-        catch (e) {
-            console.warn('sdp sps parsing failed');
-        }
-    }
-
-    const start = () => {
-        // don't start parsing until next tick, to prevent missed packets.
-        read16BELengthLoop(socket, {
-            headerLength: 2,
-            skipHeader: undefined,
-            callback: (header, data) => {
-                let type: string;
-                const pt = data[1] & 0x7f;
-
-                const prefix = Buffer.alloc(2);
-                prefix[0] = RTSP_FRAME_MAGIC;
-                if (pt === audioPt) {
-                    prefix[1] = 0;
-                }
-                else if (pt === videoPt) {
-                    prefix[1] = 2;
-                }
-                header = Buffer.concat([prefix, header]);
-
-                if (pt === audioPt)
-                    type = inputAudioCodec;
-                else if (pt === videoPt)
-                    type = inputVideoCodec;
-
-                const chunk: StreamChunk = {
-                    chunks: [header, data],
-                    type,
-                };
-
-                if (!inputVideoResolution) {
-                    const sps = findH264NaluType(chunk, H264_NAL_TYPE_SPS);
-                    if (sps) {
-                        try {
-                            const parsedSps = spsParse(sps);
-                            inputVideoResolution = getSpsResolution(parsedSps);
-                            console.log(inputVideoResolution);
-                            console.log('parsed bitstream sps', parsedSps);
-                        }
-                        catch (e) {
-                            console.warn('sps parsing failed');
-                            inputVideoResolution = {
-                                width: NaN,
-                                height: NaN,
-                            }
-                        }
-                    }
-                }
-
-                events.emit('rtsp', chunk);
-                resetActivityTimer();
-            }
-        })
-            .catch(e => {
-                throw e;
-            })
-            .finally(() => {
-                kill(new Error('parser exited'));
-            });
-    };
-
-
-
-    return {
-        start,
-        sdp: Promise.resolve([Buffer.from(sdp)]),
-        inputAudioCodec,
-        inputVideoCodec,
-        get inputVideoResolution() {
-            return inputVideoResolution;
-        },
-        get isActive() { return isActive },
-        kill(error?: Error) {
-            kill(error);
-        },
-        killed,
-        resetActivityTimer,
-        negotiateMediaStream: (requestMediaStream) => {
-            return negotiateMediaStream(sdp, mediaStreamOptions, inputVideoCodec, inputAudioCodec, requestMediaStream);
-        },
-        emit(container: 'rtsp', chunk: StreamChunk) {
-            events.emit(container, chunk);
-            return this;
-        },
-        on(event: string, cb: any) {
-            events.on(event, cb);
-            return this;
-        },
-        once(event: any, cb: any) {
-            events.once(event, cb);
-            return this;
-        },
-        removeListener(event, cb) {
-            events.removeListener(event, cb);
-            return this;
-        }
-    }
-}

package/src/rtsp-session.ts

@@ -1,302 +0,0 @@
-import { ParserSession, setupActivityTimer } from "@scrypted/common/src/ffmpeg-rebroadcast";
-import { closeQuiet, createBindZero } from "@scrypted/common/src/listen-cluster";
-import { findH264NaluType, H264_NAL_TYPE_SPS, parseSemicolonDelimited, RtspClient, RtspClientUdpSetupOptions, RTSP_FRAME_MAGIC } from "@scrypted/common/src/rtsp-server";
-import { parseSdp } from "@scrypted/common/src/sdp-utils";
-import { StreamChunk } from "@scrypted/common/src/stream-parser";
-import { ResponseMediaStreamOptions } from "@scrypted/sdk";
-import dgram from 'dgram';
-import { parse as spsParse } from "h264-sps-parser";
-import { EventEmitter } from "stream";
-import { negotiateMediaStream } from "./rfc4571";
-import { getSpsResolution } from "./sps-resolution";
-
-export type RtspChannelCodecMapping = { [key: number]: string };
-
-export interface RtspSessionParserSpecific {
-    interleaved: Map<string, number>;
-}
-
-export async function startRtspSession(console: Console, url: string, mediaStreamOptions: ResponseMediaStreamOptions, options: {
-    useUdp: boolean,
-    audioSoftMuted: boolean,
-    rtspRequestTimeout: number,
-}): Promise<ParserSession<"rtsp">> {
-    let isActive = true;
-    const events = new EventEmitter();
-    // need this to prevent kill from throwing due to uncaught Error during cleanup
-    events.on('error', e => console.error('rebroadcast error', e));
-
-    let servers: dgram.Socket[] = [];
-    const rtspClient = new RtspClient(url);
-    rtspClient.console = console;
-    rtspClient.requestTimeout = options.rtspRequestTimeout;
-
-    const cleanupSockets = () => {
-        for (const server of servers) {
-            closeQuiet(server);
-        }
-        rtspClient.safeTeardown();
-    }
-
-    let sessionKilled: any;
-    const killed = new Promise<void>(resolve => {
-        sessionKilled = resolve;
-    });
-
-    const kill = (error?: Error) => {
-        if (isActive) {
-            events.emit('killed');
-            events.emit('error', error || new Error('killed'));
-        }
-        isActive = false;
-        sessionKilled();
-        cleanupSockets();
-    };
-
-    rtspClient.client.on('close', () => {
-        kill(new Error('rtsp socket closed'));
-    });
-    rtspClient.client.on('error', e => {
-        kill(e);
-    });
-
-    const { resetActivityTimer } = setupActivityTimer('rtsp', kill, events, options?.rtspRequestTimeout);
-
-    try {
-        await rtspClient.options();
-        const sdpResponse = await rtspClient.describe();
-        const contentBase = sdpResponse.headers['content-base'];
-        if (contentBase) {
-            const url = new URL(contentBase, rtspClient.url);
-            const existing = new URL(rtspClient.url);
-            for (const p of existing.searchParams) {
-                url.searchParams.append(p[0], p[1]);
-            }
-            url.username = existing.username;
-            url.password = existing.password;
-            rtspClient.url = url.toString();
-        }
-        let sdp = sdpResponse.body.toString().trim();
-        console.log('sdp', sdp);
-
-        const parsedSdp = parseSdp(sdp);
-        let channel = 0;
-        const mapping: RtspChannelCodecMapping = {};
-        let udpSessionTimeout: number;
-        const { useUdp } = options;
-        const checkUdpSessionTimeout = (headers: { [key: string]: string }) => {
-            if (useUdp && headers.session && !udpSessionTimeout) {
-                const sessionDict = parseSemicolonDelimited(headers.session);
-                udpSessionTimeout = parseInt(sessionDict['timeout']);
-            }
-        }
-
-        let parserSpecific: RtspSessionParserSpecific;
-        if (!useUdp) {
-            parserSpecific = {
-                interleaved: new Map(),
-            }
-        }
-
-        const doSetup = async (control: string, codec: string) => {
-            let udp: dgram.Socket;
-            if (useUdp) {
-                const rtspChannel = channel;
-
-                const setup: RtspClientUdpSetupOptions = {
-                    path: control,
-                    type: 'udp',
-                    onRtp: (header, data) => {
-                        const prefix = Buffer.alloc(4);
-                        prefix.writeUInt8(RTSP_FRAME_MAGIC, 0);
-                        prefix.writeUInt8(rtspChannel, 1);
-                        prefix.writeUInt16BE(data.length, 2);
-                        const chunk: StreamChunk = {
-                            chunks: [prefix, data],
-                            type: codec,
-                        };
-                        events.emit('rtsp', chunk);
-                        resetActivityTimer?.();
-                    },
-                };
-                const setupResult = await rtspClient.setup(setup);
-                udp = setup.dgram;
-                checkUdpSessionTimeout(setupResult.headers);
-
-                const punch = Buffer.alloc(1);
-                const transport = setupResult.headers['transport'];
-                const match = transport.match(/.*?server_port=([0-9]+)-([0-9]+)/);
-                const [_, rtp, rtcp] = match;
-                const { hostname } = new URL(rtspClient.url);
-                udp.send(punch, parseInt(rtp), hostname)
-
-                mapping[channel] = codec;
-            }
-            else {
-                const setupResult = await rtspClient.setup({
-                    path: control,
-                    type: 'tcp',
-                    port: channel,
-                    onRtp: (header, data) => {
-                        const chunk: StreamChunk = {
-                            chunks: [header, data],
-                            type: codec,
-                        };
-                        events.emit('rtsp', chunk);
-                        resetActivityTimer?.();
-                    },
-                });
-
-                const resultChannel = setupResult.interleaved ? setupResult.interleaved.begin : channel;
-                mapping[resultChannel] = codec;
-                parserSpecific.interleaved.set(codec, resultChannel);
-            }
-
-            channel += 2;
-        }
-
-        let setupVideoSection = false;
-
-        parsedSdp.msections = parsedSdp.msections.filter(section => {
-            if (section.type === 'video') {
-                if (setupVideoSection) {
-                    console.warn('additional video section found. skipping.');
-                    return false;
-                }
-                setupVideoSection = true;
-            }
-            else if (section.type !== 'audio') {
-                console.warn('unknown section', section.type);
-                return false;
-            }
-            else if (options.audioSoftMuted) {
-                return false;
-            }
-            return true;
-        });
-
-        for (const section of parsedSdp.msections) {
-            await doSetup(section.control, section.codec)
-        }
-
-        // sdp may contain multiple audio/video sections. take only the first video section.
-        sdp = [...parsedSdp.header.lines, ...parsedSdp.msections.map(msection => msection.lines).flat()].join('\r\n');
-
-        // don't start parsing until next tick when this function returns to allow
-        // event handlers to be set prior to parsing.
-        const start = async () => {
-            try {
-                await rtspClient.play();
-                rtspClient.console = undefined;
-                await rtspClient.readLoop();
-            }
-            catch (e) {
-                kill(e);
-            }
-            finally {
-                kill(new Error('rtsp read loop exited'));
-            }
-        };
-
-        // this return block is intentional, to ensure that the remaining code happens sync.
-        return (() => {
-            const audioSection = parsedSdp.msections.find(msection => msection.type === 'audio');
-            const videoSection = parsedSdp.msections.find(msection => msection.type === 'video');
-
-            if (!videoSection)
-                throw new Error('SDP does not contain a video section!');
-
-            const inputAudioCodec = audioSection?.codec;
-            const inputVideoCodec = videoSection.codec;
-
-
-            let inputVideoResolution: {
-                width: number;
-                height: number;
-            };
-
-            const probeStart = Date.now();
-            const probe = (chunk: StreamChunk) => {
-                if (Date.now() - probeStart > 6000)
-                    events.removeListener('rtsp', probe);
-                const sps = findH264NaluType(chunk, H264_NAL_TYPE_SPS);
-                if (sps) {
-                    try {
-                        const parsedSps = spsParse(sps);
-                        inputVideoResolution = getSpsResolution(parsedSps);
-                        // console.log(inputVideoResolution);
-                        console.log('parsed bitstream sps', inputVideoResolution);
-                    }
-                    catch (e) {
-                        console.warn('sps parsing failed');
-                        inputVideoResolution = {
-                            width: NaN,
-                            height: NaN,
-                        }
-                    }
-                    events.removeListener('rtsp', probe);
-                }
-            }
-
-            if (!inputVideoResolution)
-                events.on('rtsp', probe);
-
-            const sprop = videoSection
-                ?.fmtp?.[0]?.parameters?.['sprop-parameter-sets'];
-            const sdpSps = sprop?.split(',')?.[0];
-            // const sdpPps = sprop?.split(',')?.[1];
-
-            if (sdpSps) {
-                try {
-                    const sps = Buffer.from(sdpSps, 'base64');
-                    const parsedSps = spsParse(sps);
-                    inputVideoResolution = getSpsResolution(parsedSps);
-                    console.log('parsed sdp sps', inputVideoResolution);
-                }
-                catch (e) {
-                    console.warn('sdp sps parsing failed');
-                }
-            }
-
-            return {
-                parserSpecific,
-                start,
-                sdp: Promise.resolve([Buffer.from(sdp)]),
-                inputAudioCodec,
-                inputVideoCodec,
-                get inputVideoResolution() {
-                    return inputVideoResolution;
-                },
-                get isActive() { return isActive },
-                kill(error?: Error) {
-                    kill(error);
-                },
-                killed,
-                resetActivityTimer,
-                negotiateMediaStream: (requestMediaStream) => {
-                    return negotiateMediaStream(sdp, mediaStreamOptions, inputVideoCodec, inputAudioCodec, requestMediaStream);
-                },
-                emit(container: 'rtsp', chunk: StreamChunk) {
-                    events.emit(container, chunk);
-                    return this;
-                },
-                on(event: string, cb: any) {
-                    events.on(event, cb);
-                    return this;
-                },
-                once(event: any, cb: any) {
-                    events.once(event, cb);
-                    return this;
-                },
-                removeListener(event, cb) {
-                    events.removeListener(event, cb);
-                    return this;
-                }
-            }
-        })();
-    }
-    catch (e) {
-        cleanupSockets();
-        throw e;
-    }
-}

package/src/sps-resolution.ts

@@ -1,50 +0,0 @@
-import { SPSInfo } from "h264-sps-parser";
-
-export function getSpsResolution(sps: SPSInfo) {
-    let SubWidthC: number;
-    let SubHeightC: number;
-
-    if (sps.chroma_format_idc == 0 && sps.color_plane_flag == 0) { //monochrome
-        SubWidthC = SubHeightC = 0;
-    }
-    else if (sps.chroma_format_idc == 1 && sps.color_plane_flag == 0) { //4:2:0 
-        SubWidthC = SubHeightC = 2;
-    }
-    else if (sps.chroma_format_idc == 2 && sps.color_plane_flag == 0) { //4:2:2 
-        SubWidthC = 2;
-        SubHeightC = 1;
-    }
-    else if (sps.chroma_format_idc == 3) { //4:4:4
-        if (sps.color_plane_flag == 0) {
-            SubWidthC = SubHeightC = 1;
-        }
-        else if (sps.color_plane_flag == 1) {
-            SubWidthC = SubHeightC = 0;
-        }
-    }
-
-    let PicWidthInMbs = sps.pic_width_in_mbs;
-
-    let PicHeightInMapUnits = sps.pic_height_in_map_units;
-    let FrameHeightInMbs = (2 - sps.frame_mbs_only_flag) * PicHeightInMapUnits;
-
-    let crop_left = 0;
-    let crop_right = 0;
-    let crop_top = 0;
-    let crop_bottom = 0;
-
-    if (sps.frame_cropping_flag) {
-        crop_left = sps.frame_cropping.left;
-        crop_right = sps.frame_cropping.right;
-        crop_top = sps.frame_cropping.top;
-        crop_bottom = sps.frame_cropping.bottom;
-    }
-
-    let width = PicWidthInMbs * 16 - SubWidthC * (crop_left + crop_right);
-    let height = FrameHeightInMbs * 16 - SubHeightC * (2 - sps.frame_mbs_only_flag) * (crop_top + crop_bottom);
-
-    return {
-        width,
-        height,
-    };
-}