@bililive-tools/manager 1.0.1 → 1.1.0

package/README.md

@@ -6,6 +6,8 @@
 
 # 安装
 
+**建议所有录制器和manager包都升级到最新版，我不会对兼容性做过多考虑**
+
 `npm i @bililive-tools/manager`
 
 ## 支持的平台
@@ -124,6 +126,14 @@ setFFMPEGPath("ffmpeg.exe");
 
 录制文件结束
 
+### RecorderProgress
+
+ffmpeg录制相关数据
+
+### RecoderLiveStart
+
+直播开始，**并非录制开始，同一场直播不会重复触发**
+
 # 协议
 
 与原项目保存一致为 LGPL

package/lib/FFMPEGRecorder.d.ts

@@ -0,0 +1,36 @@
+import EventEmitter from "node:events";
+export declare class FFMPEGRecorder extends EventEmitter {
+    private onEnd;
+    private command;
+    private streamManager;
+    private timeoutChecker;
+    hasSegment: boolean;
+    getSavePath: (data: {
+        startTime: number;
+    }) => string;
+    segment: number;
+    ffmpegOutputOptions: string[];
+    inputOptions: string[];
+    isHls: boolean;
+    disableDanma: boolean;
+    url: string;
+    constructor(opts: {
+        url: string;
+        getSavePath: (data: {
+            startTime: number;
+        }) => string;
+        segment: number;
+        outputOptions: string[];
+        inputOptions?: string[];
+        isHls?: boolean;
+        disableDanma?: boolean;
+    }, onEnd: (...args: unknown[]) => void);
+    private createCommand;
+    formatLine(line: string): {
+        time: string | null;
+    } | null;
+    run(): void;
+    getArguments(): string[];
+    stop(): Promise<void>;
+    getExtraDataController(): import("./record_extra_data_controller.js").RecordExtraDataController | null;
+}

package/lib/FFMPEGRecorder.js

@@ -0,0 +1,108 @@
+import EventEmitter from "node:events";
+import { createFFMPEGBuilder, StreamManager, utils } from "./index.js";
+import { createInvalidStreamChecker, assert } from "./utils.js";
+export class FFMPEGRecorder extends EventEmitter {
+    onEnd;
+    command;
+    streamManager;
+    timeoutChecker;
+    hasSegment;
+    getSavePath;
+    segment;
+    ffmpegOutputOptions = [];
+    inputOptions = [];
+    isHls = false;
+    disableDanma = false;
+    url;
+    constructor(opts, onEnd) {
+        super();
+        this.onEnd = onEnd;
+        const hasSegment = !!opts.segment;
+        this.disableDanma = opts.disableDanma ?? false;
+        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma);
+        this.timeoutChecker = utils.createTimeoutChecker(() => this.onEnd("ffmpeg timeout"), 3 * 10e3);
+        this.hasSegment = hasSegment;
+        this.getSavePath = opts.getSavePath;
+        this.ffmpegOutputOptions = opts.outputOptions;
+        this.inputOptions = opts.inputOptions ?? [];
+        this.url = opts.url;
+        this.segment = opts.segment;
+        this.isHls = opts.isHls ?? false;
+        this.command = this.createCommand();
+        this.streamManager.on("videoFileCreated", ({ filename }) => {
+            this.emit("videoFileCreated", { filename });
+        });
+        this.streamManager.on("videoFileCompleted", ({ filename }) => {
+            this.emit("videoFileCompleted", { filename });
+        });
+        this.streamManager.on("DebugLog", (data) => {
+            this.emit("DebugLog", data);
+        });
+    }
+    createCommand() {
+        const invalidCount = this.isHls ? 35 : 15;
+        const isInvalidStream = createInvalidStreamChecker(invalidCount);
+        const command = createFFMPEGBuilder()
+            .input(this.url)
+            .inputOptions([
+            ...this.inputOptions,
+            "-user_agent",
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36",
+        ])
+            .outputOptions(this.ffmpegOutputOptions)
+            .output(this.streamManager.videoFilePath)
+            .on("error", this.onEnd)
+            .on("end", () => this.onEnd("finished"))
+            .on("stderr", async (stderrLine) => {
+            assert(typeof stderrLine === "string");
+            await this.streamManager.handleVideoStarted(stderrLine);
+            // TODO:解析时间
+            this.emit("DebugLog", { type: "ffmpeg", text: stderrLine });
+            const info = this.formatLine(stderrLine);
+            if (info) {
+                this.emit("progress", info);
+            }
+            if (isInvalidStream(stderrLine)) {
+                this.onEnd("invalid stream");
+            }
+        })
+            .on("stderr", this.timeoutChecker.update);
+        if (this.hasSegment) {
+            command.outputOptions("-f", "segment", "-segment_time", String(this.segment * 60), "-reset_timestamps", "1");
+        }
+        return command;
+    }
+    formatLine(line) {
+        if (!line.includes("time=")) {
+            return null;
+        }
+        let time = null;
+        const timeMatch = line.match(/time=([0-9:.]+)/);
+        if (timeMatch) {
+            time = timeMatch[1];
+        }
+        return {
+            time,
+        };
+    }
+    run() {
+        this.command.run();
+    }
+    getArguments() {
+        return this.command._getArguments();
+    }
+    async stop() {
+        this.timeoutChecker.stop();
+        try {
+            // @ts-ignore
+            this.command.ffmpegProc?.stdin?.write("q");
+            await this.streamManager.handleVideoCompleted();
+        }
+        catch (err) {
+            this.emit("DebugLog", { type: "common", text: String(err) });
+        }
+    }
+    getExtraDataController() {
+        return this.streamManager?.getExtraDataController();
+    }
+}

package/lib/api.d.ts

@@ -1 +1 @@
-export declare function getBiliStatusInfoByUIDs<UID extends number>(userIds: UID[]): Promise<Record<string, boolean>>;
+export declare function getBiliStatusInfoByRoomIds<RoomId extends number>(RoomIds: RoomId[]): Promise<Record<string, boolean>>;

package/lib/api.js

@@ -6,15 +6,19 @@ const requester = axios.create({
     // 但会导致请求报错 "Client network socket disconnected before secure TLS connection was established"。
     proxy: false,
 });
-export async function getBiliStatusInfoByUIDs(userIds) {
-    const res = await requester.get("http://api.live.bilibili.com/room/v1/Room/get_status_info_by_uids", {
-        params: { uids: userIds },
-    });
+export async function getBiliStatusInfoByRoomIds(RoomIds) {
+    const roomParams = `${RoomIds.map((id) => `room_ids=${id}`).join("&")}`;
+    const res = await requester.get(`https://api.live.bilibili.com/xlive/web-room/v1/index/getRoomBaseInfo?${roomParams}&req_biz=web_room_componet`);
     assert(res.data.code === 0, `Unexpected resp, code ${res.data.code}, msg ${res.data.message}`);
     const obj = {};
-    for (const uid of userIds) {
-        const data = res.data.data?.[uid];
-        obj[uid] = data?.live_status === 1;
+    for (const roomId of RoomIds) {
+        try {
+            const data = res.data.data.by_room_ids[roomId];
+            obj[roomId] = data?.live_status === 1;
+        }
+        catch (e) {
+            continue;
+        }
     }
     return obj;
 }

package/lib/common.d.ts

@@ -3,7 +3,9 @@ export type ChannelId = string;
 export declare const Qualities: readonly ["lowest", "low", "medium", "high", "highest"];
 export declare const BiliQualities: readonly [30000, 20000, 10000, 400, 250, 150, 80];
 export declare const DouyuQualities: readonly [0, 2, 3, 4, 8];
-export type Quality = (typeof Qualities)[number] | (typeof BiliQualities)[number] | (typeof DouyuQualities)[number];
+export declare const HuYaQualities: readonly [0, 20000, 14100, 14000, 10000, 8000, 4200, 4000, 2000, 500];
+export declare const DouYinQualities: readonly ["origin", "uhd", "hd", "sd", "ld", "ao"];
+export type Quality = (typeof Qualities)[number] | (typeof BiliQualities)[number] | (typeof DouyuQualities)[number] | (typeof HuYaQualities)[number] | (typeof DouYinQualities)[number];
 export interface MessageSender<E extends AnyObject = UnknownObject> {
     uid?: string;
     name: string;

package/lib/common.js

@@ -1,3 +1,6 @@
 export const Qualities = ["lowest", "low", "medium", "high", "highest"];
 export const BiliQualities = [30000, 20000, 10000, 400, 250, 150, 80];
 export const DouyuQualities = [0, 2, 3, 4, 8];
+// 14100: 2K HDR；14000：2K；4200：HDR(10M)；0：原画；8000：蓝光8M；4000：蓝光4M；2000：超清；500：流畅
+export const HuYaQualities = [0, 20000, 14100, 14000, 10000, 8000, 4200, 4000, 2000, 500];
+export const DouYinQualities = ["origin", "uhd", "hd", "sd", "ld", "ao"];

package/lib/index.d.ts

@@ -7,6 +7,7 @@ export * from "./common.js";
 export * from "./recorder.js";
 export * from "./manager.js";
 export * from "./record_extra_data_controller.js";
+export * from "./FFMPEGRecorder.js";
 export { utils };
 /**
  * 提供一些 utils

package/lib/index.js

@@ -6,6 +6,7 @@ export * from "./common.js";
 export * from "./recorder.js";
 export * from "./manager.js";
 export * from "./record_extra_data_controller.js";
+export * from "./FFMPEGRecorder.js";
 export { utils };
 /**
  * 提供一些 utils
@@ -34,6 +35,7 @@ export function defaultToJSON(provider, recorder) {
             "disableProvideCommentsWhenRecording",
             "liveInfo",
             "uid",
+            "titleKeywords",
         ]),
     };
 }
@@ -54,6 +56,5 @@ export const createFFMPEGBuilder = (...args) => {
     return ffmpeg(...args);
 };
 export function getDataFolderPath(provider) {
-    // TODO: 改成 AppData 之类的目录
     return "./" + provider.id;
 }

package/lib/manager.d.ts

@@ -1,6 +1,6 @@
 import { Emitter } from "mitt";
 import { ChannelId, Message } from "./common.js";
-import { RecorderCreateOpts, Recorder, SerializedRecorder, RecordHandle, DebugLog } from "./recorder.js";
+import { RecorderCreateOpts, Recorder, SerializedRecorder, RecordHandle, DebugLog, Progress } from "./recorder.js";
 import { AnyObject, UnknownObject } from "./utils.js";
 import { StreamManager } from "./streamManager.js";
 export interface RecorderProvider<E extends AnyObject> {
@@ -18,7 +18,7 @@ export interface RecorderProvider<E extends AnyObject> {
     fromJSON: <T extends SerializedRecorder<E>>(this: RecorderProvider<E>, json: T) => Recorder<E>;
     setFFMPEGOutputArgs: (this: RecorderProvider<E>, args: string[]) => void;
 }
-declare const configurableProps: readonly ["savePathRule", "autoRemoveSystemReservedChars", "autoCheckLiveStatusAndRecord", "autoCheckInterval", "ffmpegOutputArgs", "biliBatchQuery"];
+declare const configurableProps: readonly ["savePathRule", "autoRemoveSystemReservedChars", "autoCheckInterval", "ffmpegOutputArgs", "biliBatchQuery"];
 type ConfigurableProp = (typeof configurableProps)[number];
 export interface RecorderManager<ME extends UnknownObject, P extends RecorderProvider<AnyObject> = RecorderProvider<UnknownObject>, PE extends AnyObject = GetProviderExtra<P>, E extends AnyObject = ME & PE> extends Emitter<{
     error: {
@@ -41,6 +41,13 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
         recorder: Recorder<E>;
         filename: string;
     };
+    RecorderProgress: {
+        recorder: Recorder<E>;
+        progress: Progress;
+    };
+    RecoderLiveStart: {
+        recorder: Recorder<E>;
+    };
     RecordStop: {
         recorder: Recorder<E>;
         recordHandle: RecordHandle;
@@ -68,7 +75,6 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     removeRecorder: (this: RecorderManager<ME, P, PE, E>, recorder: Recorder<E>) => void;
     startRecord: (this: RecorderManager<ME, P, PE, E>, id: string) => Promise<Recorder<E> | undefined>;
     stopRecord: (this: RecorderManager<ME, P, PE, E>, id: string) => Promise<Recorder<E> | undefined>;
-    autoCheckLiveStatusAndRecord: boolean;
     autoCheckInterval: number;
     isCheckLoopRunning: boolean;
     startCheckLoop: (this: RecorderManager<ME, P, PE, E>) => void;

package/lib/manager.js

@@ -2,13 +2,12 @@ import path from "node:path";
 import mitt from "mitt";
 import { omit, range } from "lodash-es";
 import { parseArgsStringToArgv } from "string-argv";
-import { getBiliStatusInfoByUIDs } from "./api.js";
-import { formatDate, removeSystemReservedChars, formatTemplate, } from "./utils.js";
+import { getBiliStatusInfoByRoomIds } from "./api.js";
+import { formatDate, removeSystemReservedChars, formatTemplate, replaceExtName, downloadImage, } from "./utils.js";
 import { StreamManager } from "./streamManager.js";
 const configurableProps = [
     "savePathRule",
     "autoRemoveSystemReservedChars",
-    "autoCheckLiveStatusAndRecord",
     "autoCheckInterval",
     "ffmpegOutputArgs",
     "biliBatchQuery",
@@ -21,11 +20,12 @@ export function createRecorderManager(opts) {
     let checkLoopTimer;
     const multiThreadCheck = async (manager) => {
         const handleBatchQuery = async (obj) => {
-            for (const recorder of recorders) {
-                if (recorder.extra.recorderUid == null)
-                    continue;
-                const isLive = obj[recorder.extra.recorderUid];
-                if (isLive) {
+            for (const recorder of recorders
+                .filter((r) => !r.disableAutoCheck)
+                .filter((r) => r.providerId === "Bilibili")) {
+                const isLive = obj[recorder.channelId];
+                // 如果是undefined，说明这个接口查不到相关信息，使用录制器内的再查一次
+                if (isLive === true || isLive === undefined) {
                     await recorder.checkLiveStatusAndRecord({
                         getSavePath(data) {
                             return genSavePathFromRule(manager, recorder, data);
@@ -41,25 +41,19 @@ export function createRecorderManager(opts) {
         let needCheckRecorders = recorders.filter((r) => !r.disableAutoCheck);
         let threads = [];
         if (manager.biliBatchQuery) {
-            const biliNeedCheckRecorders = needCheckRecorders.filter((r) => r.providerId === "Bilibili" && r.extra?.recorderUid);
-            needCheckRecorders = needCheckRecorders.filter((r) => {
-                if (r.providerId !== "Bilibili")
-                    return true;
-                if (r.providerId === "Bilibili" && !r.extra?.recorderUid)
-                    return true;
-                return false;
-            });
-            const uids = biliNeedCheckRecorders.map((r) => r.extra?.recorderUid);
-            // console.log("uids", uids);
+            const biliNeedCheckRecorders = needCheckRecorders
+                .filter((r) => r.providerId === "Bilibili")
+                .filter((r) => r.recordHandle == null);
+            needCheckRecorders = needCheckRecorders.filter((r) => r.providerId !== "Bilibili");
+            const roomIds = biliNeedCheckRecorders.map((r) => r.channelId).map(Number);
             try {
-                if (uids.length !== 0) {
-                    const biliStatus = await getBiliStatusInfoByUIDs(uids);
-                    // console.log("biliStatus", biliStatus);
+                if (roomIds.length !== 0) {
+                    const biliStatus = await getBiliStatusInfoByRoomIds(roomIds);
                     threads.push(handleBatchQuery(biliStatus));
                 }
             }
             catch (err) {
-                manager.emit("error", { source: "getBiliStatusInfoByUIDs", err });
+                manager.emit("error", { source: "getBiliStatusInfoByRoomIds", err });
             }
         }
         const checkOnce = async () => {
@@ -88,6 +82,8 @@ export function createRecorderManager(opts) {
     };
     // 用于记录暂时被 ban 掉的直播间
     const tempBanObj = {};
+    // 用于是否触发LiveStart事件，不要重复触发
+    const liveStartObj = {};
     const manager = {
         // @ts-ignore
         ...mitt(),
@@ -106,12 +102,28 @@ export function createRecorderManager(opts) {
             this.recorders.push(recorder);
             recorder.on("RecordStart", (recordHandle) => this.emit("RecordStart", { recorder, recordHandle }));
             recorder.on("RecordSegment", (recordHandle) => this.emit("RecordSegment", { recorder, recordHandle }));
-            recorder.on("videoFileCreated", ({ filename }) => this.emit("videoFileCreated", { recorder, filename }));
+            recorder.on("videoFileCreated", ({ filename }) => {
+                if (recorder.saveCover && recorder?.liveInfo?.cover) {
+                    const coverPath = replaceExtName(filename, ".jpg");
+                    downloadImage(recorder?.liveInfo?.cover, coverPath);
+                }
+                this.emit("videoFileCreated", { recorder, filename });
+            });
             recorder.on("videoFileCompleted", ({ filename }) => this.emit("videoFileCompleted", { recorder, filename }));
             recorder.on("RecordStop", ({ recordHandle, reason }) => this.emit("RecordStop", { recorder, recordHandle, reason }));
             recorder.on("Message", (message) => this.emit("Message", { recorder, message }));
             recorder.on("Updated", (keys) => this.emit("RecorderUpdated", { recorder, keys }));
             recorder.on("DebugLog", (log) => this.emit("RecorderDebugLog", { recorder, ...log }));
+            recorder.on("progress", (progress) => {
+                this.emit("RecorderProgress", { recorder, progress });
+            });
+            recorder.on("LiveStart", ({ liveId }) => {
+                const key = `${recorder.channelId}-${liveId}`;
+                if (liveStartObj[key])
+                    return;
+                liveStartObj[key] = true;
+                this.emit("RecoderLiveStart", { recorder });
+            });
             this.emit("RecorderAdded", recorder);
             return recorder;
         },
@@ -134,7 +146,7 @@ export function createRecorderManager(opts) {
                 getSavePath(data) {
                     return genSavePathFromRule(manager, recorder, data);
                 },
-                qualityRetry: 0,
+                isManualStart: true,
             });
             delete tempBanObj[recorder.channelId];
             recorder.tempStopIntervalCheck = false;
@@ -154,7 +166,6 @@ export function createRecorderManager(opts) {
             }
             return recorder;
         },
-        autoCheckLiveStatusAndRecord: opts.autoCheckLiveStatusAndRecord ?? true,
         autoCheckInterval: opts.autoCheckInterval ?? 1000,
         isCheckLoopRunning: false,
         startCheckLoop() {

package/lib/recorder.d.ts

@@ -14,6 +14,7 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     quality: Quality;
     streamPriorities: string[];
     sourcePriorities: string[];
+    formatPriorities?: string[];
     segment?: number;
     saveGiftDanma?: boolean;
     saveSCDanma?: boolean;
@@ -33,16 +34,24 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     formatName?: FormatName;
     /** 流编码 */
     codecName?: CodecName;
+    /** 选择使用的api，虎牙支持 */
+    api?: "auto" | "web" | "mp";
+    /** 标题关键词，如果直播间标题包含这些关键词，则不会自动录制（仅对斗鱼有效），多个关键词用英文逗号分隔 */
+    titleKeywords?: string;
     extra?: Partial<E>;
 }
 export type SerializedRecorder<E extends AnyObject> = PickRequired<RecorderCreateOpts<E>, "id">;
 export type RecorderState = "idle" | "recording" | "stopping-record";
+export type Progress = {
+    time: string | null;
+};
 export interface RecordHandle {
     id: string;
     stream: string;
     source: string;
     url: string;
     ffmpegArgs?: string[];
+    progress?: Progress;
     savePath: string;
     stop: (this: RecordHandle, reason?: string, tempStopIntervalCheck?: boolean) => Promise<void>;
 }
@@ -64,6 +73,10 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
     videoFileCompleted: {
         filename: string;
     };
+    progress: Progress;
+    LiveStart: {
+        liveId: string;
+    };
     RecordStop: {
         recordHandle: RecordHandle;
         reason?: string;
@@ -95,8 +108,8 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
     getChannelURL: (this: Recorder<E>) => string;
     checkLiveStatusAndRecord: (this: Recorder<E>, opts: {
         getSavePath: GetSavePath;
-        qualityRetry?: number;
         banLiveId?: string;
+        isManualStart?: boolean;
     }) => Promise<RecordHandle | null>;
     recordHandle?: RecordHandle;
     toJSON: (this: Recorder<E>) => SerializedRecorder<E>;

package/lib/streamManager.d.ts

@@ -1,29 +1,28 @@
+import EventEmitter from "node:events";
 import { createRecordExtraDataController } from "./record_extra_data_controller.js";
-import type { Recorder, GetSavePath } from "./recorder.js";
-export declare class Segment {
+export type GetSavePath = (data: {
+    startTime: number;
+}) => string;
+export declare class Segment extends EventEmitter {
     extraDataController: ReturnType<typeof createRecordExtraDataController> | null;
     init: boolean;
     getSavePath: GetSavePath;
-    owner: string;
-    title: string;
-    recorder: Recorder;
     /** 原始的ffmpeg文件名，用于重命名 */
     rawRecordingVideoPath: string;
     /** 输出文件名名，不包含拓展名 */
     outputVideoFilePath: string;
-    constructor(recorder: Recorder, getSavePath: GetSavePath, owner: string, title: string);
+    disableDanma: boolean;
+    constructor(getSavePath: GetSavePath, disableDanma: boolean);
     handleSegmentEnd(): Promise<void>;
     onSegmentStart(stderrLine: string): Promise<void>;
 }
-export declare class StreamManager {
-    private segmentManager;
+export declare class StreamManager extends EventEmitter {
+    private segment;
     private extraDataController;
-    recorder: Recorder;
-    owner: string;
-    title: string;
     recordSavePath: string;
-    constructor(recorder: Recorder, getSavePath: GetSavePath, owner: string, title: string, recordSavePath: string, hasSegment: boolean);
-    handleVideoStarted(stderrLine?: string): Promise<void>;
+    recordStartTime?: number;
+    constructor(getSavePath: GetSavePath, hasSegment: boolean, disableDanma: boolean);
+    handleVideoStarted(stderrLine: string): Promise<void>;
     handleVideoCompleted(): Promise<void>;
     getExtraDataController(): import("./record_extra_data_controller.js").RecordExtraDataController | null;
     get videoFilePath(): string;

package/lib/streamManager.js

@@ -1,41 +1,38 @@
+import EventEmitter from "node:events";
 import fs from "fs-extra";
 import { createRecordExtraDataController } from "./record_extra_data_controller.js";
-import { replaceExtName, ensureFolderExist } from "./utils.js";
-export class Segment {
+import { replaceExtName, ensureFolderExist, isFfmpegStartSegment, isFfmpegStart } from "./utils.js";
+export class Segment extends EventEmitter {
     extraDataController = null;
     init = true;
     getSavePath;
-    owner;
-    title;
-    recorder;
     /** 原始的ffmpeg文件名，用于重命名 */
     rawRecordingVideoPath;
     /** 输出文件名名，不包含拓展名 */
     outputVideoFilePath;
-    constructor(recorder, getSavePath, owner, title) {
+    disableDanma;
+    constructor(getSavePath, disableDanma) {
+        super();
         this.getSavePath = getSavePath;
-        this.owner = owner;
-        this.title = title;
-        this.recorder = recorder;
+        this.disableDanma = disableDanma;
     }
     async handleSegmentEnd() {
         if (!this.outputVideoFilePath) {
-            this.recorder.emit("DebugLog", {
+            this.emit("DebugLog", {
                 type: "common",
                 text: "Should call onSegmentStart first",
             });
             return;
         }
-        this.extraDataController?.setMeta({ recordStopTimestamp: Date.now() });
         try {
             await Promise.all([
                 fs.rename(this.rawRecordingVideoPath, `${this.outputVideoFilePath}.ts`),
                 this.extraDataController?.flush(),
             ]);
-            this.recorder.emit("videoFileCompleted", { filename: `${this.outputVideoFilePath}.ts` });
+            this.emit("videoFileCompleted", { filename: `${this.outputVideoFilePath}.ts` });
         }
         catch (err) {
-            this.recorder.emit("DebugLog", {
+            this.emit("DebugLog", {
                 type: "common",
                 text: "videoFileCompleted error " + String(err),
             });
@@ -48,71 +45,83 @@ export class Segment {
         this.init = false;
         const startTime = Date.now();
         this.outputVideoFilePath = this.getSavePath({
-            owner: this.owner,
-            title: this.title,
             startTime: startTime,
         });
         ensureFolderExist(this.outputVideoFilePath);
-        this.extraDataController = createRecordExtraDataController(`${this.outputVideoFilePath}.json`);
-        this.extraDataController.setMeta({ title: this.title, user_name: this.owner });
+        if (!this.disableDanma) {
+            this.extraDataController = createRecordExtraDataController(`${this.outputVideoFilePath}.json`);
+        }
         const regex = /'([^']+)'/;
         const match = stderrLine.match(regex);
         if (match) {
             const filename = match[1];
             this.rawRecordingVideoPath = filename;
-            this.recorder.emit("videoFileCreated", { filename: `${this.outputVideoFilePath}.ts` });
+            this.emit("videoFileCreated", { filename: `${this.outputVideoFilePath}.ts` });
         }
         else {
-            this.recorder.emit("DebugLog", { type: "ffmpeg", text: "No match found" });
+            this.emit("DebugLog", { type: "ffmpeg", text: "No match found" });
         }
     }
 }
-export class StreamManager {
-    segmentManager = null;
+export class StreamManager extends EventEmitter {
+    segment = null;
     extraDataController = null;
-    recorder;
-    owner;
-    title;
     recordSavePath;
-    constructor(recorder, getSavePath, owner, title, recordSavePath, hasSegment) {
+    recordStartTime;
+    constructor(getSavePath, hasSegment, disableDanma) {
+        super();
+        const recordSavePath = getSavePath({ startTime: Date.now() });
         this.recordSavePath = recordSavePath;
-        this.recorder = recorder;
-        this.owner = owner;
-        this.title = title;
         if (hasSegment) {
-            this.segmentManager = new Segment(recorder, getSavePath, owner, title);
+            this.segment = new Segment(getSavePath, disableDanma);
+            this.segment.on("DebugLog", (data) => {
+                this.emit("DebugLog", data);
+            });
+            this.segment.on("videoFileCreated", (data) => {
+                this.emit("videoFileCreated", data);
+            });
+            this.segment.on("videoFileCompleted", (data) => {
+                this.emit("videoFileCompleted", data);
+            });
         }
         else {
             const extraDataSavePath = replaceExtName(recordSavePath, ".json");
-            this.extraDataController = createRecordExtraDataController(extraDataSavePath);
-            this.extraDataController.setMeta({ title, user_name: owner });
-            // TODO: 增加platform参数，直播开始时间
+            if (!disableDanma) {
+                this.extraDataController = createRecordExtraDataController(extraDataSavePath);
+            }
         }
     }
     async handleVideoStarted(stderrLine) {
-        if (this.segmentManager) {
-            if (stderrLine) {
-                await this.segmentManager.onSegmentStart(stderrLine);
+        if (this.segment) {
+            if (isFfmpegStartSegment(stderrLine)) {
+                await this.segment.onSegmentStart(stderrLine);
             }
         }
         else {
-            this.recorder.emit("videoFileCreated", { filename: this.videoFilePath });
+            // 不能直接在onStart回调进行判断，在某些情况下会链接无法录制的情况
+            if (isFfmpegStart(stderrLine)) {
+                if (this.recordStartTime)
+                    return;
+                this.recordStartTime = Date.now();
+                this.emit("videoFileCreated", { filename: this.videoFilePath });
+            }
         }
     }
     async handleVideoCompleted() {
-        if (this.segmentManager) {
-            await this.segmentManager.handleSegmentEnd();
+        if (this.segment) {
+            await this.segment.handleSegmentEnd();
         }
         else {
-            this.getExtraDataController()?.setMeta({ recordStopTimestamp: Date.now() });
-            await this.getExtraDataController()?.flush();
-            this.recorder.emit("videoFileCompleted", { filename: this.videoFilePath });
+            if (this.recordStartTime) {
+                await this.getExtraDataController()?.flush();
+                this.emit("videoFileCompleted", { filename: this.videoFilePath });
+            }
         }
     }
     getExtraDataController() {
-        return this.segmentManager?.extraDataController || this.extraDataController;
+        return this.segment?.extraDataController || this.extraDataController;
     }
     get videoFilePath() {
-        return this.segmentManager ? `${this.recordSavePath}-PART%03d.ts` : `${this.recordSavePath}.ts`;
+        return this.segment ? `${this.recordSavePath}-PART%03d.ts` : `${this.recordSavePath}.ts`;
     }
 }

package/lib/utils.d.ts

@@ -36,13 +36,22 @@ export declare function assertObjectType(data: unknown, msg?: string): asserts d
 export declare function formatDate(date: Date, format: string): string;
 export declare function removeSystemReservedChars(filename: string): string;
 export declare function isFfmpegStartSegment(line: string): boolean;
+export declare function isFfmpegStart(line: string): boolean;
 export declare const formatTemplate: (string: string, ...args: any[]) => string;
-export declare function createInvalidStreamChecker(): (ffmpegLogLine: string) => boolean;
+export declare function createInvalidStreamChecker(count?: number): (ffmpegLogLine: string) => boolean;
 export declare function createTimeoutChecker(onTimeout: () => void, time: number): {
     update: () => void;
     stop: () => void;
 };
-declare function downloadImage(imageUrl: string, savePath: string): Promise<void>;
+export declare function downloadImage(imageUrl: string, savePath: string): Promise<void>;
+/**
+ * 根据指定的顺序对对象数组进行排序
+ * @param objects 要排序的对象数组
+ * @param order 指定的顺序
+ * @param key 用于排序的键
+ * @returns 排序后的对象数组
+ */
+export declare function sortByKeyOrder<T, K extends keyof T>(objects: T[], order: T[K][], key: K): T[];
 declare const _default: {
     replaceExtName: typeof replaceExtName;
     singleton: typeof singleton;
@@ -59,5 +68,6 @@ declare const _default: {
     downloadImage: typeof downloadImage;
     md5: (str: string) => string;
     uuid: () => `${string}-${string}-${string}-${string}-${string}`;
+    sortByKeyOrder: typeof sortByKeyOrder;
 };
 export default _default;

package/lib/utils.js

@@ -126,6 +126,9 @@ export function removeSystemReservedChars(filename) {
 export function isFfmpegStartSegment(line) {
     return line.includes("Opening ") && line.includes("for writing");
 }
+export function isFfmpegStart(line) {
+    return line.includes("frame=") && line.includes("fps=");
+}
 export const formatTemplate = function template(string, ...args) {
     const nargs = /\{([0-9a-zA-Z_]+)\}/g;
     let params;
@@ -152,7 +155,7 @@ export const formatTemplate = function template(string, ...args) {
         }
     });
 };
-export function createInvalidStreamChecker() {
+export function createInvalidStreamChecker(count = 15) {
     let prevFrame = 0;
     let frameUnchangedCount = 0;
     return (ffmpegLogLine) => {
@@ -161,7 +164,7 @@ export function createInvalidStreamChecker() {
             const [, frameText] = streamInfo;
             const frame = Number(frameText);
             if (frame === prevFrame) {
-                if (++frameUnchangedCount >= 10) {
+                if (++frameUnchangedCount >= count) {
                     return true;
                 }
             }
@@ -171,9 +174,6 @@ export function createInvalidStreamChecker() {
             }
             return false;
         }
-        if (ffmpegLogLine.includes("HTTP error 404 Not Found")) {
-            return true;
-        }
         return false;
     };
 }
@@ -201,7 +201,7 @@ export function createTimeoutChecker(onTimeout, time) {
         },
     };
 }
-async function downloadImage(imageUrl, savePath) {
+export async function downloadImage(imageUrl, savePath) {
     const res = await fetch(imageUrl);
     if (!res.body) {
         throw new Error("No body in response");
@@ -216,6 +216,21 @@ const md5 = (str) => {
 const uuid = () => {
     return crypto.randomUUID();
 };
+/**
+ * 根据指定的顺序对对象数组进行排序
+ * @param objects 要排序的对象数组
+ * @param order 指定的顺序
+ * @param key 用于排序的键
+ * @returns 排序后的对象数组
+ */
+export function sortByKeyOrder(objects, order, key) {
+    const orderMap = new Map(order.map((value, index) => [value, index]));
+    return [...objects].sort((a, b) => {
+        const indexA = orderMap.get(a[key]) ?? Number.MAX_VALUE;
+        const indexB = orderMap.get(b[key]) ?? Number.MAX_VALUE;
+        return indexA - indexB;
+    });
+}
 export default {
     replaceExtName,
     singleton,
@@ -232,4 +247,5 @@ export default {
     downloadImage,
     md5,
     uuid,
+    sortByKeyOrder,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bililive-tools/manager",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Batch scheduling recorders",
   "main": "./lib/index.js",
   "type": "module",