@bililive-tools/douyin-recorder 1.0.0

package/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

package/README.md

@@ -0,0 +1,73 @@
+# Intro
+
+原项目：https://github.com/WhiteMinds/DouYinRecorder
+
+这是 [biliLive-tools](https://github.com/renmu123/biliLive-tools) 的一个平台插件，为其支持了抖音平台录制
+
+# 安装
+
+`npm i @bililive-tools/douyin-recorder @bililive-tools/manager`
+
+# 使用
+
+```ts
+import { createRecorderManager } from "@bililive-tools/manager";
+import { provider } from "@bililive-tools/douyin-recorder";
+
+const manager = createRecorderManager({ providers: [provider] });
+manager.addRecorder({
+  providerId: provider.id,
+  channelId: "203641303310",
+  quality: "origin",
+  streamPriorities: [],
+  sourcePriorities: [],
+});
+
+// 录制前请设置好ffmepg的环境变量，或手动指定，具体见`@bililive-tools/manager`文档
+manager.startCheckLoop();
+```
+
+## 参数
+
+```ts
+interface Options {
+  channelId: string; // 直播间ID，具体解析见文档，也可自行解析
+  quality: string; // 见画质参数
+  qualityRetry?: number; // 画质匹配重试次数, -1为强制匹配画质，0为自动配置，正整数为最大匹配次数
+  streamPriorities: []; // 废弃
+  sourcePriorities: []; // 废弃
+  disableAutoCheck?: boolean; // 为 true 时 manager 将跳过自动检查
+  segment?: number; // 分段参数，单位分钟
+  disableProvideCommentsWhenRecording?: boolean; // 禁用弹幕录制
+  saveGiftDanma?: boolean; // 保存礼物弹幕
+  saveCover?: boolean; // 保存封面
+}
+```
+
+## 画质
+
+遗漏了部分画质，有了解的可以提PR
+
+| 画质   | 值     |
+| ------ | ------ |
+| 原画   | origin |
+| 蓝光   | uhd    |
+| 超清   | hd     |
+| 高清   | sd     |
+| 标清   | ld     |
+| 音频流 | ao     |
+
+## 直播间ID解析
+
+解析出真实直播间ID
+
+```ts
+import { provider } from "@bililive-tools/douyin-recorder";
+
+const url = "https://live.douyin.com/203641303310";
+const { id } = await provider.resolveChannelInfoFromURL(url);
+```
+
+# 协议
+
+与原项目保存一致为 LGPL

package/lib/douyin_api.d.ts

@@ -0,0 +1,37 @@
+export declare const getCookie: () => Promise<string>;
+export declare function getRoomInfo(webRoomId: string, retryOnSpecialCode?: boolean): Promise<{
+    living: boolean;
+    roomId: string;
+    owner: string;
+    title: string;
+    streams: StreamProfile[];
+    sources: SourceProfile[];
+    avatar: string;
+    cover: string;
+    liveId: string;
+}>;
+export interface StreamProfile {
+    desc: string;
+    key: string;
+    bitRate: number;
+}
+export interface SourceProfile {
+    name: string;
+    streamMap: StreamData["data"];
+}
+interface StreamData {
+    common: unknown;
+    data: Record<string, {
+        main: {
+            flv: string;
+            hls: string;
+            cmaf: string;
+            dash: string;
+            lls: string;
+            tsl: string;
+            tile: string;
+            sdk_params: string;
+        };
+    }>;
+}
+export {};

package/lib/douyin_api.js

@@ -0,0 +1,114 @@
+import axios from "axios";
+import { assert } from "./utils.js";
+const requester = axios.create({
+    timeout: 10e3,
+    // axios 会自动读取环境变量中的 http_proxy 和 https_proxy 并应用，这会让请求发往代理的 host。
+    // 所以这里需要主动禁用代理功能。
+    proxy: false,
+});
+let cookieCache;
+export const getCookie = async () => {
+    const now = new Date().getTime();
+    // 缓存24小时
+    if (cookieCache?.startTimestamp && now - cookieCache.startTimestamp < 24 * 60 * 60 * 1000) {
+        return cookieCache.cookies;
+    }
+    const res = await requester.get("https://live.douyin.com/");
+    if (!res.headers["set-cookie"]) {
+        throw new Error("No cookie in response");
+    }
+    const cookies = (res.headers["set-cookie"] ?? [])
+        .map((cookie) => {
+        return cookie.split(";")[0];
+    })
+        .join("; ");
+    cookieCache = {
+        startTimestamp: now,
+        cookies,
+    };
+    return cookies;
+};
+export async function getRoomInfo(webRoomId, retryOnSpecialCode = true) {
+    // 抖音的 'webcast/room/web/enter' api 会需要 ttwid 的 cookie，这个 cookie 是由这个请求的响应头设置的，
+    // 所以在这里请求一次自动设置。
+    const cookies = await getCookie();
+    const res = await requester.get("https://live.douyin.com/webcast/room/web/enter/", {
+        params: {
+            aid: 6383,
+            live_id: 1,
+            device_platform: "web",
+            language: "zh-CN",
+            enter_from: "web_live",
+            cookie_enabled: "true",
+            screen_width: 1920,
+            screen_height: 1080,
+            browser_language: "zh-CN",
+            browser_platform: "MacIntel",
+            browser_name: "Chrome",
+            browser_version: "108.0.0.0",
+            web_rid: webRoomId,
+            // enter_source:,
+            "Room-Enter-User-Login-Ab": 0,
+            is_need_double_stream: "false",
+        },
+        headers: {
+            cookie: cookies,
+        },
+    });
+    // console.log(JSON.stringify(res.data, null, 2));
+    // 无 cookie 时 code 为 10037
+    if (res.data.status_code === 10037 && retryOnSpecialCode) {
+        // resp 自动设置 cookie
+        // const cookieRes = await requester.get("https://live.douyin.com/favicon.ico");
+        // const cookies = cookieRes.headers["set-cookie"]
+        //   .map((cookie) => {
+        //     return cookie.split(";")[0];
+        //   })
+        //   .join("; ");
+        // console.log("cookies", cookies);
+        return getRoomInfo(webRoomId, false);
+    }
+    assert(res.data.status_code === 0, `Unexpected resp, code ${res.data.status_code}, msg ${res.data.data}, id ${webRoomId}`);
+    const data = res.data.data;
+    const room = data.data[0];
+    assert(room, `No room data, id ${webRoomId}`);
+    if (room?.stream_url == null) {
+        return {
+            living: false,
+            roomId: webRoomId,
+            owner: data.user.nickname,
+            title: room?.title ?? data.user.nickname,
+            streams: [],
+            sources: [],
+            avatar: data.user?.avatar_thumb?.url_list?.[0],
+            cover: room.cover?.url_list?.[0],
+            liveId: room.id_str,
+        };
+    }
+    const { options: { qualities }, stream_data, } = room.stream_url.live_core_sdk_data.pull_data;
+    const streamData = JSON.parse(stream_data).data;
+    const streams = qualities.map((info) => ({
+        desc: info.name,
+        key: info.sdk_key,
+        bitRate: info.v_bit_rate,
+    }));
+    // 看起来抖音是自动切换 cdn 的，所以这里固定返回一个默认的 source。
+    const sources = [
+        {
+            name: "自动",
+            streamMap: streamData,
+        },
+    ];
+    return {
+        living: data.room_status === 0,
+        // 接口里不会再返回 web room id，只能直接用入参原路返回了。
+        roomId: webRoomId,
+        owner: data.user.nickname,
+        title: room.title,
+        streams,
+        sources,
+        avatar: data.user.avatar_thumb.url_list[0],
+        cover: room.cover?.url_list?.[0],
+        liveId: room.id_str,
+    };
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+import type { RecorderProvider } from "@bililive-tools/manager";
+export declare const provider: RecorderProvider<{}>;

package/lib/index.js

@@ -0,0 +1,296 @@
+import path from "node:path";
+import mitt from "mitt";
+import { defaultFromJSON, defaultToJSON, genRecorderUUID, genRecordUUID, FFMPEGRecorder, } from "@bililive-tools/manager";
+import { getInfo, getStream } from "./stream.js";
+import { ensureFolderExist, singleton } from "./utils.js";
+import DouYinDanmaClient from "douyin-danma-listener";
+function createRecorder(opts) {
+    // 内部实现时，应该只有 proxy 包裹的那一层会使用这个 recorder 标识符，不应该有直接通过
+    // 此标志来操作这个对象的地方，不然会跳过 proxy 的拦截。
+    const recorder = {
+        id: opts.id ?? genRecorderUUID(),
+        extra: opts.extra ?? {},
+        // @ts-ignore
+        ...mitt(),
+        ...opts,
+        availableStreams: [],
+        availableSources: [],
+        qualityMaxRetry: opts.qualityRetry ?? 0,
+        qualityRetry: opts.qualityRetry ?? 0,
+        state: "idle",
+        getChannelURL() {
+            return `https://live.douyin.com/${this.channelId}`;
+        },
+        checkLiveStatusAndRecord: singleton(checkLiveStatusAndRecord),
+        toJSON() {
+            return defaultToJSON(provider, this);
+        },
+        async getLiveInfo() {
+            const channelId = this.channelId;
+            const info = await getInfo(channelId);
+            return {
+                channelId,
+                ...info,
+            };
+        },
+        async getStream() {
+            const res = await getStream({
+                channelId: this.channelId,
+                quality: this.quality,
+                streamPriorities: this.streamPriorities,
+                sourcePriorities: this.sourcePriorities,
+            });
+            return res.currentStream;
+        },
+    };
+    const recorderWithSupportUpdatedEvent = new Proxy(recorder, {
+        set(obj, prop, value) {
+            Reflect.set(obj, prop, value);
+            if (typeof prop === "string") {
+                obj.emit("Updated", [prop]);
+            }
+            return true;
+        },
+    });
+    return recorderWithSupportUpdatedEvent;
+}
+const ffmpegOutputOptions = [
+    "-c",
+    "copy",
+    "-movflags",
+    "faststart+frag_keyframe+empty_moov",
+    "-min_frag_duration",
+    "60000000",
+];
+const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isManualStart, }) {
+    if (this.recordHandle != null)
+        return this.recordHandle;
+    const liveInfo = await getInfo(this.channelId);
+    const { living, owner, title, liveId } = liveInfo;
+    this.liveInfo = liveInfo;
+    this.emit("LiveStart", { liveId });
+    if (liveInfo.liveId === banLiveId) {
+        this.tempStopIntervalCheck = true;
+    }
+    else {
+        this.tempStopIntervalCheck = false;
+    }
+    if (this.tempStopIntervalCheck)
+        return null;
+    if (!living)
+        return null;
+    let res;
+    try {
+        let strictQuality = false;
+        if (this.qualityRetry > 0) {
+            strictQuality = true;
+        }
+        if (this.qualityMaxRetry < 0) {
+            strictQuality = true;
+        }
+        if (isManualStart) {
+            strictQuality = false;
+        }
+        res = await getStream({
+            channelId: this.channelId,
+            quality: this.quality,
+            streamPriorities: this.streamPriorities,
+            sourcePriorities: this.sourcePriorities,
+            strictQuality: strictQuality,
+        });
+    }
+    catch (err) {
+        this.state = "idle";
+        throw err;
+    }
+    this.state = "recording";
+    const { currentStream: stream, sources: availableSources, streams: availableStreams } = res;
+    this.availableStreams = availableStreams.map((s) => s.desc);
+    this.availableSources = availableSources.map((s) => s.name);
+    this.usedStream = stream.name;
+    this.usedSource = stream.source;
+    // TODO: emit update event
+    let isEnded = false;
+    const onEnd = (...args) => {
+        if (isEnded)
+            return;
+        isEnded = true;
+        this.emit("DebugLog", {
+            type: "common",
+            text: `ffmpeg end, reason: ${JSON.stringify(args, (_, v) => (v instanceof Error ? v.stack : v))}`,
+        });
+        const reason = args[0] instanceof Error ? args[0].message : String(args[0]);
+        this.recordHandle?.stop(reason);
+    };
+    const recorder = new FFMPEGRecorder({
+        url: stream.url,
+        outputOptions: ffmpegOutputOptions,
+        segment: this.segment ?? 0,
+        getSavePath: (opts) => getSavePath({ owner, title, startTime: opts.startTime }),
+        disableDanma: this.disableProvideCommentsWhenRecording,
+    }, onEnd);
+    const savePath = getSavePath({
+        owner,
+        title,
+    });
+    try {
+        ensureFolderExist(savePath);
+    }
+    catch (err) {
+        this.state = "idle";
+        throw err;
+    }
+    const handleVideoCreated = async ({ filename }) => {
+        this.emit("videoFileCreated", { filename });
+        const extraDataController = recorder.getExtraDataController();
+        extraDataController?.setMeta({
+            room_id: this.channelId,
+            platform: provider?.id,
+            // liveStartTimestamp: liveInfo.startTime?.getTime(),
+            recordStopTimestamp: Date.now(),
+            title: title,
+            user_name: owner,
+        });
+    };
+    recorder.on("videoFileCreated", handleVideoCreated);
+    recorder.on("videoFileCompleted", ({ filename }) => {
+        this.emit("videoFileCompleted", { filename });
+    });
+    recorder.on("DebugLog", (data) => {
+        this.emit("DebugLog", data);
+    });
+    recorder.on("progress", (progress) => {
+        if (this.recordHandle) {
+            this.recordHandle.progress = progress;
+        }
+        this.emit("progress", progress);
+    });
+    const client = new DouYinDanmaClient(liveInfo.liveId);
+    client.on("chat", (msg) => {
+        const extraDataController = recorder.getExtraDataController();
+        if (!extraDataController)
+            return;
+        const comment = {
+            type: "comment",
+            timestamp: Date.now(),
+            text: msg.content,
+            color: "#ffffff",
+            sender: {
+                uid: msg.user.id,
+                name: msg.user.nickName,
+                // avatar: msg.user.AvatarThumb.urlListList[0],
+                // extra: {
+                //   level: msg.level,
+                // },
+            },
+        };
+        // console.log("comment", comment);
+        this.emit("Message", comment);
+        extraDataController.addMessage(comment);
+    });
+    client.on("gift", (msg) => {
+        const extraDataController = recorder.getExtraDataController();
+        if (!extraDataController)
+            return;
+        if (this.saveGiftDanma === false)
+            return;
+        // console.log("gift", msg);
+        const gift = {
+            type: "give_gift",
+            timestamp: new Date(msg.sendTime).getTime(),
+            name: msg.gift.name,
+            price: 1,
+            count: Number(msg.totalCount),
+            color: "#ffffff",
+            sender: {
+                uid: msg.user.id,
+                name: msg.user.nickName,
+                // avatar: msg.ic,
+                // extra: {
+                //   level: msg.level,
+                // },
+            },
+        };
+        // console.log("gift", gift);
+        this.emit("Message", gift);
+        extraDataController.addMessage(gift);
+    });
+    // client.on("open", () => {
+    //   console.log("open");
+    // });
+    // client.on("close", () => {
+    //   console.log("close");
+    // });
+    // client.on("error", (err) => {
+    //   console.log("error", err);
+    // });
+    // client.on("heartbeat", () => {
+    //   // console.log("heartbeat");
+    // });
+    if (!this.disableProvideCommentsWhenRecording) {
+        client.connect();
+    }
+    const ffmpegArgs = recorder.getArguments();
+    recorder.run();
+    const stop = singleton(async (reason) => {
+        if (!this.recordHandle)
+            return;
+        this.state = "stopping-record";
+        client.close();
+        try {
+            await recorder.stop();
+        }
+        catch (err) {
+            this.emit("DebugLog", {
+                type: "common",
+                text: `stop ffmpeg error: ${String(err)}`,
+            });
+        }
+        this.usedStream = undefined;
+        this.usedSource = undefined;
+        this.emit("RecordStop", { recordHandle: this.recordHandle, reason });
+        this.recordHandle = undefined;
+        this.liveInfo = undefined;
+        this.state = "idle";
+    });
+    this.recordHandle = {
+        id: genRecordUUID(),
+        stream: stream.name,
+        source: stream.source,
+        url: stream.url,
+        ffmpegArgs,
+        savePath: savePath,
+        stop,
+    };
+    this.emit("RecordStart", this.recordHandle);
+    return this.recordHandle;
+};
+export const provider = {
+    id: "DouYin",
+    name: "抖音",
+    siteURL: "https://live.douyin.com/",
+    matchURL(channelURL) {
+        // TODO: 暂时不支持 v.douyin.com
+        return /https?:\/\/live\.douyin\.com\//.test(channelURL);
+    },
+    async resolveChannelInfoFromURL(channelURL) {
+        if (!this.matchURL(channelURL))
+            return null;
+        const id = path.basename(new URL(channelURL).pathname);
+        const info = await getInfo(id);
+        return {
+            id: info.roomId,
+            title: info.title,
+            owner: info.owner,
+        };
+    },
+    createRecorder(opts) {
+        return createRecorder({ providerId: provider.id, ...opts });
+    },
+    fromJSON(recorder) {
+        return defaultFromJSON(this, recorder);
+    },
+    setFFMPEGOutputArgs(args) {
+        ffmpegOutputOptions.splice(0, ffmpegOutputOptions.length, ...args);
+    },
+};

package/lib/stream.d.ts

@@ -0,0 +1,30 @@
+import type { Recorder } from "@bililive-tools/manager";
+export declare function getInfo(channelId: string): Promise<{
+    living: boolean;
+    owner: string;
+    title: string;
+    roomId: string;
+    avatar: string;
+    cover: string;
+    startTime: Date;
+    liveId: string;
+}>;
+export declare function getStream(opts: Pick<Recorder, "channelId" | "quality" | "streamPriorities" | "sourcePriorities"> & {
+    rejectCache?: boolean;
+    strictQuality?: boolean;
+}): Promise<{
+    currentStream: {
+        name: string;
+        source: string;
+        url: string;
+    };
+    living: boolean;
+    roomId: string;
+    owner: string;
+    title: string;
+    streams: import("./douyin_api.js").StreamProfile[];
+    sources: import("./douyin_api.js").SourceProfile[];
+    avatar: string;
+    cover: string;
+    liveId: string;
+}>;

package/lib/stream.js

@@ -0,0 +1,69 @@
+import { getRoomInfo } from "./douyin_api.js";
+export async function getInfo(channelId) {
+    const info = await getRoomInfo(channelId);
+    return {
+        living: info.living,
+        owner: info.owner,
+        title: info.title,
+        roomId: info.roomId,
+        avatar: info.avatar,
+        cover: info.cover,
+        startTime: new Date(),
+        liveId: info.liveId,
+    };
+}
+export async function getStream(opts) {
+    const info = await getRoomInfo(opts.channelId);
+    if (!info.living) {
+        throw new Error("It must be called getStream when living");
+    }
+    const qualityMap = [
+        {
+            key: "origin",
+            desc: "原画",
+        },
+        {
+            key: "uhd",
+            desc: "蓝光",
+        },
+        {
+            key: "hd",
+            desc: "超清",
+        },
+        {
+            key: "sd",
+            desc: "高清",
+        },
+        {
+            key: "标清",
+            desc: "ld",
+        },
+    ];
+    const sources = info.sources[0];
+    let url = sources.streamMap[opts.quality]?.main?.flv;
+    let qualityName = qualityMap.find((q) => q.key === opts.quality)?.desc ?? "未知";
+    if (!url && opts.strictQuality) {
+        throw new Error("Can not get expect quality because of strictQuality");
+    }
+    // 如果url不存在，那么按照优先级选择
+    if (!url) {
+        for (const quality of qualityMap) {
+            url = sources.streamMap[quality.key]?.main?.flv;
+            if (url) {
+                qualityName = quality.desc;
+                break;
+            }
+        }
+    }
+    if (!url) {
+        throw new Error("未找到对应的流");
+    }
+    return {
+        ...info,
+        currentStream: {
+            name: qualityName,
+            source: "自动",
+            url: url,
+        },
+    };
+}

package/lib/test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test.js

@@ -0,0 +1,13 @@
+// execute in shell `ts-node src/test.ts` to run test
+// TODO: add to scripts
+import { createRecorderManager } from "@bililive-tools/manager";
+import { provider } from "./index.js";
+const manager = createRecorderManager({ providers: [provider] });
+manager.addRecorder({
+    providerId: provider.id,
+    channelId: "317590520822",
+    quality: "medium",
+    streamPriorities: [],
+    sourcePriorities: [],
+});
+manager.startCheckLoop();

package/lib/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 接收 fn ，返回一个和 fn 签名一致的函数 fn'。当已经有一个 fn' 在运行时，再调用
+ * fn' 会直接返回运行中 fn' 的 Promise，直到 Promise 结束 pending 状态
+ */
+export declare function singleton<Fn extends (...args: any) => Promise<any>>(fn: Fn): Fn;
+export declare function ensureFolderExist(fileOrFolderPath: string): void;
+export declare function assert(assertion: unknown, msg?: string): asserts assertion;
+export declare function assertStringType(data: unknown, msg?: string): asserts data is string;
+export declare function assertNumberType(data: unknown, msg?: string): asserts data is number;
+export declare function assertObjectType(data: unknown, msg?: string): asserts data is object;
+export declare function replaceExtName(filePath: string, newExtName: string): string;

package/lib/utils.js

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * 接收 fn ，返回一个和 fn 签名一致的函数 fn'。当已经有一个 fn' 在运行时，再调用
+ * fn' 会直接返回运行中 fn' 的 Promise，直到 Promise 结束 pending 状态
+ */
+export function singleton(fn) {
+    let latestPromise = null;
+    return function (...args) {
+        if (latestPromise)
+            return latestPromise;
+        // @ts-ignore
+        const promise = fn.apply(this, args).finally(() => {
+            if (promise === latestPromise) {
+                latestPromise = null;
+            }
+        });
+        latestPromise = promise;
+        return promise;
+    };
+}
+export function ensureFolderExist(fileOrFolderPath) {
+    const folder = path.dirname(fileOrFolderPath);
+    if (!fs.existsSync(folder)) {
+        fs.mkdirSync(folder, { recursive: true });
+    }
+}
+export function assert(assertion, msg) {
+    if (!assertion) {
+        throw new Error(msg);
+    }
+}
+export function assertStringType(data, msg) {
+    assert(typeof data === "string", msg);
+}
+export function assertNumberType(data, msg) {
+    assert(typeof data === "number", msg);
+}
+export function assertObjectType(data, msg) {
+    assert(typeof data === "object", msg);
+}
+export function replaceExtName(filePath, newExtName) {
+    return path.join(path.dirname(filePath), path.basename(filePath, path.extname(filePath)) + newExtName);
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@bililive-tools/douyin-recorder",
+  "version": "1.0.0",
+  "description": "@bililive-tools douyin recorder implemention",
+  "main": "./lib/index.js",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "development": "./src/index.ts",
+      "default": "./lib/index.js"
+    },
+    "./*.js": {
+      "types": "./src/*.ts",
+      "development": "./src/*.ts",
+      "default": "./lib/*.js"
+    }
+  },
+  "files": [
+    "lib"
+  ],
+  "keywords": [
+    "douyin",
+    "recorder",
+    "bililive-tools",
+    "直播",
+    "录制",
+    "抖音"
+  ],
+  "repository": "https://github.com/renmu123/biliLive-tools/tree/master/packages/DouYinRecorder",
+  "author": "WhiteMind",
+  "license": "LGPL",
+  "dependencies": {
+    "axios": "^1.7.8",
+    "lodash-es": "^4.17.21",
+    "mitt": "^3.0.1",
+    "@bililive-tools/manager": "^1.1.0",
+    "douyin-danma-listener": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "*"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "gen:proto": "pbjs -t static-module -w es6 -o src/danma/proto.js src/danma/dy.proto"
+  }
+}