@bililive-tools/bilibili-recorder 1.0.1 → 1.1.0

package/README.md

@@ -6,6 +6,8 @@
 
 # 安装
 
+**建议所有录制器和manager包都升级到最新版，我不会对兼容性做过多考虑**
+
 `npm i @bililive-tools/bilibili-recorder @bililive-tools/manager`
 
 # 使用
@@ -33,11 +35,11 @@ manager.startCheckLoop();
 interface Options {
   channelId: string; // 长直播间ID，具体解析见文档，也可自行解析
   quality: number; // 见画质参数
-  qualityRetry?: number; // 画质匹配重试次数
+  qualityRetry?: number; // 画质匹配重试次数, -1为强制匹配画质，0为自动配置，正整数为最大匹配次数
   streamPriorities: []; // 废弃
   sourcePriorities: []; // 废弃
   disableAutoCheck?: boolean; // 为 true 时 manager 将跳过自动检查
-  segment?: number; // 分段参数
+  segment?: number; // 分段参数，单位分钟
   disableProvideCommentsWhenRecording?: boolean; // 禁用弹幕录制
   saveGiftDanma?: boolean; // 保存礼物弹幕，包含舰长
   saveSCDanma?: boolean; // 保存SC

package/lib/bilibili_api.d.ts

@@ -49,6 +49,7 @@ export declare function getRoomBaseInfo<RoomId extends number>(roomId: RoomId):
     live_time: string;
     live_status: LiveStatus;
     cover: string;
+    is_encrypted: boolean;
 }>>;
 export declare function getPlayURL(roomId: number, opts?: {
     useHLS?: boolean;
@@ -85,7 +86,7 @@ export declare function getRoomPlayInfo(roomIdOrShortId: number, opts?: {
     };
 }>;
 export interface ProtocolInfo {
-    protocol_name: string | "http_stream" | "http_hls";
+    protocol_name: "http_stream" | "http_hls";
     format: FormatInfo[];
 }
 export interface FormatInfo {

package/lib/danma.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from "node:events";
+declare class DanmaClient extends EventEmitter {
+    private client;
+    private roomId;
+    private auth;
+    private uid;
+    private retryCount;
+    constructor(roomId: number, auth: string | undefined, uid: number | undefined);
+    start(): void;
+    stop(): void;
+}
+export default DanmaClient;

package/lib/danma.js

@@ -0,0 +1,124 @@
+import { EventEmitter } from "node:events";
+import { startListen } from "./blive-message-listener/index.js";
+class DanmaClient extends EventEmitter {
+    client = null;
+    roomId;
+    auth;
+    uid;
+    retryCount = 5;
+    constructor(roomId, auth, uid) {
+        super();
+        this.roomId = roomId;
+        this.auth = auth;
+        this.uid = uid;
+    }
+    start() {
+        const handler = {
+            onIncomeDanmu: (msg) => {
+                let content = msg.body.content;
+                content = content.replace(/(^\s*)|(\s*$)/g, "").replace(/[\r\n]/g, "");
+                if (content === "")
+                    return;
+                const comment = {
+                    type: "comment",
+                    timestamp: msg.timestamp,
+                    text: content,
+                    color: msg.body.content_color,
+                    mode: msg.body.type,
+                    sender: {
+                        uid: String(msg.body.user.uid),
+                        name: msg.body.user.uname,
+                        avatar: msg.body.user.face,
+                        extra: {
+                            badgeName: msg.body.user.badge?.name,
+                            badgeLevel: msg.body.user.badge?.level,
+                        },
+                    },
+                };
+                this.emit("Message", comment);
+            },
+            onIncomeSuperChat: (msg) => {
+                const content = msg.body.content.replaceAll(/[\r\n]/g, "");
+                const comment = {
+                    type: "super_chat",
+                    timestamp: msg.timestamp,
+                    text: content,
+                    price: msg.body.price,
+                    sender: {
+                        uid: String(msg.body.user.uid),
+                        name: msg.body.user.uname,
+                        avatar: msg.body.user.face,
+                        extra: {
+                            badgeName: msg.body.user.badge?.name,
+                            badgeLevel: msg.body.user.badge?.level,
+                        },
+                    },
+                };
+                this.emit("Message", comment);
+            },
+            onGuardBuy: (msg) => {
+                const gift = {
+                    type: "guard",
+                    timestamp: msg.timestamp,
+                    name: msg.body.gift_name,
+                    price: msg.body.price,
+                    count: 1,
+                    level: msg.body.guard_level,
+                    sender: {
+                        uid: String(msg.body.user.uid),
+                        name: msg.body.user.uname,
+                        avatar: msg.body.user.face,
+                        extra: {
+                            badgeName: msg.body.user.badge?.name,
+                            badgeLevel: msg.body.user.badge?.level,
+                        },
+                    },
+                };
+                this.emit("Message", gift);
+            },
+            onGift: (msg) => {
+                const gift = {
+                    type: "give_gift",
+                    timestamp: msg.timestamp,
+                    name: msg.body.gift_name,
+                    count: msg.body.amount,
+                    price: msg.body.coin_type === "silver" ? 0 : msg.body.price / 1000,
+                    sender: {
+                        uid: String(msg.body.user.uid),
+                        name: msg.body.user.uname,
+                        avatar: msg.body.user.face,
+                        extra: {
+                            badgeName: msg.body.user.badge?.name,
+                            badgeLevel: msg.body.user.badge?.level,
+                        },
+                    },
+                    extra: {
+                        hits: msg.body.combo?.combo_num,
+                    },
+                };
+                this.emit("Message", gift);
+            },
+        };
+        this.client = startListen(this.roomId, handler, {
+            ws: {
+                headers: {
+                    Cookie: this.auth ?? "",
+                },
+                uid: this.uid ?? 0,
+            },
+        });
+        this.client.live.on("error", (err) => {
+            this.retryCount -= 1;
+            if (this.retryCount > 0) {
+                setTimeout(() => {
+                    this.client && this.client.reconnect();
+                }, 2000 * (5 - this.retryCount));
+            }
+            this.emit("error", err);
+        });
+    }
+    stop() {
+        this.client?.close();
+    }
+}
+export default DanmaClient;

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-import { RecorderProvider } from "@bililive-tools/manager";
+import type { RecorderProvider } from "@bililive-tools/manager";
 export declare const provider: RecorderProvider<Record<string, unknown>>;

package/lib/index.js

@@ -1,9 +1,9 @@
 import path from "node:path";
 import mitt from "mitt";
-import { createFFMPEGBuilder, defaultFromJSON, defaultToJSON, genRecorderUUID, genRecordUUID, StreamManager, utils, } from "@bililive-tools/manager";
+import { defaultFromJSON, defaultToJSON, genRecorderUUID, genRecordUUID, utils, FFMPEGRecorder, } from "@bililive-tools/manager";
 import { getInfo, getStream, getLiveStatus, getStrictStream } from "./stream.js";
-import { assertStringType, ensureFolderExist, createInvalidStreamChecker } from "./utils.js";
-import { startListen } from "./blive-message-listener/index.js";
+import { ensureFolderExist } from "./utils.js";
+import DanmaClient from "./danma.js";
 function createRecorder(opts) {
     // 内部实现时，应该只有 proxy 包裹的那一层会使用这个 recorder 标识符，不应该有直接通过
     // 此标志来操作这个对象的地方，不然会跳过 proxy 的拦截。
@@ -68,27 +68,32 @@ const ffmpegOutputOptions = [
     "faststart+frag_keyframe+empty_moov",
     "-min_frag_duration",
     "60000000",
+];
+const ffmpegInputOptions = [
     "-reconnect",
     "1",
     "-reconnect_streamed",
     "1",
     "-reconnect_delay_max",
-    "5",
+    "10",
     "-rw_timeout",
-    "5000000",
+    "15000000",
+    "-headers",
+    "Referer:https://live.bilibili.com/",
 ];
-const checkLiveStatusAndRecord = async function ({ getSavePath, qualityRetry, banLiveId, }) {
+const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, banLiveId, }) {
     if (this.recordHandle != null)
         return this.recordHandle;
-    const { living, liveId } = await getLiveStatus(this.channelId);
+    const { living, liveId, owner: _owner, title: _title } = await getLiveStatus(this.channelId);
     this.liveInfo = {
         living,
-        owner: "",
-        title: "",
+        owner: _owner,
+        title: _title,
         avatar: "",
         cover: "",
-        liveId: "",
+        liveId: liveId,
     };
+    this.emit("LiveStart", { liveId });
     if (liveId === banLiveId) {
         this.tempStopIntervalCheck = true;
     }
@@ -100,15 +105,20 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, qualityRetry, ba
     if (!living)
         return null;
     const liveInfo = await getInfo(this.channelId);
-    const { owner, title, roomId, cover } = liveInfo;
+    const { owner, title, roomId } = liveInfo;
     this.liveInfo = liveInfo;
-    this.state = "recording";
     let res;
     // TODO: 先不做什么错误处理，就简单包一下预期上会有错误的地方
     try {
-        let strictQuality = !!this.qualityRetry;
-        if (qualityRetry !== undefined) {
-            strictQuality = !!qualityRetry;
+        let strictQuality = false;
+        if (this.qualityRetry > 0) {
+            strictQuality = true;
+        }
+        if (this.qualityMaxRetry < 0) {
+            strictQuality = true;
+        }
+        if (isManualStart) {
+            strictQuality = false;
         }
         res = await getStream({
             channelId: this.channelId,
@@ -124,6 +134,7 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, qualityRetry, ba
         this.state = "idle";
         throw err;
     }
+    this.state = "recording";
     const { streamOptions, currentStream: stream, sources: availableSources, streams: availableStreams, } = res;
     this.availableStreams = availableStreams.map((s) => s.desc);
     this.availableSources = availableSources.map((s) => s.name);
@@ -145,16 +156,40 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, qualityRetry, ba
                 format_name: streamOptions.format_name,
                 codec_name: streamOptions.codec_name,
             });
-            stream.url = url;
+            if (this.recordHandle) {
+                this.recordHandle.url = url;
+            }
             this.emit("DebugLog", {
                 type: "common",
                 text: `update stream: ${url}`,
             });
         }, 50 * 60 * 1000);
     }
-    // console.log(streamOptions.protocol_name, url);
-    const savePath = getSavePath({ owner, title });
-    const hasSegment = !!this.segment;
+    let isEnded = false;
+    const onEnd = (...args) => {
+        if (isEnded)
+            return;
+        isEnded = true;
+        this.emit("DebugLog", {
+            type: "common",
+            text: `ffmpeg end, reason: ${JSON.stringify(args, (_, v) => (v instanceof Error ? v.stack : v))}`,
+        });
+        const reason = args[0] instanceof Error ? args[0].message : String(args[0]);
+        this.recordHandle?.stop(reason);
+    };
+    const recorder = new FFMPEGRecorder({
+        url: url,
+        outputOptions: ffmpegOutputOptions,
+        inputOptions: ffmpegInputOptions,
+        segment: this.segment ?? 0,
+        getSavePath: (opts) => getSavePath({ owner, title, startTime: opts.startTime }),
+        isHls: streamOptions.protocol_name === "http_hls",
+        disableDanma: this.disableProvideCommentsWhenRecording,
+    }, onEnd);
+    const savePath = getSavePath({
+        owner,
+        title,
+    });
     try {
         ensureFolderExist(savePath);
     }
@@ -162,221 +197,70 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, qualityRetry, ba
         this.state = "idle";
         throw err;
     }
-    const streamManager = new StreamManager(this, getSavePath, owner, title, savePath, hasSegment);
     const handleVideoCreated = async ({ filename }) => {
-        const extraDataController = streamManager?.getExtraDataController();
+        this.emit("videoFileCreated", { filename });
+        const extraDataController = recorder.getExtraDataController();
         extraDataController?.setMeta({
             room_id: String(roomId),
             platform: provider?.id,
             liveStartTimestamp: liveInfo.startTime?.getTime(),
+            recordStopTimestamp: Date.now(),
+            title: title,
+            user_name: owner,
         });
-        if (this.saveCover) {
-            const coverPath = utils.replaceExtName(filename, ".jpg");
-            utils.downloadImage(cover, coverPath);
-        }
     };
-    this.on("videoFileCreated", handleVideoCreated);
-    let client = null;
+    recorder.on("videoFileCreated", handleVideoCreated);
+    recorder.on("videoFileCompleted", ({ filename }) => {
+        this.emit("videoFileCompleted", { filename });
+    });
+    recorder.on("DebugLog", (data) => {
+        this.emit("DebugLog", data);
+    });
+    recorder.on("progress", (progress) => {
+        if (this.recordHandle) {
+            this.recordHandle.progress = progress;
+        }
+        this.emit("progress", progress);
+    });
+    let danmaClient = new DanmaClient(roomId, this.auth, this.uid);
     if (!this.disableProvideCommentsWhenRecording) {
-        const handler = {
-            onIncomeDanmu: (msg) => {
-                const extraDataController = streamManager.getExtraDataController();
-                if (!extraDataController)
-                    return;
-                let content = msg.body.content;
-                // 去除前后空格，回车，换行
-                content = content.replace(/(^\s*)|(\s*$)/g, "").replace(/[\r\n]/g, "");
-                if (content === "")
-                    return;
-                const comment = {
-                    type: "comment",
-                    timestamp: msg.timestamp,
-                    text: content,
-                    color: msg.body.content_color,
-                    mode: msg.body.type,
-                    sender: {
-                        uid: String(msg.body.user.uid),
-                        name: msg.body.user.uname,
-                        avatar: msg.body.user.face,
-                        extra: {
-                            badgeName: msg.body.user.badge?.name,
-                            badgeLevel: msg.body.user.badge?.level,
-                        },
-                    },
-                };
-                this.emit("Message", comment);
-                extraDataController.addMessage(comment);
-            },
-            onIncomeSuperChat: (msg) => {
-                const extraDataController = streamManager.getExtraDataController();
-                if (!extraDataController)
-                    return;
-                if (this.saveSCDanma === false)
-                    return;
-                const content = msg.body.content.replaceAll(/[\r\n]/g, "");
-                // console.log(msg.id, msg.body);
-                const comment = {
-                    type: "super_chat",
-                    timestamp: msg.timestamp,
-                    text: content,
-                    price: msg.body.price,
-                    sender: {
-                        uid: String(msg.body.user.uid),
-                        name: msg.body.user.uname,
-                        avatar: msg.body.user.face,
-                        extra: {
-                            badgeName: msg.body.user.badge?.name,
-                            badgeLevel: msg.body.user.badge?.level,
-                        },
-                    },
-                };
-                this.emit("Message", comment);
-                extraDataController.addMessage(comment);
-            },
-            onGuardBuy: (msg) => {
-                const extraDataController = streamManager.getExtraDataController();
-                if (!extraDataController)
-                    return;
-                // console.log("guard", msg);
-                if (this.saveGiftDanma === false)
-                    return;
-                const gift = {
-                    type: "guard",
-                    timestamp: msg.timestamp,
-                    name: msg.body.gift_name,
-                    price: msg.body.price,
-                    count: 1,
-                    level: msg.body.guard_level,
-                    sender: {
-                        uid: String(msg.body.user.uid),
-                        name: msg.body.user.uname,
-                        avatar: msg.body.user.face,
-                        extra: {
-                            badgeName: msg.body.user.badge?.name,
-                            badgeLevel: msg.body.user.badge?.level,
-                        },
-                    },
-                };
-                this.emit("Message", gift);
-                extraDataController.addMessage(gift);
-            },
-            onGift: (msg) => {
-                const extraDataController = streamManager.getExtraDataController();
-                if (!extraDataController)
-                    return;
-                // console.log("gift", msg);
-                if (this.saveGiftDanma === false)
-                    return;
-                const gift = {
-                    type: "give_gift",
-                    timestamp: msg.timestamp,
-                    name: msg.body.gift_name,
-                    count: msg.body.amount,
-                    price: msg.body.coin_type === "silver" ? 0 : msg.body.price / 1000,
-                    sender: {
-                        uid: String(msg.body.user.uid),
-                        name: msg.body.user.uname,
-                        avatar: msg.body.user.face,
-                        extra: {
-                            badgeName: msg.body.user.badge?.name,
-                            badgeLevel: msg.body.user.badge?.level,
-                        },
-                    },
-                    extra: {
-                        hits: msg.body.combo?.combo_num,
-                    },
-                };
-                this.emit("Message", gift);
-                extraDataController.addMessage(gift);
-            },
-        };
-        // 弹幕协议不能走短 id，所以不能直接用 channelId。
-        client = startListen(roomId, handler, {
-            ws: {
-                headers: {
-                    Cookie: this.auth ?? "",
-                },
-                uid: this.uid ?? 0,
-            },
+        danmaClient = danmaClient.on("Message", (msg) => {
+            const extraDataController = recorder.getExtraDataController();
+            if (!extraDataController)
+                return;
+            if (msg.type === "super_chat" && this.saveSCDanma === false)
+                return;
+            if ((msg.type === "give_gift" || msg.type === "guard") && this.saveGiftDanma === false)
+                return;
+            this.emit("Message", msg);
+            extraDataController.addMessage(msg);
         });
+        danmaClient.start();
     }
-    let isEnded = false;
-    const onEnd = (...args) => {
-        if (isEnded)
-            return;
-        isEnded = true;
-        this.emit("DebugLog", {
-            type: "common",
-            text: `ffmpeg end, reason: ${JSON.stringify(args, (_, v) => (v instanceof Error ? v.stack : v))}`,
-        });
-        const reason = args[0] instanceof Error ? args[0].message : String(args[0]);
-        this.recordHandle?.stop(reason);
-    };
-    const isInvalidStream = createInvalidStreamChecker();
-    const timeoutChecker = utils.createTimeoutChecker(() => onEnd("ffmpeg timeout"), 3 * 10e3);
-    const command = createFFMPEGBuilder()
-        .input(url)
-        .addInputOptions("-user_agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:107.0) Gecko/20100101 Firefox/107.0", "-headers", "Referer: https://live.bilibili.com/")
-        .outputOptions(ffmpegOutputOptions)
-        .output(streamManager.videoFilePath)
-        .on("start", async () => {
-        try {
-            await streamManager.handleVideoStarted();
-        }
-        catch (err) {
-            onEnd("ffmpeg start error");
-            this.emit("DebugLog", { type: "common", text: String(err) });
-        }
-    })
-        .on("error", onEnd)
-        .on("end", () => onEnd("finished"))
-        .on("stderr", async (stderrLine) => {
-        assertStringType(stderrLine);
-        if (utils.isFfmpegStartSegment(stderrLine)) {
-            try {
-                await streamManager.handleVideoStarted(stderrLine);
-            }
-            catch (err) {
-                onEnd("ffmpeg start error");
-                this.emit("DebugLog", { type: "common", text: String(err) });
-            }
-        }
-        this.emit("DebugLog", { type: "ffmpeg", text: stderrLine });
-        if (isInvalidStream(stderrLine)) {
-            onEnd("invalid stream");
-        }
-    })
-        .on("stderr", timeoutChecker.update);
-    if (hasSegment) {
-        command.outputOptions("-f", "segment", "-segment_time", String(this.segment * 60), "-reset_timestamps", "1");
-    }
-    const ffmpegArgs = command._getArguments();
-    command.run();
+    const ffmpegArgs = recorder.getArguments();
+    recorder.run();
     const stop = utils.singleton(async (reason) => {
         if (!this.recordHandle)
             return;
         this.state = "stopping-record";
-        // TODO: emit update event
-        timeoutChecker.stop();
+        intervalId && clearInterval(intervalId);
+        danmaClient.stop();
         try {
-            // @ts-ignore
-            command.ffmpegProc?.stdin?.write("q");
-            client?.close();
-            this.usedStream = undefined;
-            this.usedSource = undefined;
-            await streamManager.handleVideoCompleted();
+            await recorder.stop();
         }
         catch (err) {
-            // TODO: 这个 stop 经常报错，这里先把错误吞掉，以后再处理。
-            this.emit("DebugLog", { type: "common", text: String(err) });
+            this.emit("DebugLog", {
+                type: "common",
+                text: `stop ffmpeg error: ${String(err)}`,
+            });
         }
+        this.usedStream = undefined;
+        this.usedSource = undefined;
         this.emit("RecordStop", { recordHandle: this.recordHandle, reason });
-        this.off("videoFileCreated", handleVideoCreated);
         this.recordHandle = undefined;
         this.liveInfo = undefined;
         this.state = "idle";
         this.qualityRetry = this.qualityMaxRetry;
-        intervalId && clearInterval(intervalId);
     });
     this.recordHandle = {
         id: genRecordUUID(),

package/lib/stream.d.ts

@@ -11,13 +11,14 @@ export declare function getStrictStream(roomId: number, options: {
 export declare function getLiveStatus(channelId: string): Promise<{
     living: boolean;
     liveId: string;
+    owner: string;
+    title: string;
 }>;
 export declare function getInfo(channelId: string): Promise<{
     living: boolean;
     owner: string;
     title: string;
     roomId: number;
-    shortId: number;
     avatar: string;
     cover: string;
     startTime: Date;
@@ -39,7 +40,7 @@ export declare function getStream(opts: Pick<Recorder, "channelId" | "quality">
     sources: SourceProfile[];
     name: string;
     streamOptions: {
-        protocol_name: string;
+        protocol_name: "http_stream" | "http_hls";
         format_name: string;
         codec_name: string;
         qn: number;

package/lib/stream.js

@@ -13,12 +13,25 @@ export async function getStrictStream(roomId, options) {
     return url;
 }
 export async function getLiveStatus(channelId) {
+    const obj = await getRoomBaseInfo(Number(channelId));
+    const data = obj[Number(channelId)];
+    if (data) {
+        const startTime = new Date(data.live_time);
+        return {
+            living: data.live_status === 1 && !data.is_encrypted,
+            liveId: utils.md5(`${channelId}-${startTime?.getTime()}`),
+            owner: data.uname,
+            title: data.title,
+        };
+    }
     const roomInit = await getRoomInit(Number(channelId));
     const startTime = new Date(roomInit.live_time * 1000);
     return {
         living: roomInit.live_status === 1 && !roomInit.encrypted,
         liveId: utils.md5(`${roomInit.room_id}-${startTime?.getTime()}`),
         ...roomInit,
+        owner: "",
+        title: "",
     };
 }
 export async function getInfo(channelId) {
@@ -38,7 +51,6 @@ export async function getInfo(channelId) {
             avatar: "",
             cover: status.cover,
             roomId: roomInit.room_id,
-            shortId: roomInit.short_id,
             liveId: utils.md5(`${roomInit.room_id}-${startTime?.getTime()}`),
         };
     }
@@ -51,7 +63,6 @@ export async function getInfo(channelId) {
         avatar: status.face,
         cover: status.cover_from_user,
         roomId: roomInit.room_id,
-        shortId: roomInit.short_id,
         startTime: startTime,
         liveId: utils.md5(`${roomInit.room_id}-${startTime.getTime()}`),
     };
@@ -68,13 +79,13 @@ async function getLiveInfo(roomIdOrShortId, opts) {
         },
         {
             protocol_name: "http_hls",
-            format_name: "fmp4",
+            format_name: "ts",
             codec_name: "avc",
             sort: 8,
         },
         {
             protocol_name: "http_hls",
-            format_name: "ts",
+            format_name: "fmp4",
             codec_name: "avc",
             sort: 7,
         },
@@ -86,13 +97,13 @@ async function getLiveInfo(roomIdOrShortId, opts) {
         },
         {
             protocol_name: "http_hls",
-            format_name: "fmp4",
+            format_name: "ts",
             codec_name: "hevc",
             sort: 5,
         },
         {
             protocol_name: "http_hls",
-            format_name: "ts",
+            format_name: "fmp4",
             codec_name: "hevc",
             sort: 4,
         },

package/lib/utils.d.ts

@@ -20,4 +20,4 @@ export declare function assert(assertion: unknown, msg?: string): asserts assert
 export declare function assertStringType(data: unknown, msg?: string): asserts data is string;
 export declare function assertNumberType(data: unknown, msg?: string): asserts data is number;
 export declare function assertObjectType(data: unknown, msg?: string): asserts data is object;
-export declare function createInvalidStreamChecker(): (ffmpegLogLine: string) => boolean;
+export declare function createInvalidStreamChecker(count?: number): (ffmpegLogLine: string) => boolean;

package/lib/utils.js

@@ -59,7 +59,7 @@ export function assertNumberType(data, msg) {
 export function assertObjectType(data, msg) {
     assert(typeof data === "object", msg);
 }
-export function createInvalidStreamChecker() {
+export function createInvalidStreamChecker(count = 10) {
     let prevFrame = 0;
     let frameUnchangedCount = 0;
     return (ffmpegLogLine) => {
@@ -68,7 +68,7 @@ export function createInvalidStreamChecker() {
             const [, frameText] = streamInfo;
             const frame = Number(frameText);
             if (frame === prevFrame) {
-                if (++frameUnchangedCount >= 10) {
+                if (++frameUnchangedCount >= count) {
                     return true;
                 }
             }
@@ -78,9 +78,6 @@ export function createInvalidStreamChecker() {
             }
             return false;
         }
-        // if (ffmpegLogLine.includes("HTTP error 404 Not Found")) {
-        //   return true;
-        // }
         return false;
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bililive-tools/bilibili-recorder",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "bililive-tools bilibili recorder implemention",
   "main": "./lib/index.js",
   "type": "module",
@@ -39,7 +39,7 @@
     "tiny-bilibili-ws": "^1.0.1",
     "lodash-es": "^4.17.21",
     "axios": "^1.7.8",
-    "@bililive-tools/manager": "1.0.1"
+    "@bililive-tools/manager": "^1.1.0"
   },
   "scripts": {
     "build": "tsc",