@bililive-tools/manager 1.5.0 → 1.6.0

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
@@ -18,4 +19,6 @@ 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 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;
@@ -19,7 +20,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", "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/{FFMPEGRecorder.d.ts → recorder/FFMPEGRecorder.d.ts}

@@ -16,6 +16,8 @@ export declare class FFMPEGRecorder extends EventEmitter {
     isHls: boolean;
     disableDanma: boolean;
     url: string;
+    formatName: "flv" | "ts" | "fmp4";
+    videoFormat: "ts" | "mkv" | "mp4";
     headers: {
         [key: string]: string | undefined;
     } | undefined;
@@ -28,9 +30,9 @@ export declare class FFMPEGRecorder extends EventEmitter {
         segment: number;
         outputOptions: string[];
         inputOptions?: string[];
-        isHls?: boolean;
         disableDanma?: boolean;
-        videoFormat?: "auto" | "ts" | "mkv";
+        videoFormat?: "auto" | "ts" | "mkv" | "mp4";
+        formatName?: "flv" | "ts" | "fmp4";
         headers?: {
             [key: string]: string | undefined;
         };
@@ -45,5 +47,5 @@ export declare class FFMPEGRecorder extends EventEmitter {
     run(): void;
     getArguments(): string[];
     stop(): Promise<void>;
-    getExtraDataController(): import("./record_extra_data_controller.js").RecordExtraDataController | null;
+    getExtraDataController(): import("../record_extra_data_controller.js").RecordExtraDataController | 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/index.d.ts

@@ -0,0 +1,80 @@
+import { FFMPEGRecorder } from "./FFMPEGRecorder.js";
+import { mesioRecorder } from "./mesioRecorder.js";
+export { FFMPEGRecorder } from "./FFMPEGRecorder.js";
+export { mesioRecorder } from "./mesioRecorder.js";
+/**
+ * 录制器类型
+ */
+export type RecorderType = "ffmpeg" | "mesio";
+/**
+ * 录制器基础配置选项
+ */
+export interface BaseRecorderOptions {
+    url: string;
+    getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    segment: number;
+    inputOptions?: string[];
+    disableDanma?: boolean;
+    videoFormat?: "auto" | "ts" | "mkv";
+    formatName?: "flv" | "ts" | "fmp4";
+    headers?: {
+        [key: string]: string | undefined;
+    };
+}
+/**
+ * FFMPEG录制器配置选项
+ */
+export interface FFMPEGRecorderOptions extends BaseRecorderOptions {
+    outputOptions: string[];
+}
+/**
+ * Mesio录制器配置选项
+ */
+export interface MesioRecorderOptions extends BaseRecorderOptions {
+}
+/**
+ * 根据录制器类型获取对应的配置选项类型
+ */
+export type RecorderOptions<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorderOptions : MesioRecorderOptions;
+/**
+ * 根据录制器类型获取对应的录制器实例类型
+ */
+export type RecorderInstance<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorder : mesioRecorder;
+/**
+ * 创建录制器的工厂函数
+ *
+ * @example
+ * ```typescript
+ * // 创建 FFMPEG 录制器
+ * const ffmpegRecorder = createRecorder("ffmpeg", {
+ *   url: "https://example.com/stream.m3u8",
+ *   getSavePath: ({ startTime, title }) => `/recordings/${title}_${startTime}.ts`,
+ *   segment: 30,
+ *   outputOptions: ["-c", "copy"],
+ *   inputOptions: ["-user_agent", "Custom-Agent"]
+ * }, onEnd, onUpdateLiveInfo);
+ *
+ * // 创建 Mesio 录制器
+ * const mesioRecorder = createRecorder("mesio", {
+ *   url: "https://example.com/stream.m3u8",
+ *   getSavePath: ({ startTime, title }) => `/recordings/${title}_${startTime}.ts`,
+ *   segment: 30,
+ *   inputOptions: ["--fix"]
+ * }, onEnd, onUpdateLiveInfo);
+ * ```
+ *
+ * @param type 录制器类型
+ * @param opts 录制器配置选项
+ * @param onEnd 录制结束回调
+ * @param onUpdateLiveInfo 更新直播信息回调
+ * @returns 对应类型的录制器实例
+ */
+export declare function createBaseRecorder<T extends RecorderType>(type: T, opts: RecorderOptions<T> & {
+    mesioOptions?: string[];
+}, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+    title?: string;
+    cover?: string;
+}>): RecorderInstance<T>;

package/lib/recorder/index.js

@@ -0,0 +1,44 @@
+import { FFMPEGRecorder } from "./FFMPEGRecorder.js";
+import { mesioRecorder } from "./mesioRecorder.js";
+export { FFMPEGRecorder } from "./FFMPEGRecorder.js";
+export { mesioRecorder } from "./mesioRecorder.js";
+/**
+ * 创建录制器的工厂函数
+ *
+ * @example
+ * ```typescript
+ * // 创建 FFMPEG 录制器
+ * const ffmpegRecorder = createRecorder("ffmpeg", {
+ *   url: "https://example.com/stream.m3u8",
+ *   getSavePath: ({ startTime, title }) => `/recordings/${title}_${startTime}.ts`,
+ *   segment: 30,
+ *   outputOptions: ["-c", "copy"],
+ *   inputOptions: ["-user_agent", "Custom-Agent"]
+ * }, onEnd, onUpdateLiveInfo);
+ *
+ * // 创建 Mesio 录制器
+ * const mesioRecorder = createRecorder("mesio", {
+ *   url: "https://example.com/stream.m3u8",
+ *   getSavePath: ({ startTime, title }) => `/recordings/${title}_${startTime}.ts`,
+ *   segment: 30,
+ *   inputOptions: ["--fix"]
+ * }, onEnd, onUpdateLiveInfo);
+ * ```
+ *
+ * @param type 录制器类型
+ * @param opts 录制器配置选项
+ * @param onEnd 录制结束回调
+ * @param onUpdateLiveInfo 更新直播信息回调
+ * @returns 对应类型的录制器实例
+ */
+export function createBaseRecorder(type, opts, onEnd, onUpdateLiveInfo) {
+    if (type === "ffmpeg") {
+        return new FFMPEGRecorder(opts, onEnd, onUpdateLiveInfo);
+    }
+    else if (type === "mesio") {
+        return new mesioRecorder({ ...opts, inputOptions: opts.mesioOptions ?? [] }, onEnd, onUpdateLiveInfo);
+    }
+    else {
+        throw new Error(`Unsupported recorder type: ${type}`);
+    }
+}

package/lib/recorder/mesioRecorder.d.ts

@@ -0,0 +1,60 @@
+import EventEmitter from "node:events";
+declare class MesioCommand extends EventEmitter {
+    private _input;
+    private _output;
+    private _inputOptions;
+    private process;
+    constructor();
+    input(source: string): MesioCommand;
+    output(target: string): MesioCommand;
+    inputOptions(options: string[]): MesioCommand;
+    inputOptions(...options: string[]): MesioCommand;
+    _getArguments(): string[];
+    run(): void;
+    kill(signal?: NodeJS.Signals): void;
+}
+export declare const createMesioBuilder: () => MesioCommand;
+export declare class mesioRecorder extends EventEmitter {
+    private onEnd;
+    private onUpdateLiveInfo;
+    private command;
+    private streamManager;
+    hasSegment: boolean;
+    getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    segment: number;
+    inputOptions: string[];
+    isHls: boolean;
+    disableDanma: boolean;
+    url: string;
+    headers: {
+        [key: string]: string | undefined;
+    } | undefined;
+    constructor(opts: {
+        url: string;
+        getSavePath: (data: {
+            startTime: number;
+            title?: string;
+        }) => string;
+        segment: number;
+        outputOptions?: string[];
+        inputOptions?: string[];
+        isHls?: boolean;
+        disableDanma?: boolean;
+        formatName?: "flv" | "ts" | "fmp4";
+        headers?: {
+            [key: string]: string | undefined;
+        };
+    }, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+        title?: string;
+        cover?: string;
+    }>);
+    createCommand(): MesioCommand;
+    run(): void;
+    getArguments(): string[];
+    stop(): Promise<void>;
+    getExtraDataController(): import("../record_extra_data_controller.js").RecordExtraDataController | null;
+}
+export {};

package/lib/recorder/mesioRecorder.js

@@ -0,0 +1,194 @@
+import path from "node:path";
+import EventEmitter from "node:events";
+import { spawn } from "node:child_process";
+import { StreamManager, getMesioPath } from "../index.js";
+// Mesio command builder class similar to ffmpeg
+class MesioCommand extends EventEmitter {
+    _input = "";
+    _output = "";
+    _inputOptions = [];
+    process = null;
+    constructor() {
+        super();
+    }
+    input(source) {
+        this._input = source;
+        return this;
+    }
+    output(target) {
+        this._output = target;
+        return this;
+    }
+    inputOptions(...options) {
+        const opts = Array.isArray(options[0]) ? options[0] : options;
+        this._inputOptions.push(...opts);
+        return this;
+    }
+    _getArguments() {
+        const args = [];
+        // Add input options first
+        args.push(...this._inputOptions);
+        // Add output target
+        if (this._output) {
+            const { dir, name } = path.parse(this._output);
+            args.push("-o", dir);
+            args.push("-n", name);
+        }
+        // args.push("-v");
+        // Add input source
+        if (this._input) {
+            args.push(this._input);
+        }
+        return args;
+    }
+    run() {
+        const args = this._getArguments();
+        const mesioExecutable = getMesioPath();
+        this.process = spawn(mesioExecutable, args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (this.process.stdout) {
+            this.process.stdout.on("data", (data) => {
+                const output = data.toString();
+                // console.log(output);
+                this.emit("stderr", output);
+            });
+        }
+        if (this.process.stderr) {
+            this.process.stderr.on("data", (data) => {
+                const output = data.toString();
+                // console.error(output);
+                this.emit("stderr", output);
+            });
+        }
+        this.process.on("error", (error) => {
+            this.emit("error", error);
+        });
+        this.process.on("close", (code) => {
+            if (code === 0) {
+                this.emit("end");
+            }
+            else {
+                this.emit("error", new Error(`mesio process exited with code ${code}`));
+            }
+        });
+    }
+    kill(signal = "SIGTERM") {
+        if (this.process) {
+            this.process.kill(signal);
+        }
+    }
+}
+// Factory function similar to createFFMPEGBuilder
+export const createMesioBuilder = () => {
+    return new MesioCommand();
+};
+export class mesioRecorder extends EventEmitter {
+    onEnd;
+    onUpdateLiveInfo;
+    command;
+    streamManager;
+    hasSegment;
+    getSavePath;
+    segment;
+    inputOptions = [];
+    isHls;
+    disableDanma = false;
+    url;
+    headers;
+    constructor(opts, onEnd, onUpdateLiveInfo) {
+        super();
+        this.onEnd = onEnd;
+        this.onUpdateLiveInfo = onUpdateLiveInfo;
+        const hasSegment = true;
+        this.disableDanma = opts.disableDanma ?? false;
+        let videoFormat = "flv";
+        if (opts.url.includes(".m3u8")) {
+            videoFormat = "ts";
+        }
+        if (opts.formatName) {
+            if (opts.formatName === "fmp4") {
+                videoFormat = "m4s";
+            }
+            else if (opts.formatName === "ts") {
+                videoFormat = "ts";
+            }
+            else if (opts.formatName === "flv") {
+                videoFormat = "flv";
+            }
+        }
+        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, "mesio", videoFormat, {
+            onUpdateLiveInfo: this.onUpdateLiveInfo,
+        });
+        this.hasSegment = hasSegment;
+        this.getSavePath = opts.getSavePath;
+        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 });
+        });
+        this.streamManager.on("videoFileCompleted", ({ filename }) => {
+            this.emit("videoFileCompleted", { filename });
+        });
+        this.streamManager.on("DebugLog", (data) => {
+            this.emit("DebugLog", data);
+        });
+    }
+    createCommand() {
+        const inputOptions = [
+            ...this.inputOptions,
+            "--fix",
+            "-H",
+            "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",
+        ];
+        if (this.headers) {
+            Object.entries(this.headers).forEach(([key, value]) => {
+                if (!value)
+                    return;
+                inputOptions.push("-H", `${key}: ${value}`);
+            });
+        }
+        if (this.hasSegment) {
+            inputOptions.push("-d", `${this.segment * 60}s`);
+        }
+        const command = createMesioBuilder()
+            .input(this.url)
+            .inputOptions(inputOptions)
+            .output(this.streamManager.videoFilePath)
+            .on("error", this.onEnd)
+            .on("end", () => this.onEnd("finished"))
+            .on("stderr", async (stderrLine) => {
+            await this.streamManager.handleVideoStarted(stderrLine);
+            this.emit("DebugLog", { type: "ffmpeg", text: stderrLine });
+        });
+        return command;
+    }
+    run() {
+        this.command.run();
+    }
+    getArguments() {
+        return this.command._getArguments();
+    }
+    async stop() {
+        try {
+            // 直接发送SIGINT信号，会导致数据丢失
+            this.command.kill("SIGINT");
+            await this.streamManager.handleVideoCompleted();
+        }
+        catch (err) {
+            this.emit("DebugLog", { type: "error", text: String(err) });
+        }
+    }
+    getExtraDataController() {
+        return this.streamManager?.getExtraDataController();
+    }
+}

package/lib/{streamManager.d.ts → recorder/streamManager.d.ts}

@@ -1,20 +1,23 @@
 import EventEmitter from "node:events";
-import { createRecordExtraDataController } from "./record_extra_data_controller.js";
+import { createRecordExtraDataController } from "../record_extra_data_controller.js";
+import type { RecorderCreateOpts } from "../recorder.js";
 export type GetSavePath = (data: {
     startTime: number;
     title?: string;
 }) => string;
+type RecorderType = Exclude<RecorderCreateOpts["recorderType"], undefined | "auto">;
+type VideoFormat = "auto" | "ts" | "mkv" | "flv" | "mp4" | "m4s";
 export declare class Segment extends EventEmitter {
     extraDataController: ReturnType<typeof createRecordExtraDataController> | null;
     init: boolean;
     getSavePath: GetSavePath;
-    /** 原始的ffmpeg文件名，用于重命名 */
+    /** 原始的文件名，用于重命名 */
     rawRecordingVideoPath: string;
     /** 输出文件名名，不包含拓展名 */
     outputVideoFilePath: string;
     disableDanma: boolean;
-    videoExt: "ts" | "mkv" | "mp4";
-    constructor(getSavePath: GetSavePath, disableDanma: boolean, videoExt: "ts" | "mkv" | "mp4");
+    videoExt: VideoFormat;
+    constructor(getSavePath: GetSavePath, disableDanma: boolean, videoExt: VideoFormat);
     handleSegmentEnd(): Promise<void>;
     onSegmentStart(stderrLine: string, callBack?: {
         onUpdateLiveInfo: () => Promise<{
@@ -30,9 +33,10 @@ export declare class StreamManager extends EventEmitter {
     recordSavePath: string;
     recordStartTime?: number;
     hasSegment: boolean;
-    private videoFormat?;
+    recorderType: RecorderType;
+    private videoFormat;
     private callBack?;
-    constructor(getSavePath: GetSavePath, hasSegment: boolean, disableDanma: boolean, videoFormat?: "auto" | "ts" | "mkv", callBack?: {
+    constructor(getSavePath: GetSavePath, hasSegment: boolean, disableDanma: boolean, recorderType: RecorderType, videoFormat: VideoFormat, callBack?: {
         onUpdateLiveInfo: () => Promise<{
             title?: string;
             cover?: string;
@@ -40,7 +44,8 @@ export declare class StreamManager extends EventEmitter {
     });
     handleVideoStarted(stderrLine: string): Promise<void>;
     handleVideoCompleted(): Promise<void>;
-    getExtraDataController(): import("./record_extra_data_controller.js").RecordExtraDataController | null;
-    get videoExt(): "ts" | "mkv" | "mp4";
+    getExtraDataController(): import("../record_extra_data_controller.js").RecordExtraDataController | null;
+    get videoExt(): VideoFormat;
     get videoFilePath(): string;
 }
+export {};

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

@@ -1,12 +1,12 @@
 import EventEmitter from "node:events";
 import fs from "fs/promises";
-import { createRecordExtraDataController } from "./record_extra_data_controller.js";
-import { replaceExtName, ensureFolderExist, isFfmpegStartSegment, isFfmpegStart, retry, } from "./utils.js";
+import { createRecordExtraDataController } from "../record_extra_data_controller.js";
+import { replaceExtName, ensureFolderExist, isFfmpegStartSegment, isMesioStartSegment, isFfmpegStart, retry, cleanTerminalText, } from "../utils.js";
 export class Segment extends EventEmitter {
     extraDataController = null;
     init = true;
     getSavePath;
-    /** 原始的ffmpeg文件名，用于重命名 */
+    /** 原始的文件名，用于重命名 */
     rawRecordingVideoPath;
     /** 输出文件名名，不包含拓展名 */
     outputVideoFilePath;
@@ -66,8 +66,15 @@ export class Segment extends EventEmitter {
         if (!this.disableDanma) {
             this.extraDataController = createRecordExtraDataController(`${this.outputVideoFilePath}.json`);
         }
-        const regex = /'([^']+)'/;
-        const match = stderrLine.match(regex);
+        // 支持两种格式的正则表达式
+        // 1. FFmpeg格式: Opening 'filename' for writing
+        // 2. Mesio格式: Opening FLV segment path=filename Processing
+        const ffmpegRegex = /'([^']+)'/;
+        const mesioRegex = /segment path=([^\n]*)/i;
+        let match = stderrLine.match(ffmpegRegex);
+        if (!match) {
+            match = cleanTerminalText(stderrLine).match(mesioRegex);
+        }
         if (match) {
             const filename = match[1];
             this.rawRecordingVideoPath = filename;
@@ -91,13 +98,15 @@ export class StreamManager extends EventEmitter {
     recordSavePath;
     recordStartTime;
     hasSegment;
+    recorderType = "ffmpeg";
     videoFormat;
     callBack;
-    constructor(getSavePath, hasSegment, disableDanma, videoFormat, callBack) {
+    constructor(getSavePath, hasSegment, disableDanma, recorderType, videoFormat, callBack) {
         super();
         const recordSavePath = getSavePath({ startTime: Date.now() });
         this.recordSavePath = recordSavePath;
-        this.videoFormat = videoFormat;
+        this.videoFormat = videoFormat ?? "auto";
+        this.recorderType = recorderType;
         this.hasSegment = hasSegment;
         this.callBack = callBack;
         if (hasSegment) {
@@ -120,29 +129,43 @@ export class StreamManager extends EventEmitter {
         }
     }
     async handleVideoStarted(stderrLine) {
-        if (this.segment) {
-            if (isFfmpegStartSegment(stderrLine)) {
-                await this.segment.onSegmentStart(stderrLine, this.callBack);
+        if (this.recorderType === "ffmpeg") {
+            if (this.segment) {
+                if (isFfmpegStartSegment(stderrLine)) {
+                    await this.segment.onSegmentStart(stderrLine, this.callBack);
+                }
+            }
+            else {
+                // 不能直接在onStart回调进行判断，在某些情况下会链接无法录制的情况
+                if (isFfmpegStart(stderrLine)) {
+                    if (this.recordStartTime)
+                        return;
+                    this.recordStartTime = Date.now();
+                    this.emit("videoFileCreated", { filename: this.videoFilePath });
+                }
             }
         }
-        else {
-            // 不能直接在onStart回调进行判断，在某些情况下会链接无法录制的情况
-            if (isFfmpegStart(stderrLine)) {
-                if (this.recordStartTime)
-                    return;
-                this.recordStartTime = Date.now();
-                this.emit("videoFileCreated", { filename: this.videoFilePath });
+        else if (this.recorderType === "mesio") {
+            if (this.segment && isMesioStartSegment(stderrLine)) {
+                await this.segment.onSegmentStart(stderrLine, this.callBack);
             }
         }
     }
     async handleVideoCompleted() {
-        if (this.segment) {
-            await this.segment.handleSegmentEnd();
+        if (this.recorderType === "ffmpeg") {
+            if (this.segment) {
+                await this.segment.handleSegmentEnd();
+            }
+            else {
+                if (this.recordStartTime) {
+                    await this.getExtraDataController()?.flush();
+                    this.emit("videoFileCompleted", { filename: this.videoFilePath });
+                }
+            }
         }
-        else {
-            if (this.recordStartTime) {
-                await this.getExtraDataController()?.flush();
-                this.emit("videoFileCompleted", { filename: this.videoFilePath });
+        else if (this.recorderType === "mesio") {
+            if (this.segment) {
+                await this.segment.handleSegmentEnd();
             }
         }
     }
@@ -150,19 +173,25 @@ export class StreamManager extends EventEmitter {
         return this.segment?.extraDataController || this.extraDataController;
     }
     get videoExt() {
-        if (this.videoFormat === "mkv") {
-            return "mkv";
+        if (this.recorderType === "ffmpeg") {
+            return this.videoFormat;
         }
-        else if (this.videoFormat === "auto") {
-            if (!this.hasSegment) {
-                return "mp4";
-            }
+        else if (this.recorderType === "mesio") {
+            return this.videoFormat;
+        }
+        else {
+            throw new Error("Unknown recorderType");
         }
-        return "ts";
     }
     get videoFilePath() {
-        return this.segment
-            ? `${this.recordSavePath}-PART%03d.${this.videoExt}`
-            : `${this.recordSavePath}.${this.videoExt}`;
+        if (this.recorderType === "ffmpeg") {
+            return this.segment
+                ? `${this.recordSavePath}-PART%03d.${this.videoExt}`
+                : `${this.recordSavePath}.${this.videoExt}`;
+        }
+        else if (this.recorderType === "mesio") {
+            return `${this.recordSavePath}-PART%i.${this.videoExt}`;
+        }
+        return `${this.recordSavePath}.${this.videoExt}`;
     }
 }

package/lib/recorder.d.ts

@@ -2,6 +2,7 @@ import { Emitter } from "mitt";
 import { ChannelId, Message, Quality } from "./common.js";
 import { RecorderProvider } from "./manager.js";
 import { AnyObject, PickRequired, UnknownObject } from "./utils.js";
+import { Cache } from "./cache.js";
 type FormatName = "auto" | "flv" | "hls" | "fmp4" | "flv_only" | "hls_only" | "fmp4_only";
 type CodecName = "auto" | "avc" | "hevc" | "avc_only" | "hevc_only";
 export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
@@ -37,12 +38,14 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     formatName?: FormatName;
     /** 流编码 */
     codecName?: CodecName;
-    /** 选择使用的api，虎牙支持 */
-    api?: "auto" | "web" | "mp";
+    /** 选择使用的api，虎牙支持: auto,web,mp，抖音支持：web,webHTML */
+    api?: "auto" | "web" | "mp" | "webHTML";
     /** 标题关键词，如果直播间标题包含这些关键词，则不会自动录制（仅对斗鱼有效），多个关键词用英文逗号分隔 */
     titleKeywords?: string;
     /** 用于指定录制文件格式，auto时，分段使用ts，不分段使用mp4 */
     videoFormat?: "auto" | "ts" | "mkv";
+    /** 录制类型 */
+    recorderType?: "auto" | "ffmpeg" | "mesio";
     /** 流格式优先级 */
     formatriorities?: Array<"flv" | "hls">;
     /** 只录制音频 */
@@ -52,8 +55,9 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     /** 控制弹幕是否使用服务端时间戳 */
     useServerTimestamp?: boolean;
     extra?: Partial<E>;
+    cache: Cache;
 }
-export type SerializedRecorder<E extends AnyObject> = PickRequired<RecorderCreateOpts<E>, "id">;
+export type SerializedRecorder<E extends AnyObject> = PickRequired<RecorderCreateOpts<E>, "id"> & Pick<Recorder<E>, "id" | "channelId" | "remarks" | "disableAutoCheck" | "quality" | "streamPriorities" | "sourcePriorities" | "extra" | "segment" | "saveSCDanma" | "saveCover" | "saveGiftDanma" | "disableProvideCommentsWhenRecording" | "liveInfo" | "uid" | "titleKeywords">;
 export type RecorderState = "idle" | "recording" | "stopping-record";
 export type Progress = {
     time: string | null;
@@ -117,6 +121,8 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
         liveId?: string;
     };
     tempStopIntervalCheck?: boolean;
+    /** 缓存实例引用，由 manager 设置 */
+    cache: Cache;
     getChannelURL: (this: Recorder<E>) => string;
     checkLiveStatusAndRecord: (this: Recorder<E>, opts: {
         getSavePath: GetSavePath;

package/lib/utils.d.ts

@@ -36,9 +36,19 @@ 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 isMesioStartSegment(line: string): boolean;
 export declare function isFfmpegStart(line: string): boolean;
+export declare function cleanTerminalText(text: string): string;
 export declare const formatTemplate: (string: string, ...args: any[]) => string;
-export declare function createInvalidStreamChecker(count?: number): (ffmpegLogLine: string) => boolean;
+/**
+ * 检查ffmpeg无效流
+ * @param count 连续多少次帧数不变就判定为无效流
+ * @returns
+ * "receive repart stream": b站最后的无限流
+ * "receive invalid aac stream": ADTS无法被解析的flv流
+ * "invalid stream": 一段时间内帧数不变
+ */
+export declare function createInvalidStreamChecker(count?: number): (ffmpegLogLine: string) => [boolean, string];
 export declare function createTimeoutChecker(onTimeout: () => void, time: number, autoStart?: boolean): {
     update: () => void;
     stop: () => void;

package/lib/utils.js

@@ -126,10 +126,16 @@ export function removeSystemReservedChars(filename) {
 export function isFfmpegStartSegment(line) {
     return line.includes("Opening ") && line.includes("for writing");
 }
+export function isMesioStartSegment(line) {
+    return line.includes("Opening ") && line.includes("Opening segment");
+}
 export function isFfmpegStart(line) {
     return ((line.includes("frame=") && line.includes("fps=")) ||
         (line.includes("speed=") && line.includes("time=")));
 }
+export function cleanTerminalText(text) {
+    return text.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "").replace(/[\x00-\x1F\x7F]/g, "");
+}
 export const formatTemplate = function template(string, ...args) {
     const nargs = /\{([0-9a-zA-Z_]+)\}/g;
     let params;
@@ -156,13 +162,25 @@ export const formatTemplate = function template(string, ...args) {
         }
     });
 };
+/**
+ * 检查ffmpeg无效流
+ * @param count 连续多少次帧数不变就判定为无效流
+ * @returns
+ * "receive repart stream": b站最后的无限流
+ * "receive invalid aac stream": ADTS无法被解析的flv流
+ * "invalid stream": 一段时间内帧数不变
+ */
 export function createInvalidStreamChecker(count = 15) {
     let prevFrame = 0;
     let frameUnchangedCount = 0;
     return (ffmpegLogLine) => {
         // B站某些cdn在直播结束后仍会返回一些数据 https://github.com/renmu123/biliLive-tools/issues/123
         if (ffmpegLogLine.includes("New subtitle stream with index")) {
-            return true;
+            return [true, "receive repart stream"];
+        }
+        // 虎牙某些cdn会返回无法解析ADTS的flv流 https://github.com/renmu123/biliLive-tools/issues/150
+        if (ffmpegLogLine.includes("AAC bitstream not in ADTS format and extradata missing")) {
+            return [true, "receive invalid aac stream"];
         }
         const streamInfo = ffmpegLogLine.match(/frame=\s*(\d+) fps=.*? q=.*? size=.*? time=.*? bitrate=.*? speed=.*?/);
         if (streamInfo != null) {
@@ -170,16 +188,16 @@ export function createInvalidStreamChecker(count = 15) {
             const frame = Number(frameText);
             if (frame === prevFrame) {
                 if (++frameUnchangedCount >= count) {
-                    return true;
+                    return [true, "invalid stream"];
                 }
             }
             else {
                 prevFrame = frame;
                 frameUnchangedCount = 0;
             }
-            return false;
+            return [false, ""];
         }
-        return false;
+        return [false, ""];
     };
 }
 export function createTimeoutChecker(onTimeout, time, autoStart = true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bililive-tools/manager",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Batch scheduling recorders",
   "main": "./lib/index.js",
   "type": "module",
@@ -32,7 +32,7 @@
   "author": "renmu123",
   "license": "LGPL",
   "dependencies": {
-    "@renmu/fluent-ffmpeg": "2.3.2",
+    "@renmu/fluent-ffmpeg": "2.3.3",
     "fast-xml-parser": "^4.5.0",
     "filenamify": "^6.0.0",
     "mitt": "^3.0.1",