@bililive-tools/manager 1.9.0 → 1.10.0

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

@@ -10,12 +10,10 @@ export class Segment extends EventEmitter {
     rawRecordingVideoPath;
     /** 输出文件名名，不包含拓展名 */
     outputVideoFilePath;
-    disableDanma;
     videoExt;
-    constructor(getSavePath, disableDanma, videoExt) {
+    constructor(getSavePath, videoExt) {
         super();
         this.getSavePath = getSavePath;
-        this.disableDanma = disableDanma;
         this.videoExt = videoExt;
     }
     async handleSegmentEnd() {
@@ -69,9 +67,7 @@ export class Segment extends EventEmitter {
             title: liveInfo?.title,
         });
         ensureFolderExist(this.outputVideoFilePath);
-        if (!this.disableDanma) {
-            this.extraDataController = createRecordExtraDataController(`${this.outputVideoFilePath}.xml`);
-        }
+        this.extraDataController = createRecordExtraDataController(`${this.outputVideoFilePath}.xml`);
         // 支持两种格式的正则表达式
         // 1. FFmpeg格式: Opening 'filename' for writing
         // 2. Mesio格式: Opening FLV segment path=filename Processing
@@ -107,19 +103,19 @@ export class StreamManager extends EventEmitter {
     recordSavePath;
     recordStartTime;
     hasSegment;
-    recorderType = "ffmpeg";
+    recorderType;
     videoFormat;
     callBack;
-    constructor(getSavePath, hasSegment, disableDanma, recorderType, videoFormat, callBack) {
+    constructor(getSavePath, hasSegment, recorderType, videoFormat, callBack) {
         super();
         const recordSavePath = getSavePath({ startTime: Date.now() });
         this.recordSavePath = recordSavePath;
-        this.videoFormat = videoFormat ?? "auto";
+        this.videoFormat = videoFormat;
         this.recorderType = recorderType;
         this.hasSegment = hasSegment;
         this.callBack = callBack;
         if (hasSegment) {
-            this.segment = new Segment(getSavePath, disableDanma, this.videoExt);
+            this.segment = new Segment(getSavePath, this.videoExt);
             this.segment.on("DebugLog", (data) => {
                 this.emit("DebugLog", data);
             });
@@ -132,9 +128,7 @@ export class StreamManager extends EventEmitter {
         }
         else {
             const extraDataSavePath = replaceExtName(recordSavePath, ".xml");
-            if (!disableDanma) {
-                this.extraDataController = createRecordExtraDataController(extraDataSavePath);
-            }
+            this.extraDataController = createRecordExtraDataController(extraDataSavePath);
         }
     }
     async handleVideoStarted(stderrLine) {
@@ -196,18 +190,7 @@ export class StreamManager extends EventEmitter {
         return this.segment?.extraDataController || this.extraDataController;
     }
     get videoExt() {
-        if (this.recorderType === "ffmpeg") {
-            return this.videoFormat;
-        }
-        else if (this.recorderType === "mesio") {
-            return this.videoFormat;
-        }
-        else if (this.recorderType === "bililive") {
-            return "flv";
-        }
-        else {
-            throw new Error("Unknown recorderType");
-        }
+        return this.videoFormat;
     }
     get videoFilePath() {
         if (this.recorderType === "ffmpeg") {

package/lib/index.d.ts

@@ -6,9 +6,11 @@ import utils from "./utils.js";
 export * from "./common.js";
 export * from "./recorder.js";
 export * from "./manager.js";
+export * from "./cache.js";
 export * from "./record_extra_data_controller.js";
-export * from "./recorder/FFMPEGRecorder.js";
-export { createBaseRecorder } from "./recorder/index.js";
+export * from "./downloader/FFmpegDownloader.js";
+export { createDownloader } from "./downloader/index.js";
+export { checkTitleKeywordsWhileRecording, checkTitleKeywordsBeforeRecord } from "./utils.js";
 export { utils };
 /**
  * 提供一些 utils
@@ -25,3 +27,4 @@ export declare function setBililivePath(newPath: string): void;
 export declare function getBililivePath(): string;
 export declare function getDataFolderPath<E extends AnyObject>(provider: RecorderProvider<E>): string;
 export type VideoFormat = "auto" | "ts" | "mkv" | "flv" | "mp4" | "m4s";
+export type TrueVideoFormat = Exclude<VideoFormat, "auto">;

package/lib/index.js

@@ -5,9 +5,11 @@ import utils from "./utils.js";
 export * from "./common.js";
 export * from "./recorder.js";
 export * from "./manager.js";
+export * from "./cache.js";
 export * from "./record_extra_data_controller.js";
-export * from "./recorder/FFMPEGRecorder.js";
-export { createBaseRecorder } from "./recorder/index.js";
+export * from "./downloader/FFmpegDownloader.js";
+export { createDownloader } from "./downloader/index.js";
+export { checkTitleKeywordsWhileRecording, checkTitleKeywordsBeforeRecord } from "./utils.js";
 export { utils };
 /**
  * 提供一些 utils

package/lib/manager.d.ts

@@ -1,9 +1,9 @@
 import { Emitter } from "mitt";
 import { ChannelId, Message } from "./common.js";
+import { RecorderCache } from "./cache.js";
 import { RecorderCreateOpts, Recorder, SerializedRecorder, RecordHandle, DebugLog, Progress } from "./recorder.js";
 import { AnyObject, UnknownObject } from "./utils.js";
-import { StreamManager } from "./recorder/streamManager.js";
-import { Cache } from "./cache.js";
+import { StreamManager } from "./downloader/streamManager.js";
 export interface RecorderProvider<E extends AnyObject> {
     id: string;
     name: string;
@@ -75,7 +75,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: Omit<RecorderCreateOpts<E>, "cache">) => Recorder<E>;
+    addRecorder: (this: RecorderManager<ME, P, PE, E>, opts: RecorderCreateOpts<E>) => 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>;
@@ -91,13 +91,15 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     ffmpegOutputArgs: string;
     /** b站使用批量查询接口 */
     biliBatchQuery: boolean;
-    /** 测试：录制错误立即重试 */
+    /** 下播延迟检查 */
     recordRetryImmediately: boolean;
-    /** 缓存实例 */
-    cache: Cache;
+    /** 缓存系统 */
+    cache: RecorderCache;
 }
 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[];
+    /** 自定义缓存实现，不提供则使用默认的内存缓存 */
+    cache?: RecorderCache;
 };
 export declare function createRecorderManager<ME extends AnyObject = UnknownObject, P extends RecorderProvider<AnyObject> = RecorderProvider<UnknownObject>, PE extends AnyObject = GetProviderExtra<P>, E extends AnyObject = ME & PE>(opts: RecorderManagerCreateOpts<ME, P, PE, E>): RecorderManager<ME, P, PE, E>;
 export declare function genSavePathFromRule<ME extends AnyObject, P extends RecorderProvider<AnyObject>, PE extends AnyObject, E extends AnyObject>(manager: RecorderManager<ME, P, PE, E>, recorder: Recorder<E>, extData: {
@@ -108,4 +110,4 @@ export declare function genSavePathFromRule<ME extends AnyObject, P extends Reco
     recordStartTime: Date;
 }): string;
 export type GetProviderExtra<P> = P extends RecorderProvider<infer E> ? E : never;
-export { StreamManager, Cache };
+export { StreamManager };

package/lib/manager.js

@@ -3,10 +3,10 @@ import mitt from "mitt";
 import ejs from "ejs";
 import { omit, range } from "lodash-es";
 import { parseArgsStringToArgv } from "string-argv";
+import { RecorderCacheImpl, MemoryCacheStore } from "./cache.js";
 import { getBiliStatusInfoByRoomIds } from "./api.js";
 import { formatDate, removeSystemReservedChars, formatTemplate, replaceExtName, downloadImage, isBetweenTimeRange, sleep, } from "./utils.js";
-import { StreamManager } from "./recorder/streamManager.js";
-import { Cache } from "./cache.js";
+import { StreamManager } from "./downloader/streamManager.js";
 const configurableProps = [
     "savePathRule",
     "autoRemoveSystemReservedChars",
@@ -97,8 +97,6 @@ export function createRecorderManager(opts) {
     const liveStartObj = {};
     // 用于记录触发重试直播场次的次数
     const retryCountObj = {};
-    // 获取缓存单例
-    const cache = Cache.getInstance();
     const manager = {
         // @ts-ignore
         ...mitt(),
@@ -115,8 +113,10 @@ export function createRecorderManager(opts) {
             // provider.createRecorder 能返回 Recorder<PE> 才能进一步优化。
             const recorder = provider.createRecorder({
                 ...omit(opts, ["providerId"]),
-                cache,
+                // cache,
             });
+            // 为录制器注入独立的缓存命名空间
+            recorder.cache = this.cache.createNamespace(recorder.id);
             this.recorders.push(recorder);
             recorder.on("RecordStart", (recordHandle) => this.emit("RecordStart", { recorder: recorder.toJSON(), recordHandle }));
             recorder.on("RecordSegment", (recordHandle) => this.emit("RecordSegment", { recorder: recorder.toJSON(), recordHandle }));
@@ -133,29 +133,32 @@ export function createRecorderManager(opts) {
             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"，说明直播由于某些原因中断了，虽然会在下一次周期检查中继续，但是会遗漏一段时间。
-                // 这时候可以触发一次检查，但出于直播可能抽风的原因，为避免风控，一场直播最多触发五次。
-                // 测试阶段，还需要一个开关，默认关闭，几个版本后转正使用
+                const maxRetryCount = 10;
+                // 默认策略下，如果录制被中断，那么会在下一个检查周期时重新检查直播状态并重新开始录制，这种策略的问题就是一部分时间会被漏掉。
+                // 如果开启了该选项，且录制开始时间与结束时间相差在一分钟以上（某些平台下播会扔会有重复流），那么会立即进行一次检查。
                 // 也许之后还能链接复用，但也会引入更多复杂度，需要谨慎考虑
                 // 虎牙直播结束后可能额外触发导致错误，忽略虎牙直播间：https://www.huya.com/910323
                 if (manager.recordRetryImmediately &&
-                    recorder.providerId !== "HuYa" &&
-                    reason &&
-                    reason.includes("invalid stream") &&
-                    recorder?.liveInfo?.liveId) {
+                    recorder?.liveInfo?.liveId &&
+                    reason !== "manual stop") {
                     const key = `${recorder.channelId}-${recorder.liveInfo?.liveId}`;
-                    if (retryCountObj[key] > 5)
+                    const recordStartTime = recorder.liveInfo?.recordStartTime.getTime() ?? 0;
+                    const recordStopTime = Date.now();
+                    // 录制时间差在一分钟以上
+                    if (recordStopTime - recordStartTime < 60 * 1000)
+                        return;
+                    if (retryCountObj[key] > maxRetryCount)
                         return;
                     if (!retryCountObj[key]) {
                         retryCountObj[key] = 0;
                     }
-                    if (retryCountObj[key] < 5) {
+                    if (retryCountObj[key] < maxRetryCount) {
                         retryCountObj[key]++;
                     }
                     this.emit("RecorderDebugLog", {
                         recorder,
                         type: "common",
-                        text: `录制${recorder?.channelId}因“${reason}”中断，触发重试直播（${retryCountObj[key]}）`,
+                        text: `录制${recorder.channelId}中断，立即触发重试（${retryCountObj[key]}/${maxRetryCount}）`,
                     });
                     // 触发一次检查，等待一秒使状态清理完毕
                     setTimeout(() => {
@@ -214,7 +217,7 @@ export function createRecorderManager(opts) {
             if (recorder.recordHandle == null)
                 return;
             const liveId = recorder.liveInfo?.liveId;
-            await recorder.recordHandle.stop("manual stop", true);
+            await recorder.recordHandle.stop("manual stop");
             if (liveId) {
                 tempBanObj[recorder.channelId] = liveId;
                 recorder.tempStopIntervalCheck = true;
@@ -269,6 +272,7 @@ export function createRecorderManager(opts) {
         autoRemoveSystemReservedChars: opts.autoRemoveSystemReservedChars ?? true,
         biliBatchQuery: opts.biliBatchQuery ?? false,
         recordRetryImmediately: opts.recordRetryImmediately ?? false,
+        cache: opts.cache ?? new RecorderCacheImpl(new MemoryCacheStore()),
         ffmpegOutputArgs: opts.ffmpegOutputArgs ??
             "-c copy" +
                 /**
@@ -276,18 +280,7 @@ export function createRecorderManager(opts) {
                  * 最后一个片段，而 FLV 格式如果录制中 KILL 了需要手动修复下 keyframes。所以默认使用 fmp4 格式。
                  */
                 " -movflags faststart+frag_keyframe+empty_moov" +
-                /**
-                 * 浏览器加载 FragmentMP4 会需要先把它所有的 moof boxes 都加载完成后才能播放，
-                 * 默认的分段时长很小，会产生大量的 moof，导致加载很慢，所以这里设置一个分段的最小时长。
-                 *
-                 * TODO: 这个浏览器行为或许是可以优化的，比如试试给 fmp4 在录制完成后设置或者录制过程中实时更新 mvhd.duration。
-                 * https://stackoverflow.com/questions/55887980/how-to-use-media-source-extension-mse-low-latency-mode
-                 * https://stackoverflow.com/questions/61803136/ffmpeg-fragmented-mp4-takes-long-time-to-start-playing-on-chrome
-                 *
-                 * TODO: 如果浏览器行为无法优化，并且想进一步优化加载速度，可以考虑录制时使用 fmp4，录制完成后再转一次普通 mp4。
-                 */
                 " -min_frag_duration 10000000",
-        cache,
     };
     const setProvidersFFMPEGOutputArgs = (ffmpegOutputArgs) => {
         const args = parseArgsStringToArgv(ffmpegOutputArgs);
@@ -334,11 +327,10 @@ export function genSavePathFromRule(manager, recorder, extData) {
     let savePathRule = manager.savePathRule;
     try {
         savePathRule = ejs.render(savePathRule, params);
-        console.log("解析后保存路径模板：", savePathRule, params);
     }
     catch (error) {
         console.error("模板解析错误", error, savePathRule, params);
     }
     return formatTemplate(savePathRule, params);
 }
-export { StreamManager, Cache };
+export { StreamManager };

package/lib/record_extra_data_controller.d.ts

@@ -5,7 +5,7 @@ export interface RecordExtraData {
         recordStartTimestamp: number;
         recordStopTimestamp?: number;
         liveStartTimestamp?: number;
-        ffmpegArgs?: string[];
+        downloaderArgs?: string[];
         platform?: string;
         user_name?: string;
         room_id?: string;

package/lib/recorder.d.ts

@@ -2,8 +2,8 @@ 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";
-import type { RecorderType } from "./recorder/index.js";
+import type { NamespacedCache } from "./cache.js";
+import type { DownloaderType } from "./downloader/index.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> {
@@ -19,7 +19,7 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     sourcePriorities: string[];
     formatPriorities?: Array<"flv" | "hls">;
     source?: string;
-    segment?: number;
+    segment?: string;
     saveGiftDanma?: boolean;
     saveSCDanma?: boolean;
     /** 保存封面 */
@@ -59,8 +59,6 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     extra?: Partial<E>;
     /** 调试等级 */
     debugLevel?: "none" | "basic" | "verbose";
-    /** 缓存 */
-    cache: Cache;
 }
 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">;
 /** 录制状态，idle: 空闲中，recording: 录制中，stopping-record: 停止录制中，check-error: 检查错误，title-blocked: 标题黑名单 */
@@ -72,12 +70,12 @@ export interface RecordHandle {
     id: string;
     stream: string;
     source: string;
-    recorderType?: RecorderType;
+    recorderType?: DownloaderType;
     url: string;
-    ffmpegArgs?: string[];
+    downloaderArgs?: string[];
     progress?: Progress;
     savePath: string;
-    stop: (this: RecordHandle, reason?: string, tempStopIntervalCheck?: boolean) => Promise<void>;
+    stop: (this: RecordHandle, reason?: string) => Promise<void>;
     cut: (this: RecordHandle) => Promise<void>;
 }
 export interface DebugLog {
@@ -118,21 +116,21 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
     usedStream?: string;
     usedSource?: string;
     state: RecorderState;
-    qualityMaxRetry: number;
     qualityRetry: number;
     uid?: number | string;
     liveInfo?: {
         living: boolean;
         owner: string;
         title: string;
-        startTime: Date;
+        liveStartTime: Date;
         avatar: string;
         cover: string;
         liveId?: string;
+        recordStartTime: Date;
     };
     tempStopIntervalCheck?: boolean;
-    /** 缓存实例引用，由 manager 设置 */
-    cache: Cache;
+    /** 缓存实例（命名空间） */
+    cache: NamespacedCache;
     getChannelURL: (this: Recorder<E>) => string;
     checkLiveStatusAndRecord: (this: Recorder<E>, opts: {
         getSavePath: GetSavePath;
@@ -148,7 +146,7 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
         cover: string;
         channelId: ChannelId;
         living: boolean;
-        startTime: Date;
+        liveStartTime: Date;
     }>;
     getStream: (this: Recorder<E>) => Promise<{
         source: string;

package/lib/utils.d.ts

@@ -1,4 +1,5 @@
 import { DebouncedFunc } from "lodash-es";
+import type { Recorder } from "./recorder.js";
 export type AnyObject = Record<string, any>;
 export type UnknownObject = Record<string, unknown>;
 export type PickRequired<T, K extends keyof T> = T & Pick<Required<T>, K>;
@@ -74,6 +75,14 @@ export declare function sortByKeyOrder<T, K extends keyof T>(objects: T[], order
 export declare function retry<T>(fn: () => Promise<T>, retries?: number, delay?: number): Promise<T>;
 export declare const isBetweenTimeRange: (range: undefined | [] | [string | null, string | null]) => boolean;
 export declare const sleep: (ms: number) => Promise<unknown>;
+/**
+ * 判断是否应该使用严格画质模式
+ * @param qualityRetryLeft 剩余的画质重试次数
+ * @param qualityRetry 初始画质重试次数配置
+ * @param isManualStart 是否手动启动
+ * @returns 是否使用严格画质模式
+ */
+export declare function shouldUseStrictQuality(qualityRetryLeft: number, qualityRetry: number, isManualStart?: boolean): boolean;
 /**
  * 检查标题是否包含黑名单关键词
  */
@@ -82,6 +91,24 @@ declare function hasBlockedTitleKeywords(title: string, titleKeywords: string |
  * 检查是否需要进行标题关键词检查
  */
 declare function shouldCheckTitleKeywords(isManualStart: boolean | undefined, titleKeywords: string | undefined): boolean;
+/**
+ * 逆向格式化"xxxB", "xxxKB", "xxxMB", "xxxGB"为字节数，如果值为空返回0，如果为数字则直接返回数字，如果带单位则转换为字节数
+ * @param sizeStr 大小字符串
+ * @returns 字节数
+ */
+export declare function parseSizeToBytes(sizeStr: string): number | string;
+export declare const byte2MB: (bytes: number) => number;
+export declare function checkTitleKeywordsWhileRecording(recorder: Recorder, isManualStart: boolean | undefined, getInfo: (channelId: string) => Promise<{
+    title: string;
+}>): Promise<boolean>;
+/**
+ * 检查开始录制前的标题关键词
+ * @param title 直播间标题
+ * @param recorder 录制器实例
+ * @param isManualStart 是否手动启动
+ * @returns 如果标题包含关键词返回 true（不应录制），否则返回 false
+ */
+export declare function checkTitleKeywordsBeforeRecord(title: string, recorder: Recorder, isManualStart: boolean | undefined): boolean;
 declare const _default: {
     replaceExtName: typeof replaceExtName;
     singleton: typeof singleton;
@@ -103,6 +130,9 @@ declare const _default: {
     isBetweenTimeRange: (range: undefined | [] | [string | null, string | null]) => boolean;
     hasBlockedTitleKeywords: typeof hasBlockedTitleKeywords;
     shouldCheckTitleKeywords: typeof shouldCheckTitleKeywords;
+    shouldUseStrictQuality: typeof shouldUseStrictQuality;
     sleep: (ms: number) => Promise<unknown>;
+    checkTitleKeywordsWhileRecording: typeof checkTitleKeywordsWhileRecording;
+    checkTitleKeywordsBeforeRecord: typeof checkTitleKeywordsBeforeRecord;
 };
 export default _default;

package/lib/utils.js

@@ -327,6 +327,32 @@ function isBetweenTime(currentTime, timeRange) {
     return start <= current && current <= end;
 }
 export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * 判断是否应该使用严格画质模式
+ * @param qualityRetryLeft 剩余的画质重试次数
+ * @param qualityRetry 初始画质重试次数配置
+ * @param isManualStart 是否手动启动
+ * @returns 是否使用严格画质模式
+ */
+export function shouldUseStrictQuality(qualityRetryLeft, qualityRetry, isManualStart) {
+    // 手动启动时不使用严格模式
+    if (isManualStart) {
+        return false;
+    }
+    // 如果配置为0，不使用严格模式
+    if (qualityRetry === 0) {
+        return false;
+    }
+    // 如果还有重试次数，使用严格模式
+    if (qualityRetryLeft > 0) {
+        return true;
+    }
+    // 如果配置为负数（无限重试），使用严格模式
+    if (qualityRetry < 0) {
+        return true;
+    }
+    return false;
+}
 /**
  * 检查标题是否包含黑名单关键词
  */
@@ -343,6 +369,106 @@ function hasBlockedTitleKeywords(title, titleKeywords) {
 function shouldCheckTitleKeywords(isManualStart, titleKeywords) {
     return (!isManualStart && !!titleKeywords && typeof titleKeywords === "string" && !!titleKeywords.trim());
 }
+/**
+ * 逆向格式化"xxxB", "xxxKB", "xxxMB", "xxxGB"为字节数，如果值为空返回0，如果为数字则直接返回数字，如果带单位则转换为字节数
+ * @param sizeStr 大小字符串
+ * @returns 字节数
+ */
+export function parseSizeToBytes(sizeStr) {
+    if (!sizeStr) {
+        return 0;
+    }
+    // 字符类型的数字
+    if (!isNaN(Number(sizeStr))) {
+        return Number(sizeStr);
+    }
+    const sizePattern = /^(\d+(?:\.\d+)?)(B|KB|MB|GB)$/i;
+    const match = sizeStr.toUpperCase().trim().match(sizePattern);
+    if (match) {
+        const size = parseFloat(match[1]);
+        const unit = match[2];
+        switch (unit) {
+            case "B":
+                return String(size);
+            case "KB":
+                return String(size * 1024);
+            case "MB":
+                return String(size * 1024 * 1024);
+            case "GB":
+                return String(size * 1024 * 1024 * 1024);
+            default:
+                return 0;
+        }
+    }
+    else {
+        return 0;
+    }
+}
+export const byte2MB = (bytes) => {
+    return bytes / (1024 * 1024);
+};
+/*
+ * 检查录制中的标题关键词
+ * @param recorder 录制器实例
+ * @param isManualStart 是否手动启动
+ * @param getInfo 获取直播间信息的函数
+ * @returns 如果标题包含关键词返回 true（需要停止），否则返回 false
+ */
+export async function checkTitleKeywordsWhileRecording(recorder, isManualStart, getInfo) {
+    // 只有当设置了标题关键词时，并且不是手动启动的录制，才获取最新的直播间信息
+    if (!shouldCheckTitleKeywords(isManualStart, recorder.titleKeywords)) {
+        return false;
+    }
+    const now = Date.now();
+    // 每5分钟检查一次标题变化
+    const titleCheckInterval = 5 * 60 * 1000; // 5分钟
+    // 获取上次检查时间
+    const lastCheckTime = await recorder.cache.get("lastTitleCheckTime");
+    // 如果距离上次检查时间不足指定间隔，则跳过检查
+    if (lastCheckTime && now - lastCheckTime < titleCheckInterval) {
+        return false;
+    }
+    // 更新检查时间
+    await recorder.cache.set("lastTitleCheckTime", now);
+    // 获取直播间信息
+    const liveInfo = await getInfo(recorder.channelId);
+    const { title } = liveInfo;
+    // 检查标题是否包含关键词
+    if (hasBlockedTitleKeywords(title, recorder.titleKeywords)) {
+        recorder.state = "title-blocked";
+        recorder.emit("DebugLog", {
+            type: "common",
+            text: `检测到标题包含关键词，停止录制：直播间标题 "${title}" 包含关键词 "${recorder.titleKeywords}"`,
+        });
+        // 停止录制
+        await recorder?.recordHandle?.stop("直播间标题包含关键词");
+        return true;
+    }
+    return false;
+}
+/**
+ * 检查开始录制前的标题关键词
+ * @param title 直播间标题
+ * @param recorder 录制器实例
+ * @param isManualStart 是否手动启动
+ * @returns 如果标题包含关键词返回 true（不应录制），否则返回 false
+ */
+export function checkTitleKeywordsBeforeRecord(title, recorder, isManualStart) {
+    // 检查标题是否包含关键词，如果包含则不自动录制
+    // 手动开始录制时不检查标题关键词
+    if (!shouldCheckTitleKeywords(isManualStart, recorder.titleKeywords)) {
+        return false;
+    }
+    if (hasBlockedTitleKeywords(title, recorder.titleKeywords)) {
+        recorder.state = "title-blocked";
+        recorder.emit("DebugLog", {
+            type: "common",
+            text: `跳过录制：直播间标题 "${title}" 包含关键词 "${recorder.titleKeywords}"`,
+        });
+        return true;
+    }
+    return false;
+}
 export default {
     replaceExtName,
     singleton,
@@ -364,5 +490,8 @@ export default {
     isBetweenTimeRange,
     hasBlockedTitleKeywords,
     shouldCheckTitleKeywords,
+    shouldUseStrictQuality,
     sleep,
+    checkTitleKeywordsWhileRecording,
+    checkTitleKeywordsBeforeRecord,
 };

package/lib/xml_stream_controller.d.ts

@@ -5,7 +5,7 @@ export interface XmlStreamData {
         recordStartTimestamp: number;
         recordStopTimestamp?: number;
         liveStartTimestamp?: number;
-        ffmpegArgs?: string[];
+        downloaderArgs?: string[];
         platform?: string;
         user_name?: string;
         room_id?: string;

package/package.json

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

package/lib/recorder/index.d.ts

@@ -1,48 +0,0 @@
-import { FFMPEGRecorder } from "./FFMPEGRecorder.js";
-import { MesioRecorder } from "./mesioRecorder.js";
-import { BililiveRecorder } from "./BililiveRecorder.js";
-export { FFMPEGRecorder } from "./FFMPEGRecorder.js";
-export { MesioRecorder } from "./mesioRecorder.js";
-export { BililiveRecorder } from "./BililiveRecorder.js";
-import type { IRecorder, FFMPEGRecorderOptions, MesioRecorderOptions, BililiveRecorderOptions } from "./IRecorder.js";
-/**
- * 录制器类型
- */
-export type RecorderType = "ffmpeg" | "mesio" | "bililive";
-export type FormatName = "flv" | "ts" | "fmp4";
-/**
- * 根据录制器类型获取对应的配置选项类型
- */
-export type RecorderOptions<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorderOptions : T extends "mesio" ? MesioRecorderOptions : BililiveRecorderOptions;
-/**
- * 根据录制器类型获取对应的录制器实例类型
- */
-export type RecorderInstance<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorder : T extends "mesio" ? MesioRecorder : BililiveRecorder;
-type RecorderOpts = FFMPEGRecorderOptions | MesioRecorderOptions | BililiveRecorderOptions;
-/**
- * 创建录制器的工厂函数
- */
-export declare function createRecorder<T extends RecorderType>(type: T, opts: RecorderOptions<T> & {
-    onlyAudio?: boolean;
-}, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
-    title?: string;
-    cover?: string;
-}>): IRecorder;
-/**
- * 选择录制器
- */
-export declare function selectRecorder(preferredRecorder: "auto" | RecorderType | undefined): RecorderType;
-/**
- * 判断原始录制流格式，flv, ts, m4s
- */
-export declare function getSourceFormatName(streamUrl: string, formatName: FormatName | undefined): FormatName;
-type PickPartial<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Partial<Pick<T, K>>;
-/**
- * 创建录制器的工厂函数
- */
-export declare function createBaseRecorder(type: "auto" | RecorderType | undefined, opts: PickPartial<RecorderOpts, "formatName"> & {
-    onlyAudio?: boolean;
-}, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
-    title?: string;
-    cover?: string;
-}>): IRecorder;