@bililive-tools/manager 1.5.0 → 1.6.1

package/lib/recorder/index.d.ts

@@ -0,0 +1,26 @@
+import { FFMPEGRecorder } from "./FFMPEGRecorder.js";
+import { mesioRecorder } from "./mesioRecorder.js";
+export { FFMPEGRecorder } from "./FFMPEGRecorder.js";
+export { mesioRecorder } from "./mesioRecorder.js";
+import type { IRecorder, FFMPEGRecorderOptions, MesioRecorderOptions } from "./IRecorder.js";
+/**
+ * 录制器类型
+ */
+export type RecorderType = "ffmpeg" | "mesio";
+/**
+ * 根据录制器类型获取对应的配置选项类型
+ */
+export type RecorderOptions<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorderOptions : MesioRecorderOptions;
+/**
+ * 根据录制器类型获取对应的录制器实例类型
+ */
+export type RecorderInstance<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorder : mesioRecorder;
+/**
+ * 创建录制器的工厂函数
+ */
+export declare function createBaseRecorder<T extends RecorderType>(type: T, opts: RecorderOptions<T> & {
+    mesioOptions?: string[];
+}, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+    title?: string;
+    cover?: string;
+}>): IRecorder;

package/lib/recorder/index.js

@@ -0,0 +1,18 @@
+import { FFMPEGRecorder } from "./FFMPEGRecorder.js";
+import { mesioRecorder } from "./mesioRecorder.js";
+export { FFMPEGRecorder } from "./FFMPEGRecorder.js";
+export { mesioRecorder } from "./mesioRecorder.js";
+/**
+ * 创建录制器的工厂函数
+ */
+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,46 @@
+import EventEmitter from "node:events";
+import { IRecorder, MesioRecorderOptions } from "./IRecorder.js";
+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 implements IRecorder {
+    private onEnd;
+    private onUpdateLiveInfo;
+    private command;
+    private streamManager;
+    readonly hasSegment: boolean;
+    readonly getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    readonly segment: number;
+    readonly inputOptions: string[];
+    readonly isHls: boolean;
+    readonly disableDanma: boolean;
+    readonly url: string;
+    readonly headers: {
+        [key: string]: string | undefined;
+    } | undefined;
+    constructor(opts: MesioRecorderOptions, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+        title?: string;
+        cover?: string;
+    }>);
+    createCommand(): MesioCommand;
+    run(): void;
+    getArguments(): string[];
+    stop(): Promise<void>;
+    getExtraDataController(): import("../xml_stream_controller.js").XmlStreamController | null;
+}
+export {};

package/lib/recorder/mesioRecorder.js

@@ -0,0 +1,195 @@
+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 "../xml_stream_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("../xml_stream_controller.js").XmlStreamController | 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 "../xml_stream_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;
@@ -64,10 +64,17 @@ export class Segment extends EventEmitter {
         });
         ensureFolderExist(this.outputVideoFilePath);
         if (!this.disableDanma) {
-            this.extraDataController = createRecordExtraDataController(`${this.outputVideoFilePath}.json`);
+            this.extraDataController = createRecordExtraDataController(`${this.outputVideoFilePath}.xml`);
+        }
+        // 支持两种格式的正则表达式
+        // 1. FFmpeg格式: Opening 'filename' for writing
+        // 2. Mesio格式: Opening FLV segment path=filename Processing
+        const ffmpegRegex = /'([^']+)'/;
+        const mesioRegex = /segment path=(.+?\.(?:flv|ts|m4s))/is;
+        let match = stderrLine.match(ffmpegRegex);
+        if (!match) {
+            match = cleanTerminalText(stderrLine).match(mesioRegex);
         }
-        const regex = /'([^']+)'/;
-        const match = stderrLine.match(regex);
         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) {
@@ -113,36 +122,50 @@ export class StreamManager extends EventEmitter {
             });
         }
         else {
-            const extraDataSavePath = replaceExtName(recordSavePath, ".json");
+            const extraDataSavePath = replaceExtName(recordSavePath, ".xml");
             if (!disableDanma) {
                 this.extraDataController = createRecordExtraDataController(extraDataSavePath);
             }
         }
     }
     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> {
@@ -9,6 +10,7 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     channelId: ChannelId;
     id?: string;
     remarks?: string;
+    weight?: number;
     disableAutoCheck?: boolean;
     disableProvideCommentsWhenRecording?: boolean;
     quality: Quality;
@@ -24,7 +26,7 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     /** 身份验证 */
     auth?: string;
     /** cookie所有者uid,B站弹幕录制 */
-    uid?: number;
+    uid?: number | string;
     /** 画质匹配重试次数 */
     qualityRetry?: number;
     /** 抖音是否使用双屏直播流，开启后如果是双屏直播，那么就使用拼接的流，默认为true */
@@ -37,12 +39,14 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     formatName?: FormatName;
     /** 流编码 */
     codecName?: CodecName;
-    /** 选择使用的api，虎牙支持 */
-    api?: "auto" | "web" | "mp";
+    /** 选择使用的api，虎牙支持: auto,web,mp，抖音支持：web,webHTML,mobile,userHTML */
+    api?: "auto" | "web" | "mp" | "webHTML" | "mobile" | "userHTML";
     /** 标题关键词，如果直播间标题包含这些关键词，则不会自动录制（仅对斗鱼有效），多个关键词用英文逗号分隔 */
     titleKeywords?: string;
     /** 用于指定录制文件格式，auto时，分段使用ts，不分段使用mp4 */
     videoFormat?: "auto" | "ts" | "mkv";
+    /** 录制类型 */
+    recorderType?: "auto" | "ffmpeg" | "mesio";
     /** 流格式优先级 */
     formatriorities?: Array<"flv" | "hls">;
     /** 只录制音频 */
@@ -52,9 +56,10 @@ 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 RecorderState = "idle" | "recording" | "stopping-record";
+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" | "check-error";
 export type Progress = {
     time: string | null;
 };
@@ -106,7 +111,7 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
     state: RecorderState;
     qualityMaxRetry: number;
     qualityRetry: number;
-    uid?: number;
+    uid?: number | string;
     liveInfo?: {
         living: boolean;
         owner: string;
@@ -117,6 +122,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) {