@bililive-tools/manager 1.6.1 → 1.9.0

package/README.md

@@ -17,6 +17,7 @@
 | B站  | `@bililive-tools/bilibili-recorder` |
 | 斗鱼 | `@bililive-tools/douyu-recorder`    |
 | 虎牙 | `@bililive-tools/huya-recorder`     |
+| 抖音 | `@bililive-tools/douyin-recorder`   |
 
 # 使用
 
@@ -30,6 +31,8 @@ const manager = createRecorderManager({
   providers: [provider],
   savePathRule: "D:\\录制\\{platforme}}/{owner}/{year}-{month}-{date} {hour}-{min}-{sec} {title}", // 保存路径，占位符见文档，支持 [ejs](https://ejs.co/) 模板引擎
   autoCheckInterval: 1000 * 60, // 自动检查间隔，单位秒
+  maxThreadCount: 3, // 检查并发数
+  waitTime: 0, // 检查后等待时间
   autoRemoveSystemReservedChars: true, // 移除系统非法字符串
   biliBatchQuery: false, // B站检查使用批量接口
 });
@@ -75,32 +78,38 @@ manager.startCheckLoop();
 ### setFFMPEGPath & setMesioPath
 
 ```ts
-import { setFFMPEGPath, setMesioPath } from "@bililive-tools/manager";
+import { setFFMPEGPath, setMesioPath, setBililivePath } from "@bililive-tools/manager";
 
 // 设置ffmpeg可执行路径
 setFFMPEGPath("ffmpeg.exe");
 
 // 设置mesio可执行文件路径
 setMesioPath("mesio.exe");
+
+// 设置录播姬录制器的可执行文件路径
+setBililivePath("BililiveRecorder.Cli.exe");
 ```
 
 ## savePathRule 占位符参数
 
 默认值为 `{platform}/{owner}/{year}-{month}-{date} {hour}-{min}-{sec} {title}`
 
-| 值          | 标签   |
-| ----------- | ------ |
-| {platform}  | 平台   |
-| {channelId} | 房间号 |
-| {remarks}   | 备注   |
-| {owner}     | 主播名 |
-| {title}     | 标题   |
-| {year}      | 年     |
-| {month}     | 月     |
-| {date}      | 日     |
-| {hour}      | 时     |
-| {min}       | 分     |
-| {sec}       | 秒     |
+| 值                | 标签                                       |
+| ----------------- | ------------------------------------------ |
+| {platform}        | 平台                                       |
+| {channelId}       | 房间号                                     |
+| {remarks}         | 备注                                       |
+| {owner}           | 主播名                                     |
+| {title}           | 标题                                       |
+| {year}            | 年                                         |
+| {month}           | 月                                         |
+| {date}            | 日                                         |
+| {hour}            | 时                                         |
+| {min}             | 分                                         |
+| {sec}             | 秒                                         |
+| {startTime}       | 分段开始时间，Date对象                     |
+| {recordStartTime} | 录制开始时间，Date对象                     |
+| {liveStartTime}   | 直播开始时间，Date对象，抖音同录制开始时间 |
 
 ## 事件
 

package/lib/common.d.ts

@@ -1,11 +1,10 @@
 import { AnyObject, UnknownObject } from "./utils.js";
 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, -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 type Quality = string | number;
 export interface MessageSender<E extends AnyObject = UnknownObject> {
     uid?: string;
     name: string;

package/lib/common.js

@@ -1,5 +1,4 @@
 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 = [

package/lib/index.d.ts

@@ -21,4 +21,7 @@ export declare function setFFMPEGPath(newPath: string): void;
 export declare const createFFMPEGBuilder: (...args: Parameters<typeof ffmpeg>) => ffmpeg.FfmpegCommand;
 export declare function setMesioPath(newPath: string): void;
 export declare function getMesioPath(): string;
+export declare function 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";

package/lib/index.js

@@ -64,6 +64,13 @@ export function setMesioPath(newPath) {
 export function getMesioPath() {
     return mesioPath;
 }
+let bililivePath = "BililiveRecorder.Cli";
+export function setBililivePath(newPath) {
+    bililivePath = newPath;
+}
+export function getBililivePath() {
+    return bililivePath;
+}
 export function getDataFolderPath(provider) {
     return "./" + provider.id;
 }

package/lib/manager.d.ts

@@ -20,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", "recordRetryImmediately"];
+declare const configurableProps: readonly ["savePathRule", "autoRemoveSystemReservedChars", "autoCheckInterval", "maxThreadCount", "waitTime", "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: {
@@ -39,6 +39,7 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
         recorder: SerializedRecorder<E>;
         filename: string;
         cover?: string;
+        rawFilename?: string;
     };
     videoFileCompleted: {
         recorder: SerializedRecorder<E>;
@@ -80,6 +81,8 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     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;
+    maxThreadCount: number;
+    waitTime: number;
     isCheckLoopRunning: boolean;
     startCheckLoop: (this: RecorderManager<ME, P, PE, E>) => void;
     stopCheckLoop: (this: RecorderManager<ME, P, PE, E>) => void;
@@ -100,7 +103,9 @@ export declare function createRecorderManager<ME extends AnyObject = UnknownObje
 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: {
     owner: string;
     title: string;
-    startTime?: number;
+    startTime: number;
+    liveStartTime: Date;
+    recordStartTime: Date;
 }): string;
 export type GetProviderExtra<P> = P extends RecorderProvider<infer E> ? E : never;
 export { StreamManager, Cache };

package/lib/manager.js

@@ -4,13 +4,15 @@ import ejs from "ejs";
 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 { formatDate, removeSystemReservedChars, formatTemplate, replaceExtName, downloadImage, isBetweenTimeRange, sleep, } from "./utils.js";
 import { StreamManager } from "./recorder/streamManager.js";
 import { Cache } from "./cache.js";
 const configurableProps = [
     "savePathRule",
     "autoRemoveSystemReservedChars",
     "autoCheckInterval",
+    "maxThreadCount",
+    "waitTime",
     "ffmpegOutputArgs",
     "biliBatchQuery",
     "recordRetryImmediately",
@@ -38,7 +40,6 @@ export function createRecorderManager(opts) {
                 }
             }
         };
-        const maxThreadCount = 3;
         // 这里暂时不打算用 state == recording 来过滤，provider 必须内部自己处理录制过程中的 check，
         // 这样可以防止一些意外调用 checkLiveStatusAndRecord 时出现重复录制。
         let needCheckRecorders = recorders
@@ -75,10 +76,13 @@ export function createRecorderManager(opts) {
                 banLiveId,
             });
         };
-        threads = threads.concat(range(0, maxThreadCount).map(async () => {
+        threads = threads.concat(range(0, manager.maxThreadCount).map(async () => {
             while (needCheckRecorders.length > 0) {
                 try {
                     await checkOnce();
+                    if (manager.waitTime > 0) {
+                        await sleep(manager.waitTime);
+                    }
                 }
                 catch (err) {
                     manager.emit("error", { source: "checkOnceInThread", err });
@@ -116,12 +120,12 @@ export function createRecorderManager(opts) {
             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 }));
-            recorder.on("videoFileCreated", ({ filename, cover }) => {
+            recorder.on("videoFileCreated", ({ filename, cover, rawFilename }) => {
                 if (recorder.saveCover && recorder?.liveInfo?.cover) {
                     const coverPath = replaceExtName(filename, ".jpg");
                     downloadImage(cover ?? recorder?.liveInfo?.cover, coverPath);
                 }
-                this.emit("videoFileCreated", { recorder: recorder.toJSON(), filename });
+                this.emit("videoFileCreated", { recorder: recorder.toJSON(), filename, rawFilename });
             });
             recorder.on("videoFileCompleted", ({ filename }) => this.emit("videoFileCompleted", { recorder: recorder.toJSON(), filename }));
             recorder.on("Message", (message) => this.emit("Message", { recorder: recorder.toJSON(), message }));
@@ -227,6 +231,8 @@ export function createRecorderManager(opts) {
             return recorder;
         },
         autoCheckInterval: opts.autoCheckInterval ?? 1000,
+        maxThreadCount: opts.maxThreadCount ?? 3,
+        waitTime: opts.waitTime ?? 0,
         isCheckLoopRunning: false,
         startCheckLoop() {
             if (this.isCheckLoopRunning)
@@ -306,12 +312,12 @@ 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 owner = removeSystemReservedChars((extData?.owner ?? "").replaceAll("%", "_"));
+    const title = removeSystemReservedChars((extData?.title ?? "").replaceAll("%", "_"));
+    const remarks = removeSystemReservedChars((recorder.remarks ?? "").replaceAll("%", "_"));
+    const channelId = removeSystemReservedChars(String(recorder.channelId));
     const params = {
         platform: provider?.name ?? "unknown",
-        channelId: recorder.channelId,
-        remarks: recorder.remarks ?? "",
         year: formatDate(now, "yyyy"),
         month: formatDate(now, "MM"),
         date: formatDate(now, "dd"),
@@ -319,20 +325,19 @@ export function genSavePathFromRule(manager, recorder, extData) {
         min: formatDate(now, "mm"),
         sec: formatDate(now, "ss"),
         ...extData,
+        startTime: now,
         owner: owner,
         title: title,
+        remarks: remarks,
+        channelId,
     };
-    if (manager.autoRemoveSystemReservedChars) {
-        for (const key in params) {
-            params[key] = removeSystemReservedChars(String(params[key])).trim();
-        }
-    }
     let savePathRule = manager.savePathRule;
     try {
         savePathRule = ejs.render(savePathRule, params);
+        console.log("解析后保存路径模板：", savePathRule, params);
     }
     catch (error) {
-        console.error("模板解析错误", error);
+        console.error("模板解析错误", error, savePathRule, params);
     }
     return formatTemplate(savePathRule, params);
 }

package/lib/recorder/BililiveRecorder.d.ts

@@ -0,0 +1,50 @@
+import EventEmitter from "node:events";
+import { IRecorder, BililiveRecorderOptions } from "./IRecorder.js";
+declare class BililiveRecorderCommand extends EventEmitter {
+    private _input;
+    private _output;
+    private _inputOptions;
+    private process;
+    constructor();
+    input(source: string): BililiveRecorderCommand;
+    output(target: string): BililiveRecorderCommand;
+    inputOptions(options: string[]): BililiveRecorderCommand;
+    inputOptions(...options: string[]): BililiveRecorderCommand;
+    _getArguments(): string[];
+    run(): void;
+    kill(signal?: NodeJS.Signals): void;
+}
+export declare const createBililiveBuilder: () => BililiveRecorderCommand;
+export declare class BililiveRecorder extends EventEmitter implements IRecorder {
+    private onEnd;
+    private onUpdateLiveInfo;
+    type: "bililive";
+    private command;
+    private streamManager;
+    readonly hasSegment: boolean;
+    readonly getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    readonly segment: number;
+    readonly inputOptions: string[];
+    readonly disableDanma: boolean;
+    readonly url: string;
+    readonly debugLevel: "none" | "basic" | "verbose";
+    readonly headers: {
+        [key: string]: string | undefined;
+    } | undefined;
+    constructor(opts: BililiveRecorderOptions, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+        title?: string;
+        cover?: string;
+    }>);
+    createCommand(): BililiveRecorderCommand;
+    formatLine(line: string): {
+        time: string | null;
+    } | null;
+    run(): void;
+    getArguments(): string[];
+    stop(): Promise<void>;
+    getExtraDataController(): import("../xml_stream_controller.js").XmlStreamController | null;
+}
+export {};

package/lib/recorder/BililiveRecorder.js

@@ -0,0 +1,195 @@
+import EventEmitter from "node:events";
+import { spawn } from "node:child_process";
+import { StreamManager, getBililivePath } from "../index.js";
+// Bililive command builder class similar to ffmpeg
+class BililiveRecorderCommand 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 = ["downloader", "-p"];
+        // Add input source
+        if (this._input) {
+            args.push(this._input);
+        }
+        // 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(this._output);
+        }
+        // args.push("-v");
+        return args;
+    }
+    run() {
+        const args = this._getArguments();
+        const bililiveExecutable = getBililivePath();
+        this.process = spawn(bililiveExecutable, 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(`bililive process exited with code ${code}`));
+            }
+        });
+    }
+    kill(signal = "SIGTERM") {
+        if (this.process) {
+            this.process.kill(signal);
+        }
+    }
+}
+// Factory function similar to createFFMPEGBuilder
+export const createBililiveBuilder = () => {
+    return new BililiveRecorderCommand();
+};
+export class BililiveRecorder extends EventEmitter {
+    onEnd;
+    onUpdateLiveInfo;
+    type = "bililive";
+    command;
+    streamManager;
+    hasSegment;
+    getSavePath;
+    segment;
+    inputOptions = [];
+    disableDanma = false;
+    url;
+    debugLevel = "none";
+    headers;
+    constructor(opts, onEnd, onUpdateLiveInfo) {
+        super();
+        this.onEnd = onEnd;
+        this.onUpdateLiveInfo = onUpdateLiveInfo;
+        const hasSegment = true;
+        this.disableDanma = opts.disableDanma ?? false;
+        this.debugLevel = opts.debugLevel ?? "none";
+        let videoFormat = "flv";
+        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, "bililive", videoFormat, {
+            onUpdateLiveInfo: this.onUpdateLiveInfo,
+        });
+        this.hasSegment = hasSegment;
+        this.getSavePath = opts.getSavePath;
+        this.inputOptions = [];
+        this.url = opts.url;
+        this.segment = opts.segment;
+        this.headers = opts.headers;
+        this.command = this.createCommand();
+        this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename, title }) => {
+            this.emit("videoFileCreated", { filename, cover, rawFilename, title });
+        });
+        this.streamManager.on("videoFileCompleted", ({ filename }) => {
+            this.emit("videoFileCompleted", { filename });
+        });
+        this.streamManager.on("DebugLog", (data) => {
+            this.emit("DebugLog", data);
+        });
+    }
+    createCommand() {
+        const inputOptions = [
+            ...this.inputOptions,
+            "-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.debugLevel === "verbose") {
+            inputOptions.push("-l", "Debug");
+        }
+        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}`);
+        }
+        const command = createBililiveBuilder()
+            .input(this.url)
+            .inputOptions(inputOptions)
+            .output(this.streamManager.videoFilePath)
+            .on("error", this.onEnd)
+            .on("end", () => this.onEnd("finished"))
+            .on("stderr", async (stderrLine) => {
+            this.emit("DebugLog", { type: "ffmpeg", text: stderrLine });
+            await this.streamManager.handleVideoStarted(stderrLine);
+            const info = this.formatLine(stderrLine);
+            if (info) {
+                this.emit("progress", info);
+            }
+        });
+        return command;
+    }
+    formatLine(line) {
+        if (!line.includes("下载进度:")) {
+            return null;
+        }
+        let time = null;
+        const timeMatch = line.match(/录制时长:\s*([0-9:]+)\s/);
+        if (timeMatch) {
+            time = timeMatch[1];
+        }
+        return {
+            time,
+        };
+    }
+    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/recorder/FFMPEGRecorder.d.ts

@@ -1,8 +1,11 @@
 import EventEmitter from "node:events";
 import { IRecorder, FFMPEGRecorderOptions } from "./IRecorder.js";
+import { FormatName } from "./index.js";
+import type { VideoFormat } from "../index.js";
 export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
     private onEnd;
     private onUpdateLiveInfo;
+    type: "ffmpeg";
     private command;
     private streamManager;
     private timeoutChecker;
@@ -17,8 +20,9 @@ export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
     readonly isHls: boolean;
     readonly disableDanma: boolean;
     readonly url: string;
-    formatName: "flv" | "ts" | "fmp4";
-    videoFormat: "ts" | "mkv" | "mp4";
+    formatName: FormatName;
+    videoFormat: VideoFormat;
+    readonly debugLevel: "none" | "basic" | "verbose";
     readonly headers: {
         [key: string]: string | undefined;
     } | undefined;
@@ -27,6 +31,7 @@ export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
         cover?: string;
     }>);
     createCommand(): import("@renmu/fluent-ffmpeg").FfmpegCommand;
+    buildOutputOptions(): string[];
     formatLine(line: string): {
         time: string | null;
     } | null;

package/lib/recorder/FFMPEGRecorder.js

@@ -4,6 +4,7 @@ import { createInvalidStreamChecker, assert } from "../utils.js";
 export class FFMPEGRecorder extends EventEmitter {
     onEnd;
     onUpdateLiveInfo;
+    type = "ffmpeg";
     command;
     streamManager;
     timeoutChecker;
@@ -17,6 +18,7 @@ export class FFMPEGRecorder extends EventEmitter {
     url;
     formatName;
     videoFormat;
+    debugLevel = "none";
     headers;
     constructor(opts, onEnd, onUpdateLiveInfo) {
         super();
@@ -24,11 +26,8 @@ export class FFMPEGRecorder extends EventEmitter {
         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;
+        this.debugLevel = opts.debugLevel ?? "none";
+        this.formatName = opts.formatName;
         if (this.formatName === "fmp4" || this.formatName === "ts") {
             this.isHls = true;
         }
@@ -38,7 +37,7 @@ export class FFMPEGRecorder extends EventEmitter {
         let videoFormat = opts.videoFormat ?? "auto";
         if (videoFormat === "auto") {
             if (!this.hasSegment) {
-                videoFormat = "mp4";
+                videoFormat = "m4s";
                 if (this.formatName === "ts") {
                     videoFormat = "ts";
                 }
@@ -60,8 +59,8 @@ export class FFMPEGRecorder extends EventEmitter {
         this.segment = opts.segment;
         this.headers = opts.headers;
         this.command = this.createCommand();
-        this.streamManager.on("videoFileCreated", ({ filename, cover }) => {
-            this.emit("videoFileCreated", { filename, cover });
+        this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename, title }) => {
+            this.emit("videoFileCreated", { filename, cover, rawFilename, title });
         });
         this.streamManager.on("videoFileCompleted", ({ filename }) => {
             this.emit("videoFileCompleted", { filename });
@@ -79,6 +78,12 @@ export class FFMPEGRecorder extends EventEmitter {
             "-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.isHls) {
+            inputOptions.push(...["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "3"]);
+        }
+        if (this.debugLevel === "verbose") {
+            inputOptions.push("-loglevel", "debug");
+        }
         if (this.headers) {
             const headers = [];
             Object.entries(this.headers).forEach(([key, value]) => {
@@ -90,10 +95,11 @@ export class FFMPEGRecorder extends EventEmitter {
                 inputOptions.push("-headers", headers.join("\\r\\n"));
             }
         }
+        const outputOptions = this.buildOutputOptions();
         const command = createFFMPEGBuilder()
             .input(this.url)
             .inputOptions(inputOptions)
-            .outputOptions(this.ffmpegOutputOptions)
+            .outputOptions(outputOptions)
             .output(this.streamManager.videoFilePath)
             .on("error", this.onEnd)
             .on("end", () => this.onEnd("finished"))
@@ -111,10 +117,24 @@ export class FFMPEGRecorder extends EventEmitter {
             }
         })
             .on("stderr", this.timeoutChecker?.update);
+        return command;
+    }
+    buildOutputOptions() {
+        const options = [];
+        options.push(...this.ffmpegOutputOptions);
+        options.push("-c", "copy", "-movflags", "+frag_keyframe+empty_moov+separate_moof", "-fflags", "+genpts+igndts", "-min_frag_duration", "10000000");
         if (this.hasSegment) {
-            command.outputOptions("-f", "segment", "-segment_time", String(this.segment * 60), "-reset_timestamps", "1");
+            options.push("-f", "segment", "-segment_time", String(this.segment * 60), "-reset_timestamps", "1");
+            if (this.videoFormat === "m4s") {
+                options.push("-segment_format", "mp4");
+            }
         }
-        return command;
+        else {
+            if (this.videoFormat === "m4s") {
+                options.push("-f", "mp4");
+            }
+        }
+        return options;
     }
     formatLine(line) {
         if (!line.includes("time=")) {