@bililive-tools/manager 1.5.0 → 1.6.1

package/README.md

@@ -72,14 +72,16 @@ manager.startCheckLoop();
 
 手动开启录制
 
-### setFFMPEGPath
-
-设置ffmpeg可执行路径
+### setFFMPEGPath & setMesioPath
 
 ```ts
-import { setFFMPEGPath } from "@bililive-tools/manager";
+import { setFFMPEGPath, setMesioPath } from "@bililive-tools/manager";
 
+// 设置ffmpeg可执行路径
 setFFMPEGPath("ffmpeg.exe");
+
+// 设置mesio可执行文件路径
+setMesioPath("mesio.exe");
 ```
 
 ## savePathRule 占位符参数

package/lib/cache.d.ts

@@ -0,0 +1,17 @@
+export declare class Cache {
+    private static instance;
+    private data;
+    private constructor();
+    static getInstance(): Cache;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+    get size(): number;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<any>;
+    entries(): IterableIterator<[string, any]>;
+    forEach(callbackfn: (value: any, key: string, map: Map<string, any>) => void, thisArg?: any): void;
+    [Symbol.iterator](): IterableIterator<[string, any]>;
+}

package/lib/cache.js

@@ -0,0 +1,47 @@
+export class Cache {
+    static instance;
+    data;
+    constructor() {
+        this.data = new Map();
+    }
+    static getInstance() {
+        if (!Cache.instance) {
+            Cache.instance = new Cache();
+        }
+        return Cache.instance;
+    }
+    set(key, value) {
+        this.data.set(key, value);
+    }
+    get(key) {
+        return this.data.get(key);
+    }
+    has(key) {
+        return this.data.has(key);
+    }
+    delete(key) {
+        return this.data.delete(key);
+    }
+    clear() {
+        this.data.clear();
+    }
+    get size() {
+        return this.data.size;
+    }
+    keys() {
+        return this.data.keys();
+    }
+    values() {
+        return this.data.values();
+    }
+    entries() {
+        return this.data.entries();
+    }
+    forEach(callbackfn, thisArg) {
+        this.data.forEach(callbackfn, thisArg);
+    }
+    // 实现 Symbol.iterator 接口，支持 for...of 循环
+    [Symbol.iterator]() {
+        return this.data[Symbol.iterator]();
+    }
+}

package/lib/common.d.ts

@@ -3,7 +3,7 @@ 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 declare const HuYaQualities: readonly [0, 20000, 14100, 14000, 10000, 8000, 4200, 4000, 2000, 500];
+export declare const HuYaQualities: readonly [0, 20000, 14100, 14000, 10000, 8000, 4200, 4000, 2000, 500, -1];
 export declare const DouYinQualities: readonly ["origin", "uhd", "hd", "sd", "ld", "ao", "real_origin"];
 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> {

package/lib/common.js

@@ -2,5 +2,7 @@ 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 HuYaQualities = [
+    0, 20000, 14100, 14000, 10000, 8000, 4200, 4000, 2000, 500, -1,
+];
 export const DouYinQualities = ["origin", "uhd", "hd", "sd", "ld", "ao", "real_origin"];

package/lib/index.d.ts

@@ -7,7 +7,8 @@ export * from "./common.js";
 export * from "./recorder.js";
 export * from "./manager.js";
 export * from "./record_extra_data_controller.js";
-export * from "./FFMPEGRecorder.js";
+export * from "./recorder/FFMPEGRecorder.js";
+export { createBaseRecorder } from "./recorder/index.js";
 export { utils };
 /**
  * 提供一些 utils
@@ -17,5 +18,7 @@ export declare function defaultToJSON<E extends AnyObject>(provider: RecorderPro
 export declare function genRecorderUUID(): Recorder["id"];
 export declare function genRecordUUID(): RecordHandle["id"];
 export declare function setFFMPEGPath(newPath: string): void;
-export declare const createFFMPEGBuilder: (input?: string | import("stream").Readable | undefined, options?: ffmpeg.FfmpegCommandOptions | undefined) => ffmpeg.FfmpegCommand;
+export declare const createFFMPEGBuilder: (...args: Parameters<typeof ffmpeg>) => ffmpeg.FfmpegCommand;
+export declare function setMesioPath(newPath: string): void;
+export declare function getMesioPath(): string;
 export declare function getDataFolderPath<E extends AnyObject>(provider: RecorderProvider<E>): string;

package/lib/index.js

@@ -6,7 +6,8 @@ export * from "./common.js";
 export * from "./recorder.js";
 export * from "./manager.js";
 export * from "./record_extra_data_controller.js";
-export * from "./FFMPEGRecorder.js";
+export * from "./recorder/FFMPEGRecorder.js";
+export { createBaseRecorder } from "./recorder/index.js";
 export { utils };
 /**
  * 提供一些 utils
@@ -21,7 +22,6 @@ export function defaultToJSON(provider, recorder) {
         ...pick(recorder, [
             "id",
             "channelId",
-            "owner",
             "remarks",
             "disableAutoCheck",
             "quality",
@@ -36,6 +36,7 @@ export function defaultToJSON(provider, recorder) {
             "liveInfo",
             "uid",
             "titleKeywords",
+            // "recordHandle",
         ]),
     };
 }
@@ -55,6 +56,14 @@ export const createFFMPEGBuilder = (...args) => {
     ffmpeg.setFfmpegPath(ffmpegPath);
     return ffmpeg(...args);
 };
+// Mesio path management
+let mesioPath = "mesio";
+export function setMesioPath(newPath) {
+    mesioPath = newPath;
+}
+export function getMesioPath() {
+    return mesioPath;
+}
 export function getDataFolderPath(provider) {
     return "./" + provider.id;
 }

package/lib/manager.d.ts

@@ -2,7 +2,8 @@ import { Emitter } from "mitt";
 import { ChannelId, Message } from "./common.js";
 import { RecorderCreateOpts, Recorder, SerializedRecorder, RecordHandle, DebugLog, Progress } from "./recorder.js";
 import { AnyObject, UnknownObject } from "./utils.js";
-import { StreamManager } from "./streamManager.js";
+import { StreamManager } from "./recorder/streamManager.js";
+import { Cache } from "./cache.js";
 export interface RecorderProvider<E extends AnyObject> {
     id: string;
     name: string;
@@ -12,14 +13,14 @@ export interface RecorderProvider<E extends AnyObject> {
         id: ChannelId;
         title: string;
         owner: string;
-        uid?: number;
+        uid?: number | string;
         avatar?: string;
     } | null>;
     createRecorder: (this: RecorderProvider<E>, opts: Omit<RecorderCreateOpts<E>, "providerId">) => Recorder<E>;
     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", "autoCheckInterval", "ffmpegOutputArgs", "biliBatchQuery"];
+declare const configurableProps: readonly ["savePathRule", "autoRemoveSystemReservedChars", "autoCheckInterval", "ffmpegOutputArgs", "biliBatchQuery", "recordRetryImmediately"];
 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: {
@@ -27,44 +28,44 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
         err: unknown;
     };
     RecordStart: {
-        recorder: Recorder<E>;
+        recorder: SerializedRecorder<E>;
         recordHandle: RecordHandle;
     };
     RecordSegment: {
-        recorder: Recorder<E>;
+        recorder: SerializedRecorder<E>;
         recordHandle?: RecordHandle;
     };
     videoFileCreated: {
-        recorder: Recorder<E>;
+        recorder: SerializedRecorder<E>;
         filename: string;
         cover?: string;
     };
     videoFileCompleted: {
-        recorder: Recorder<E>;
+        recorder: SerializedRecorder<E>;
         filename: string;
     };
     RecorderProgress: {
-        recorder: Recorder<E>;
+        recorder: SerializedRecorder<E>;
         progress: Progress;
     };
     RecoderLiveStart: {
         recorder: Recorder<E>;
     };
     RecordStop: {
-        recorder: Recorder<E>;
+        recorder: SerializedRecorder<E>;
         recordHandle: RecordHandle;
         reason?: string;
     };
     Message: {
-        recorder: Recorder<E>;
+        recorder: SerializedRecorder<E>;
         message: Message;
     };
     RecorderUpdated: {
-        recorder: Recorder<E>;
+        recorder: SerializedRecorder<E>;
         keys: (string | keyof Recorder<E>)[];
     };
-    RecorderAdded: Recorder<E>;
-    RecorderRemoved: Recorder<E>;
+    RecorderAdded: SerializedRecorder<E>;
+    RecorderRemoved: SerializedRecorder<E>;
     RecorderDebugLog: DebugLog & {
         recorder: Recorder<E>;
     };
@@ -73,7 +74,7 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     providers: P[];
     getChannelURLMatchedRecorderProviders: (this: RecorderManager<ME, P, PE, E>, channelURL: string) => P[];
     recorders: Recorder<E>[];
-    addRecorder: (this: RecorderManager<ME, P, PE, E>, opts: RecorderCreateOpts<E>) => Recorder<E>;
+    addRecorder: (this: RecorderManager<ME, P, PE, E>, opts: Omit<RecorderCreateOpts<E>, "cache">) => Recorder<E>;
     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>;
@@ -87,6 +88,10 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     ffmpegOutputArgs: string;
     /** b站使用批量查询接口 */
     biliBatchQuery: boolean;
+    /** 测试：录制错误立即重试 */
+    recordRetryImmediately: boolean;
+    /** 缓存实例 */
+    cache: Cache;
 }
 export type RecorderManagerCreateOpts<ME extends AnyObject = UnknownObject, P extends RecorderProvider<AnyObject> = RecorderProvider<UnknownObject>, PE extends AnyObject = GetProviderExtra<P>, E extends AnyObject = ME & PE> = Partial<Pick<RecorderManager<ME, P, PE, E>, ConfigurableProp>> & {
     providers: P[];
@@ -98,4 +103,4 @@ export declare function genSavePathFromRule<ME extends AnyObject, P extends Reco
     startTime?: number;
 }): string;
 export type GetProviderExtra<P> = P extends RecorderProvider<infer E> ? E : never;
-export { StreamManager };
+export { StreamManager, Cache };

package/lib/manager.js

@@ -5,13 +5,15 @@ import { omit, range } from "lodash-es";
 import { parseArgsStringToArgv } from "string-argv";
 import { getBiliStatusInfoByRoomIds } from "./api.js";
 import { formatDate, removeSystemReservedChars, formatTemplate, replaceExtName, downloadImage, isBetweenTimeRange, } from "./utils.js";
-import { StreamManager } from "./streamManager.js";
+import { StreamManager } from "./recorder/streamManager.js";
+import { Cache } from "./cache.js";
 const configurableProps = [
     "savePathRule",
     "autoRemoveSystemReservedChars",
     "autoCheckInterval",
     "ffmpegOutputArgs",
     "biliBatchQuery",
+    "recordRetryImmediately",
 ];
 function isConfigurableProp(prop) {
     return configurableProps.includes(prop);
@@ -89,6 +91,10 @@ export function createRecorderManager(opts) {
     const tempBanObj = {};
     // 用于是否触发LiveStart事件，不要重复触发
     const liveStartObj = {};
+    // 用于记录触发重试直播场次的次数
+    const retryCountObj = {};
+    // 获取缓存单例
+    const cache = Cache.getInstance();
     const manager = {
         // @ts-ignore
         ...mitt(),
@@ -103,24 +109,62 @@ export function createRecorderManager(opts) {
                 throw new Error("Cant find provider " + opts.providerId);
             // TODO: 因为泛型函数内部是不持有具体泛型的，这里被迫用了 as，没什么好的思路处理，除非
             // provider.createRecorder 能返回 Recorder<PE> 才能进一步优化。
-            const recorder = provider.createRecorder(omit(opts, ["providerId"]));
+            const recorder = provider.createRecorder({
+                ...omit(opts, ["providerId"]),
+                cache,
+            });
             this.recorders.push(recorder);
-            recorder.on("RecordStart", (recordHandle) => this.emit("RecordStart", { recorder, recordHandle }));
-            recorder.on("RecordSegment", (recordHandle) => this.emit("RecordSegment", { recorder, recordHandle }));
+            recorder.on("RecordStart", (recordHandle) => this.emit("RecordStart", { recorder: recorder.toJSON(), recordHandle }));
+            recorder.on("RecordSegment", (recordHandle) => this.emit("RecordSegment", { recorder: recorder.toJSON(), recordHandle }));
             recorder.on("videoFileCreated", ({ filename, cover }) => {
                 if (recorder.saveCover && recorder?.liveInfo?.cover) {
                     const coverPath = replaceExtName(filename, ".jpg");
                     downloadImage(cover ?? recorder?.liveInfo?.cover, coverPath);
                 }
-                this.emit("videoFileCreated", { recorder, filename });
+                this.emit("videoFileCreated", { recorder: recorder.toJSON(), filename });
+            });
+            recorder.on("videoFileCompleted", ({ filename }) => this.emit("videoFileCompleted", { recorder: recorder.toJSON(), filename }));
+            recorder.on("Message", (message) => this.emit("Message", { recorder: recorder.toJSON(), message }));
+            recorder.on("Updated", (keys) => this.emit("RecorderUpdated", { recorder: recorder.toJSON(), keys }));
+            recorder.on("DebugLog", (log) => this.emit("RecorderDebugLog", { recorder: recorder, ...log }));
+            recorder.on("RecordStop", ({ recordHandle, reason }) => {
+                this.emit("RecordStop", { recorder: recorder.toJSON(), recordHandle, reason });
+                // 如果reason中存在"invalid stream"，说明直播由于某些原因中断了，虽然会在下一次周期检查中继续，但是会遗漏一段时间。
+                // 这时候可以触发一次检查，但出于直播可能抽风的原因，为避免风控，一场直播最多触发五次。
+                // 测试阶段，还需要一个开关，默认关闭，几个版本后转正使用
+                // 也许之后还能链接复用，但也会引入更多复杂度，需要谨慎考虑
+                // 虎牙直播结束后可能额外触发导致错误，忽略虎牙直播间：https://www.huya.com/910323
+                if (manager.recordRetryImmediately &&
+                    recorder.providerId !== "HuYa" &&
+                    reason &&
+                    reason.includes("invalid stream") &&
+                    recorder?.liveInfo?.liveId) {
+                    const key = `${recorder.channelId}-${recorder.liveInfo?.liveId}`;
+                    if (retryCountObj[key] > 5)
+                        return;
+                    if (!retryCountObj[key]) {
+                        retryCountObj[key] = 0;
+                    }
+                    if (retryCountObj[key] < 5) {
+                        retryCountObj[key]++;
+                    }
+                    this.emit("RecorderDebugLog", {
+                        recorder,
+                        type: "common",
+                        text: `录制${recorder?.channelId}因“${reason}”中断，触发重试直播（${retryCountObj[key]}）`,
+                    });
+                    // 触发一次检查，等待一秒使状态清理完毕
+                    setTimeout(() => {
+                        recorder.checkLiveStatusAndRecord({
+                            getSavePath(data) {
+                                return genSavePathFromRule(manager, recorder, data);
+                            },
+                        });
+                    }, 1000);
+                }
             });
-            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 });
+                this.emit("RecorderProgress", { recorder: recorder.toJSON(), progress });
             });
             recorder.on("videoFileCreated", () => {
                 if (!recorder.liveInfo?.liveId)
@@ -129,9 +173,9 @@ export function createRecorderManager(opts) {
                 if (liveStartObj[key])
                     return;
                 liveStartObj[key] = true;
-                this.emit("RecoderLiveStart", { recorder });
+                this.emit("RecoderLiveStart", { recorder: recorder });
             });
-            this.emit("RecorderAdded", recorder);
+            this.emit("RecorderAdded", recorder.toJSON());
             return recorder;
         },
         removeRecorder(recorder) {
@@ -141,7 +185,7 @@ export function createRecorderManager(opts) {
             recorder.recordHandle?.stop("remove recorder");
             this.recorders.splice(idx, 1);
             delete tempBanObj[recorder.channelId];
-            this.emit("RecorderRemoved", recorder);
+            this.emit("RecorderRemoved", recorder.toJSON());
         },
         async startRecord(id) {
             const recorder = this.recorders.find((item) => item.id === id);
@@ -218,6 +262,7 @@ export function createRecorderManager(opts) {
             path.join(process.cwd(), "{platform}/{owner}/{year}-{month}-{date} {hour}-{min}-{sec} {title}"),
         autoRemoveSystemReservedChars: opts.autoRemoveSystemReservedChars ?? true,
         biliBatchQuery: opts.biliBatchQuery ?? false,
+        recordRetryImmediately: opts.recordRetryImmediately ?? false,
         ffmpegOutputArgs: opts.ffmpegOutputArgs ??
             "-c copy" +
                 /**
@@ -236,6 +281,7 @@ export function createRecorderManager(opts) {
                  * TODO: 如果浏览器行为无法优化，并且想进一步优化加载速度，可以考虑录制时使用 fmp4，录制完成后再转一次普通 mp4。
                  */
                 " -min_frag_duration 10000000",
+        cache,
     };
     const setProvidersFFMPEGOutputArgs = (ffmpegOutputArgs) => {
         const args = parseArgsStringToArgv(ffmpegOutputArgs);
@@ -260,6 +306,8 @@ export function genSavePathFromRule(manager, recorder, extData) {
     // TODO: 这里随便写的，后面再优化
     const provider = manager.providers.find((p) => p.id === recorder.toJSON().providerId);
     const now = extData?.startTime ? new Date(extData.startTime) : new Date();
+    const owner = (extData?.owner ?? "").replaceAll("%", "_");
+    const title = (extData?.title ?? "").replaceAll("%", "_");
     const params = {
         platform: provider?.name ?? "unknown",
         channelId: recorder.channelId,
@@ -271,6 +319,8 @@ export function genSavePathFromRule(manager, recorder, extData) {
         min: formatDate(now, "mm"),
         sec: formatDate(now, "ss"),
         ...extData,
+        owner: owner,
+        title: title,
     };
     if (manager.autoRemoveSystemReservedChars) {
         for (const key in params) {
@@ -286,4 +336,4 @@ export function genSavePathFromRule(manager, recorder, extData) {
     }
     return formatTemplate(savePathRule, params);
 }
-export { StreamManager };
+export { StreamManager, Cache };

package/lib/recorder/FFMPEGRecorder.d.ts

@@ -0,0 +1,37 @@
+import EventEmitter from "node:events";
+import { IRecorder, FFMPEGRecorderOptions } from "./IRecorder.js";
+export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
+    private onEnd;
+    private onUpdateLiveInfo;
+    private command;
+    private streamManager;
+    private timeoutChecker;
+    readonly hasSegment: boolean;
+    readonly getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    readonly segment: number;
+    ffmpegOutputOptions: string[];
+    readonly inputOptions: string[];
+    readonly isHls: boolean;
+    readonly disableDanma: boolean;
+    readonly url: string;
+    formatName: "flv" | "ts" | "fmp4";
+    videoFormat: "ts" | "mkv" | "mp4";
+    readonly headers: {
+        [key: string]: string | undefined;
+    } | undefined;
+    constructor(opts: FFMPEGRecorderOptions, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+        title?: string;
+        cover?: string;
+    }>);
+    createCommand(): import("@renmu/fluent-ffmpeg").FfmpegCommand;
+    formatLine(line: string): {
+        time: string | null;
+    } | null;
+    run(): void;
+    getArguments(): string[];
+    stop(): Promise<void>;
+    getExtraDataController(): import("../xml_stream_controller.js").XmlStreamController | null;
+}

package/lib/{FFMPEGRecorder.js → recorder/FFMPEGRecorder.js}

@@ -1,6 +1,6 @@
 import EventEmitter from "node:events";
-import { createFFMPEGBuilder, StreamManager, utils } from "./index.js";
-import { createInvalidStreamChecker, assert } from "./utils.js";
+import { createFFMPEGBuilder, StreamManager, utils } from "../index.js";
+import { createInvalidStreamChecker, assert } from "../utils.js";
 export class FFMPEGRecorder extends EventEmitter {
     onEnd;
     onUpdateLiveInfo;
@@ -15,30 +15,50 @@ export class FFMPEGRecorder extends EventEmitter {
     isHls;
     disableDanma = false;
     url;
+    formatName;
+    videoFormat;
     headers;
     constructor(opts, onEnd, onUpdateLiveInfo) {
         super();
         this.onEnd = onEnd;
         this.onUpdateLiveInfo = onUpdateLiveInfo;
         const hasSegment = !!opts.segment;
+        this.hasSegment = hasSegment;
+        let formatName = "flv";
+        if (opts.url.includes(".m3u8")) {
+            formatName = "ts";
+        }
+        this.formatName = opts.formatName ?? formatName;
+        if (this.formatName === "fmp4" || this.formatName === "ts") {
+            this.isHls = true;
+        }
+        else {
+            this.isHls = false;
+        }
+        let videoFormat = opts.videoFormat ?? "auto";
+        if (videoFormat === "auto") {
+            if (!this.hasSegment) {
+                videoFormat = "mp4";
+                if (this.formatName === "ts") {
+                    videoFormat = "ts";
+                }
+            }
+            else {
+                videoFormat = "ts";
+            }
+        }
+        this.videoFormat = videoFormat;
         this.disableDanma = opts.disableDanma ?? false;
-        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, opts.videoFormat, {
+        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, "ffmpeg", this.videoFormat, {
             onUpdateLiveInfo: this.onUpdateLiveInfo,
         });
         this.timeoutChecker = utils.createTimeoutChecker(() => this.onEnd("ffmpeg timeout"), 3 * 10e3, false);
-        this.hasSegment = hasSegment;
         this.getSavePath = opts.getSavePath;
         this.ffmpegOutputOptions = opts.outputOptions;
         this.inputOptions = opts.inputOptions ?? [];
         this.url = opts.url;
         this.segment = opts.segment;
         this.headers = opts.headers;
-        if (opts.isHls === undefined) {
-            this.isHls = this.url.includes("m3u8");
-        }
-        else {
-            this.isHls = opts.isHls;
-        }
         this.command = this.createCommand();
         this.streamManager.on("videoFileCreated", ({ filename, cover }) => {
             this.emit("videoFileCreated", { filename, cover });
@@ -79,15 +99,16 @@ export class FFMPEGRecorder extends EventEmitter {
             .on("end", () => this.onEnd("finished"))
             .on("stderr", async (stderrLine) => {
             assert(typeof stderrLine === "string");
-            await this.streamManager.handleVideoStarted(stderrLine);
             this.emit("DebugLog", { type: "ffmpeg", text: stderrLine });
+            const [isInvalid, reason] = isInvalidStream(stderrLine);
+            if (isInvalid) {
+                this.onEnd(reason);
+            }
+            await this.streamManager.handleVideoStarted(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) {

package/lib/recorder/IRecorder.d.ts

@@ -0,0 +1,81 @@
+import { EventEmitter } from "node:events";
+/**
+ * 录制器构造函数选项的基础接口
+ */
+export interface BaseRecorderOptions {
+    url: string;
+    getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    segment: number;
+    inputOptions?: string[];
+    disableDanma?: boolean;
+    formatName?: "flv" | "ts" | "fmp4";
+    headers?: {
+        [key: string]: string | undefined;
+    };
+}
+/**
+ * 录制器接口定义
+ */
+export interface IRecorder extends EventEmitter {
+    readonly hasSegment: boolean;
+    readonly segment: number;
+    readonly inputOptions: string[];
+    readonly isHls: boolean;
+    readonly disableDanma: boolean;
+    readonly url: string;
+    readonly headers: {
+        [key: string]: string | undefined;
+    } | undefined;
+    readonly getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    run(): void;
+    stop(): Promise<void>;
+    getArguments(): string[];
+    getExtraDataController(): any;
+    createCommand(): any;
+    on(event: "videoFileCreated", listener: (data: {
+        filename: string;
+        cover?: string;
+    }) => void): this;
+    on(event: "videoFileCompleted", listener: (data: {
+        filename: string;
+    }) => void): this;
+    on(event: "DebugLog", listener: (data: {
+        type: string;
+        text: string;
+    }) => void): this;
+    on(event: "progress", listener: (info: any) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    emit(event: "videoFileCreated", data: {
+        filename: string;
+        cover?: string;
+    }): boolean;
+    emit(event: "videoFileCompleted", data: {
+        filename: string;
+    }): boolean;
+    emit(event: "DebugLog", data: {
+        type: string;
+        text: string;
+    }): boolean;
+    emit(event: "progress", info: any): boolean;
+    emit(event: string, ...args: any[]): boolean;
+}
+/**
+ * FFMPEG录制器特定选项
+ */
+export interface FFMPEGRecorderOptions extends BaseRecorderOptions {
+    outputOptions: string[];
+    videoFormat?: "auto" | "ts" | "mkv" | "mp4";
+}
+/**
+ * Mesio录制器特定选项
+ */
+export interface MesioRecorderOptions extends BaseRecorderOptions {
+    outputOptions?: string[];
+    isHls?: boolean;
+}

package/lib/recorder/IRecorder.js

@@ -0,0 +1 @@
+export {};