@bililive-tools/manager 1.2.1 → 1.3.0

package/lib/FFMPEGRecorder.d.ts

@@ -1,12 +1,14 @@
 import EventEmitter from "node:events";
 export declare class FFMPEGRecorder extends EventEmitter {
     private onEnd;
+    private onUpdateLiveInfo;
     private command;
     private streamManager;
     private timeoutChecker;
     hasSegment: boolean;
     getSavePath: (data: {
         startTime: number;
+        title?: string;
     }) => string;
     segment: number;
     ffmpegOutputOptions: string[];
@@ -14,10 +16,14 @@ export declare class FFMPEGRecorder extends EventEmitter {
     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[];
@@ -25,8 +31,14 @@ export declare class FFMPEGRecorder extends EventEmitter {
         isHls?: boolean;
         disableDanma?: boolean;
         videoFormat?: "auto" | "ts" | "mkv";
-    }, onEnd: (...args: unknown[]) => void);
-    private createCommand;
+        headers?: {
+            [key: string]: string | undefined;
+        };
+    }, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+        title?: string;
+        cover?: string;
+    }>);
+    createCommand(): import("@renmu/fluent-ffmpeg").FfmpegCommand;
     formatLine(line: string): {
         time: string | null;
     } | null;

package/lib/FFMPEGRecorder.js

@@ -3,6 +3,7 @@ import { createFFMPEGBuilder, StreamManager, utils } from "./index.js";
 import { createInvalidStreamChecker, assert } from "./utils.js";
 export class FFMPEGRecorder extends EventEmitter {
     onEnd;
+    onUpdateLiveInfo;
     command;
     streamManager;
     timeoutChecker;
@@ -11,26 +12,36 @@ export class FFMPEGRecorder extends EventEmitter {
     segment;
     ffmpegOutputOptions = [];
     inputOptions = [];
-    isHls = false;
+    isHls;
     disableDanma = false;
     url;
-    constructor(opts, onEnd) {
+    headers;
+    constructor(opts, onEnd, onUpdateLiveInfo) {
         super();
         this.onEnd = onEnd;
+        this.onUpdateLiveInfo = onUpdateLiveInfo;
         const hasSegment = !!opts.segment;
         this.disableDanma = opts.disableDanma ?? false;
-        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, opts.videoFormat);
-        this.timeoutChecker = utils.createTimeoutChecker(() => this.onEnd("ffmpeg timeout"), 3 * 10e3);
+        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, opts.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.isHls = opts.isHls ?? false;
+        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 }) => {
-            this.emit("videoFileCreated", { filename });
+        this.streamManager.on("videoFileCreated", ({ filename, cover }) => {
+            this.emit("videoFileCreated", { filename, cover });
         });
         this.streamManager.on("videoFileCompleted", ({ filename }) => {
             this.emit("videoFileCompleted", { filename });
@@ -40,15 +51,28 @@ export class FFMPEGRecorder extends EventEmitter {
         });
     }
     createCommand() {
+        this.timeoutChecker?.start();
         const invalidCount = this.isHls ? 35 : 15;
         const isInvalidStream = createInvalidStreamChecker(invalidCount);
-        const command = createFFMPEGBuilder()
-            .input(this.url)
-            .inputOptions([
+        const inputOptions = [
             ...this.inputOptions,
             "-user_agent",
             "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36",
-        ])
+        ];
+        if (this.headers) {
+            const headers = [];
+            Object.entries(this.headers).forEach(([key, value]) => {
+                if (!value)
+                    return;
+                headers.push(`${key}:${value}`);
+            });
+            if (headers.length) {
+                inputOptions.push("-headers", headers.join("\\r\\n"));
+            }
+        }
+        const command = createFFMPEGBuilder()
+            .input(this.url)
+            .inputOptions(inputOptions)
             .outputOptions(this.ffmpegOutputOptions)
             .output(this.streamManager.videoFilePath)
             .on("error", this.onEnd)
@@ -56,7 +80,6 @@ export class FFMPEGRecorder extends EventEmitter {
             .on("stderr", async (stderrLine) => {
             assert(typeof stderrLine === "string");
             await this.streamManager.handleVideoStarted(stderrLine);
-            // TODO:解析时间
             this.emit("DebugLog", { type: "ffmpeg", text: stderrLine });
             const info = this.formatLine(stderrLine);
             if (info) {
@@ -66,7 +89,7 @@ export class FFMPEGRecorder extends EventEmitter {
                 this.onEnd("invalid stream");
             }
         })
-            .on("stderr", this.timeoutChecker.update);
+            .on("stderr", this.timeoutChecker?.update);
         if (this.hasSegment) {
             command.outputOptions("-f", "segment", "-segment_time", String(this.segment * 60), "-reset_timestamps", "1");
         }
@@ -94,8 +117,9 @@ export class FFMPEGRecorder extends EventEmitter {
     async stop() {
         this.timeoutChecker.stop();
         try {
+            this.command.kill("SIGINT");
             // @ts-ignore
-            this.command.ffmpegProc?.stdin?.write("q");
+            // this.command.ffmpegProc?.stdin?.write("q");
             await this.streamManager.handleVideoCompleted();
         }
         catch (err) {

package/lib/common.d.ts

@@ -4,7 +4,7 @@ export declare const Qualities: readonly ["lowest", "low", "medium", "high", "hi
 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 DouYinQualities: readonly ["origin", "uhd", "hd", "sd", "ld", "ao"];
+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> {
     uid?: string;

package/lib/common.js

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

package/lib/manager.d.ts

@@ -36,6 +36,7 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     videoFileCreated: {
         recorder: Recorder<E>;
         filename: string;
+        cover?: string;
     };
     videoFileCompleted: {
         recorder: Recorder<E>;
@@ -75,6 +76,7 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     removeRecorder: (this: RecorderManager<ME, P, PE, E>, recorder: Recorder<E>) => void;
     startRecord: (this: RecorderManager<ME, P, PE, E>, id: string) => Promise<Recorder<E> | undefined>;
     stopRecord: (this: RecorderManager<ME, P, PE, E>, id: string) => Promise<Recorder<E> | undefined>;
+    cutRecord: (this: RecorderManager<ME, P, PE, E>, id: string) => Promise<Recorder<E> | undefined>;
     autoCheckInterval: number;
     isCheckLoopRunning: boolean;
     startCheckLoop: (this: RecorderManager<ME, P, PE, E>) => void;

package/lib/manager.js

@@ -104,10 +104,10 @@ export function createRecorderManager(opts) {
             this.recorders.push(recorder);
             recorder.on("RecordStart", (recordHandle) => this.emit("RecordStart", { recorder, recordHandle }));
             recorder.on("RecordSegment", (recordHandle) => this.emit("RecordSegment", { recorder, recordHandle }));
-            recorder.on("videoFileCreated", ({ filename }) => {
+            recorder.on("videoFileCreated", ({ filename, cover }) => {
                 if (recorder.saveCover && recorder?.liveInfo?.cover) {
                     const coverPath = replaceExtName(filename, ".jpg");
-                    downloadImage(recorder?.liveInfo?.cover, coverPath);
+                    downloadImage(cover ?? recorder?.liveInfo?.cover, coverPath);
                 }
                 this.emit("videoFileCreated", { recorder, filename });
             });
@@ -119,8 +119,10 @@ export function createRecorderManager(opts) {
             recorder.on("progress", (progress) => {
                 this.emit("RecorderProgress", { recorder, progress });
             });
-            recorder.on("LiveStart", ({ liveId }) => {
-                const key = `${recorder.channelId}-${liveId}`;
+            recorder.on("videoFileCreated", () => {
+                if (!recorder.liveInfo?.liveId)
+                    return;
+                const key = `${recorder.channelId}-${recorder.liveInfo?.liveId}`;
                 if (liveStartObj[key])
                     return;
                 liveStartObj[key] = true;
@@ -168,6 +170,15 @@ export function createRecorderManager(opts) {
             }
             return recorder;
         },
+        async cutRecord(id) {
+            const recorder = this.recorders.find((item) => item.id === id);
+            if (recorder == null)
+                return;
+            if (recorder.recordHandle == null)
+                return;
+            await recorder.recordHandle.cut();
+            return recorder;
+        },
         autoCheckInterval: opts.autoCheckInterval ?? 1000,
         isCheckLoopRunning: false,
         startCheckLoop() {
@@ -221,7 +232,7 @@ export function createRecorderManager(opts) {
                  *
                  * TODO: 如果浏览器行为无法优化，并且想进一步优化加载速度，可以考虑录制时使用 fmp4，录制完成后再转一次普通 mp4。
                  */
-                " -min_frag_duration 60000000",
+                " -min_frag_duration 10000000",
     };
     const setProvidersFFMPEGOutputArgs = (ffmpegOutputArgs) => {
         const args = parseArgsStringToArgv(ffmpegOutputArgs);

package/lib/record_extra_data_controller.js

@@ -62,7 +62,7 @@ export function convert2Xml(data) {
     const comments = data.messages
         .filter((item) => item.type === "comment")
         .map((ele) => {
-        const progress = (ele.timestamp - metadata?.recordStartTimestamp) / 1000;
+        const progress = Math.max((ele.timestamp - metadata.recordStartTimestamp) / 1000, 0);
         const data = {
             "@@p": "",
             "@@progress": progress,
@@ -93,7 +93,7 @@ export function convert2Xml(data) {
     const gifts = data.messages
         .filter((item) => item.type === "give_gift")
         .map((ele) => {
-        const progress = (ele.timestamp - metadata?.recordStartTimestamp) / 1000;
+        const progress = Math.max((ele.timestamp - metadata.recordStartTimestamp) / 1000, 0);
         const data = {
             "@@ts": progress,
             "@@giftname": String(ele.name),
@@ -108,7 +108,7 @@ export function convert2Xml(data) {
     const superChats = data.messages
         .filter((item) => item.type === "super_chat")
         .map((ele) => {
-        const progress = (ele.timestamp - metadata?.recordStartTimestamp) / 1000;
+        const progress = Math.max((ele.timestamp - metadata.recordStartTimestamp) / 1000, 0);
         const data = {
             "@@ts": progress,
             "@@price": String(ele.price * 1000),
@@ -122,7 +122,7 @@ export function convert2Xml(data) {
     const guardGift = data.messages
         .filter((item) => item.type === "guard")
         .map((ele) => {
-        const progress = (ele.timestamp - metadata?.recordStartTimestamp) / 1000;
+        const progress = Math.max((ele.timestamp - metadata.recordStartTimestamp) / 1000, 0);
         const data = {
             "@@ts": progress,
             "@@price": String(ele.price * 1000),

package/lib/recorder.d.ts

@@ -14,7 +14,7 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     quality: Quality;
     streamPriorities: string[];
     sourcePriorities: string[];
-    formatPriorities?: string[];
+    formatPriorities?: Array<"flv" | "hls">;
     source?: string;
     segment?: number;
     saveGiftDanma?: boolean;
@@ -41,6 +41,8 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     titleKeywords?: string;
     /** 用于指定录制文件格式，auto时，分段使用ts，不分段使用mp4 */
     videoFormat?: "auto" | "ts" | "mkv";
+    /** 流格式优先级 */
+    formatriorities?: Array<"flv" | "hls">;
     extra?: Partial<E>;
 }
 export type SerializedRecorder<E extends AnyObject> = PickRequired<RecorderCreateOpts<E>, "id">;
@@ -57,6 +59,7 @@ export interface RecordHandle {
     progress?: Progress;
     savePath: string;
     stop: (this: RecordHandle, reason?: string, tempStopIntervalCheck?: boolean) => Promise<void>;
+    cut: (this: RecordHandle) => Promise<void>;
 }
 export interface DebugLog {
     type: string | "common" | "ffmpeg";
@@ -72,14 +75,12 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
     RecordSegment?: RecordHandle;
     videoFileCreated: {
         filename: string;
+        cover?: string;
     };
     videoFileCompleted: {
         filename: string;
     };
     progress: Progress;
-    LiveStart: {
-        liveId: string;
-    };
     RecordStop: {
         recordHandle: RecordHandle;
         reason?: string;

package/lib/streamManager.d.ts

@@ -2,6 +2,7 @@ import EventEmitter from "node:events";
 import { createRecordExtraDataController } from "./record_extra_data_controller.js";
 export type GetSavePath = (data: {
     startTime: number;
+    title?: string;
 }) => string;
 export declare class Segment extends EventEmitter {
     extraDataController: ReturnType<typeof createRecordExtraDataController> | null;
@@ -15,7 +16,12 @@ export declare class Segment extends EventEmitter {
     videoExt: "ts" | "mkv" | "mp4";
     constructor(getSavePath: GetSavePath, disableDanma: boolean, videoExt: "ts" | "mkv" | "mp4");
     handleSegmentEnd(): Promise<void>;
-    onSegmentStart(stderrLine: string): Promise<void>;
+    onSegmentStart(stderrLine: string, callBack?: {
+        onUpdateLiveInfo: () => Promise<{
+            title?: string;
+            cover?: string;
+        }>;
+    }): Promise<void>;
     get outputFilePath(): string;
 }
 export declare class StreamManager extends EventEmitter {
@@ -25,7 +31,13 @@ export declare class StreamManager extends EventEmitter {
     recordStartTime?: number;
     hasSegment: boolean;
     private videoFormat?;
-    constructor(getSavePath: GetSavePath, hasSegment: boolean, disableDanma: boolean, videoFormat?: "auto" | "ts" | "mkv");
+    private callBack?;
+    constructor(getSavePath: GetSavePath, hasSegment: boolean, disableDanma: boolean, videoFormat?: "auto" | "ts" | "mkv", callBack?: {
+        onUpdateLiveInfo: () => Promise<{
+            title?: string;
+            cover?: string;
+        }>;
+    });
     handleVideoStarted(stderrLine: string): Promise<void>;
     handleVideoCompleted(): Promise<void>;
     getExtraDataController(): import("./record_extra_data_controller.js").RecordExtraDataController | null;

package/lib/streamManager.js

@@ -1,7 +1,7 @@
 import EventEmitter from "node:events";
-import fs from "fs-extra";
+import fs from "fs/promises";
 import { createRecordExtraDataController } from "./record_extra_data_controller.js";
-import { replaceExtName, ensureFolderExist, isFfmpegStartSegment, isFfmpegStart } from "./utils.js";
+import { replaceExtName, ensureFolderExist, isFfmpegStartSegment, isFfmpegStart, retry, } from "./utils.js";
 export class Segment extends EventEmitter {
     extraDataController = null;
     init = true;
@@ -28,7 +28,7 @@ export class Segment extends EventEmitter {
         }
         try {
             await Promise.all([
-                fs.rename(this.rawRecordingVideoPath, this.outputFilePath),
+                retry(() => fs.rename(this.rawRecordingVideoPath, this.outputFilePath)),
                 this.extraDataController?.flush(),
             ]);
             this.emit("videoFileCompleted", { filename: this.outputFilePath });
@@ -40,14 +40,27 @@ export class Segment extends EventEmitter {
             });
         }
     }
-    async onSegmentStart(stderrLine) {
+    async onSegmentStart(stderrLine, callBack) {
         if (!this.init) {
             await this.handleSegmentEnd();
         }
         this.init = false;
         const startTime = Date.now();
+        let liveInfo = { title: "", cover: "" };
+        if (callBack?.onUpdateLiveInfo) {
+            try {
+                liveInfo = await callBack.onUpdateLiveInfo();
+            }
+            catch (err) {
+                this.emit("DebugLog", {
+                    type: "common",
+                    text: "onUpdateLiveInfo error " + String(err),
+                });
+            }
+        }
         this.outputVideoFilePath = this.getSavePath({
             startTime: startTime,
+            title: liveInfo?.title,
         });
         ensureFolderExist(this.outputVideoFilePath);
         if (!this.disableDanma) {
@@ -58,7 +71,11 @@ export class Segment extends EventEmitter {
         if (match) {
             const filename = match[1];
             this.rawRecordingVideoPath = filename;
-            this.emit("videoFileCreated", { filename: this.outputFilePath });
+            this.emit("videoFileCreated", {
+                filename: this.outputFilePath,
+                title: liveInfo?.title,
+                cover: liveInfo?.cover,
+            });
         }
         else {
             this.emit("DebugLog", { type: "ffmpeg", text: "No match found" });
@@ -75,12 +92,14 @@ export class StreamManager extends EventEmitter {
     recordStartTime;
     hasSegment;
     videoFormat;
-    constructor(getSavePath, hasSegment, disableDanma, videoFormat) {
+    callBack;
+    constructor(getSavePath, hasSegment, disableDanma, videoFormat, callBack) {
         super();
         const recordSavePath = getSavePath({ startTime: Date.now() });
         this.recordSavePath = recordSavePath;
         this.videoFormat = videoFormat;
         this.hasSegment = hasSegment;
+        this.callBack = callBack;
         if (hasSegment) {
             this.segment = new Segment(getSavePath, disableDanma, this.videoExt);
             this.segment.on("DebugLog", (data) => {
@@ -103,7 +122,7 @@ export class StreamManager extends EventEmitter {
     async handleVideoStarted(stderrLine) {
         if (this.segment) {
             if (isFfmpegStartSegment(stderrLine)) {
-                await this.segment.onSegmentStart(stderrLine);
+                await this.segment.onSegmentStart(stderrLine, this.callBack);
             }
         }
         else {

package/lib/utils.d.ts

@@ -39,9 +39,10 @@ export declare function isFfmpegStartSegment(line: string): boolean;
 export declare function isFfmpegStart(line: string): boolean;
 export declare const formatTemplate: (string: string, ...args: any[]) => string;
 export declare function createInvalidStreamChecker(count?: number): (ffmpegLogLine: string) => boolean;
-export declare function createTimeoutChecker(onTimeout: () => void, time: number): {
+export declare function createTimeoutChecker(onTimeout: () => void, time: number, autoStart?: boolean): {
     update: () => void;
     stop: () => void;
+    start: () => void;
 };
 export declare function downloadImage(imageUrl: string, savePath: string): Promise<void>;
 /**
@@ -52,6 +53,14 @@ export declare function downloadImage(imageUrl: string, savePath: string): Promi
  * @returns 排序后的对象数组
  */
 export declare function sortByKeyOrder<T, K extends keyof T>(objects: T[], order: T[K][], key: K): T[];
+/**
+ * 重试执行异步函数
+ * @param fn 要重试的异步函数
+ * @param retries 重试次数,默认为3次
+ * @param delay 重试延迟时间(毫秒),默认为1000ms
+ * @returns Promise
+ */
+export declare function retry<T>(fn: () => Promise<T>, retries?: number, delay?: number): Promise<T>;
 declare const _default: {
     replaceExtName: typeof replaceExtName;
     singleton: typeof singleton;
@@ -69,5 +78,6 @@ declare const _default: {
     md5: (str: string) => string;
     uuid: () => `${string}-${string}-${string}-${string}-${string}`;
     sortByKeyOrder: typeof sortByKeyOrder;
+    retry: typeof retry;
 };
 export default _default;

package/lib/utils.js

@@ -177,7 +177,7 @@ export function createInvalidStreamChecker(count = 15) {
         return false;
     };
 }
-export function createTimeoutChecker(onTimeout, time) {
+export function createTimeoutChecker(onTimeout, time, autoStart = true) {
     let timer = null;
     let stopped = false;
     const update = () => {
@@ -190,7 +190,13 @@ export function createTimeoutChecker(onTimeout, time) {
             onTimeout();
         }, time);
     };
-    update();
+    const start = () => {
+        stopped = false;
+        update();
+    };
+    if (autoStart) {
+        start();
+    }
     return {
         update,
         stop() {
@@ -199,6 +205,7 @@ export function createTimeoutChecker(onTimeout, time) {
                 clearTimeout(timer);
             timer = null;
         },
+        start,
     };
 }
 export async function downloadImage(imageUrl, savePath) {
@@ -231,6 +238,25 @@ export function sortByKeyOrder(objects, order, key) {
         return indexA - indexB;
     });
 }
+/**
+ * 重试执行异步函数
+ * @param fn 要重试的异步函数
+ * @param retries 重试次数,默认为3次
+ * @param delay 重试延迟时间(毫秒),默认为1000ms
+ * @returns Promise
+ */
+export async function retry(fn, retries = 3, delay = 1000) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        if (retries <= 0) {
+            throw err;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        return retry(fn, retries - 1, delay);
+    }
+}
 export default {
     replaceExtName,
     singleton,
@@ -248,4 +274,5 @@ export default {
     md5,
     uuid,
     sortByKeyOrder,
+    retry,
 };

package/package.json

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