@bililive-tools/douyin-recorder 1.2.0 → 1.4.0

package/README.md

@@ -36,12 +36,15 @@ interface Options {
   qualityRetry?: number; // 画质匹配重试次数, -1为强制匹配画质，0为自动配置，正整数为最大匹配次数
   streamPriorities: []; // 废弃
   sourcePriorities: []; // 废弃
+  formatPriorities?: string[]; // 支持，`flv`和`hls` 参数，默认为['flv','hls']
   disableAutoCheck?: boolean; // 为 true 时 manager 将跳过自动检查
   segment?: number; // 分段参数，单位分钟
   disableProvideCommentsWhenRecording?: boolean; // 禁用弹幕录制
   saveGiftDanma?: boolean; // 保存礼物弹幕
   saveCover?: boolean; // 保存封面
   videoFormat?: "auto"; // 视频格式： "auto", "ts", "mkv" ，auto模式下, 分段使用 "ts"，不分段使用 "mp4"
+  doubleScreen?: boolean; // 是否使用双屏直播流，开启后如果是双屏直播，那么就使用拼接的流，默认为true
+  auth?: string; // 传递cookie，用于录制会员视频
 }
 ```
 
@@ -49,14 +52,15 @@ interface Options {
 
 遗漏了部分画质，有了解的可以提PR
 
-| 画质   | 值     |
-| ------ | ------ |
-| 原画   | origin |
-| 蓝光   | uhd    |
-| 超清   | hd     |
-| 高清   | sd     |
-| 标清   | ld     |
-| 音频流 | ao     |
+| 画质                   | 值          |
+| ---------------------- | ----------- |
+| 原画                   | origin      |
+| 蓝光                   | uhd         |
+| 超清                   | hd          |
+| 高清                   | sd          |
+| 标清                   | ld          |
+| 音频流                 | ao          |
+| 真原画(音频流中获取的) | real_origin |
 
 ## 直播间ID解析
 
@@ -66,6 +70,7 @@ interface Options {
 import { provider } from "@bililive-tools/douyin-recorder";
 
 const url = "https://live.douyin.com/203641303310";
+// 同样支持解析 https://v.douyin.com/DpfoBLAXoHM/
 const { id } = await provider.resolveChannelInfoFromURL(url);
 ```
 

package/lib/douyin_api.d.ts

@@ -1,5 +1,15 @@
+/**
+ * 从抖音短链接解析得到直播间ID
+ * @param shortURL 短链接，如 https://v.douyin.com/DpfoBLAXoHM/
+ * @returns webRoomId 直播间ID
+ */
+export declare function resolveShortURL(shortURL: string): Promise<string>;
 export declare const getCookie: () => Promise<string>;
-export declare function getRoomInfo(webRoomId: string, retryOnSpecialCode?: boolean): Promise<{
+export declare function getRoomInfo(webRoomId: string, opts?: {
+    retryOnSpecialCode?: boolean;
+    auth?: string;
+    doubleScreen?: boolean;
+}): Promise<{
     living: boolean;
     roomId: string;
     owner: string;
@@ -15,9 +25,16 @@ export interface StreamProfile {
     key: string;
     bitRate: number;
 }
+export interface StreamInfo {
+    quality: string;
+    name: string;
+    flv?: string;
+    hls?: string;
+}
 export interface SourceProfile {
     name: string;
     streamMap: StreamData["data"];
+    streams: StreamInfo[];
 }
 interface StreamData {
     common: unknown;

package/lib/douyin_api.js

@@ -1,16 +1,65 @@
 import axios from "axios";
+import { isEmpty } from "lodash-es";
 import { assert } from "./utils.js";
 const requester = axios.create({
     timeout: 10e3,
     // axios 会自动读取环境变量中的 http_proxy 和 https_proxy 并应用，这会让请求发往代理的 host。
     // 所以这里需要主动禁用代理功能。
     proxy: false,
+    headers: {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+    },
 });
+/**
+ * 从抖音短链接解析得到直播间ID
+ * @param shortURL 短链接，如 https://v.douyin.com/DpfoBLAXoHM/
+ * @returns webRoomId 直播间ID
+ */
+export async function resolveShortURL(shortURL) {
+    // 获取跳转后的页面内容
+    const response = await requester.get(shortURL);
+    // 尝试从页面内容中提取webRid
+    const webRidMatch = response.data.match(/"webRid\\":\\"(\d+)\\"/);
+    if (webRidMatch) {
+        return webRidMatch[1];
+    }
+    throw new Error("无法从短链接解析出直播间ID");
+}
+const qualityList = [
+    {
+        key: "origin",
+        desc: "原画",
+    },
+    {
+        key: "uhd",
+        desc: "蓝光",
+    },
+    {
+        key: "hd",
+        desc: "超清",
+    },
+    {
+        key: "sd",
+        desc: "高清",
+    },
+    {
+        key: "ld",
+        desc: "标清",
+    },
+    {
+        key: "ao",
+        desc: "音频流",
+    },
+    {
+        key: "real_origin",
+        desc: "真原画",
+    },
+];
 let cookieCache;
 export const getCookie = async () => {
     const now = new Date().getTime();
-    // 缓存24小时
-    if (cookieCache?.startTimestamp && now - cookieCache.startTimestamp < 24 * 60 * 60 * 1000) {
+    // 缓存6小时
+    if (cookieCache?.startTimestamp && now - cookieCache.startTimestamp < 6 * 60 * 60 * 1000) {
         return cookieCache.cookies;
     }
     const res = await requester.get("https://live.douyin.com/");
@@ -28,10 +77,16 @@ export const getCookie = async () => {
     };
     return cookies;
 };
-export async function getRoomInfo(webRoomId, retryOnSpecialCode = true) {
-    // 抖音的 'webcast/room/web/enter' api 会需要 ttwid 的 cookie，这个 cookie 是由这个请求的响应头设置的，
-    // 所以在这里请求一次自动设置。
-    const cookies = await getCookie();
+export async function getRoomInfo(webRoomId, opts = {}) {
+    let cookies = undefined;
+    if (opts.auth) {
+        cookies = opts.auth;
+    }
+    else {
+        // 抖音的 'webcast/room/web/enter' api 会需要 ttwid 的 cookie，这个 cookie 是由这个请求的响应头设置的，
+        // 所以在这里请求一次自动设置。
+        cookies = await getCookie();
+    }
     const res = await requester.get("https://live.douyin.com/webcast/room/web/enter/", {
         params: {
             aid: 6383,
@@ -55,9 +110,8 @@ export async function getRoomInfo(webRoomId, retryOnSpecialCode = true) {
             cookie: cookies,
         },
     });
-    // console.log(JSON.stringify(res.data, null, 2));
     // 无 cookie 时 code 为 10037
-    if (res.data.status_code === 10037 && retryOnSpecialCode) {
+    if (res.data.status_code === 10037 && opts.retryOnSpecialCode) {
         // resp 自动设置 cookie
         // const cookieRes = await requester.get("https://live.douyin.com/favicon.ico");
         // const cookies = cookieRes.headers["set-cookie"]
@@ -66,9 +120,12 @@ export async function getRoomInfo(webRoomId, retryOnSpecialCode = true) {
         //   })
         //   .join("; ");
         // console.log("cookies", cookies);
-        return getRoomInfo(webRoomId, false);
+        return getRoomInfo(webRoomId, {
+            retryOnSpecialCode: false,
+            doubleScreen: opts.doubleScreen,
+        });
     }
-    assert(res.data.status_code === 0, `Unexpected resp, code ${res.data.status_code}, msg ${res.data.data}, id ${webRoomId}`);
+    assert(res.data.status_code === 0, `Unexpected resp, code ${res.data.status_code}, msg ${JSON.stringify(res.data.data)}, id ${webRoomId}`);
     const data = res.data.data;
     const room = data.data[0];
     assert(room, `No room data, id ${webRoomId}`);
@@ -85,23 +142,72 @@ export async function getRoomInfo(webRoomId, retryOnSpecialCode = true) {
             liveId: room.id_str,
         };
     }
-    const { options: { qualities }, stream_data, } = room.stream_url.live_core_sdk_data.pull_data;
+    let qualities = [];
+    let stream_data = "";
+    if (opts.doubleScreen && !isEmpty(room.stream_url.pull_datas)) {
+        const pull_data = Object.values(room.stream_url.pull_datas)[0] ?? {
+            options: {
+                qualities: [],
+            },
+            stream_data: "",
+        };
+        qualities = pull_data.options.qualities;
+        stream_data = pull_data.stream_data;
+    }
+    if (!stream_data) {
+        qualities = room.stream_url.live_core_sdk_data.pull_data.options.qualities;
+        stream_data = room.stream_url.live_core_sdk_data.pull_data.stream_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,
     }));
+    // 转换流数据结构
+    const streamList = Object.entries(streamData)
+        .map(([quality, info]) => {
+        const stream = info?.main;
+        const name = qualityList.find((item) => item.key === quality)?.desc;
+        return {
+            quality: quality,
+            name: name ?? "未知",
+            flv: stream?.flv,
+            hls: stream?.hls,
+        };
+    })
+        .filter((stream) => stream.flv || stream.hls);
+    const aoStream = streamList.find((stream) => stream.quality === "ao");
+    if (!!aoStream) {
+        // 真原画流是在ao流中拿到的
+        streamList.push({
+            quality: "real_origin",
+            name: "真原画",
+            flv: (aoStream?.flv ?? "").replace("&only_audio=1", ""),
+            hls: (aoStream?.hls ?? "").replace("&only_audio=1", ""),
+        });
+    }
+    streamList.sort((a, b) => {
+        const aIndex = qualityList.findIndex((item) => item.key === a.quality);
+        const bIndex = qualityList.findIndex((item) => item.key === b.quality);
+        // 如果找不到对应的质量等级，将其排在最后
+        if (aIndex === -1)
+            return 1;
+        if (bIndex === -1)
+            return -1;
+        return aIndex - bIndex;
+    });
     // 看起来抖音是自动切换 cdn 的，所以这里固定返回一个默认的 source。
     const sources = [
         {
             name: "自动",
             streamMap: streamData,
+            streams: streamList,
         },
     ];
+    // console.log(JSON.stringify(sources, null, 2), qualities);
     return {
         living: data.room_status === 0,
-        // 接口里不会再返回 web room id，只能直接用入参原路返回了。
         roomId: webRoomId,
         owner: data.user.nickname,
         title: room.title,

package/lib/index.js

@@ -3,6 +3,7 @@ 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 { resolveShortURL } from "./douyin_api.js";
 import DouYinDanmaClient from "douyin-danma-listener";
 function createRecorder(opts) {
     // 内部实现时，应该只有 proxy 包裹的那一层会使用这个 recorder 标识符，不应该有直接通过
@@ -60,13 +61,23 @@ const ffmpegOutputOptions = [
     "-movflags",
     "faststart+frag_keyframe+empty_moov",
     "-min_frag_duration",
-    "60000000",
+    "10000000",
+];
+const ffmpegInputOptions = [
+    "-reconnect",
+    "1",
+    "-reconnect_streamed",
+    "1",
+    "-reconnect_delay_max",
+    "10",
+    "-rw_timeout",
+    "15000000",
 ];
 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;
+    const { living, owner, title } = liveInfo;
     this.liveInfo = liveInfo;
     if (liveInfo.liveId === banLiveId) {
         this.tempStopIntervalCheck = true;
@@ -78,7 +89,6 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
         return null;
     if (!living)
         return null;
-    this.emit("LiveStart", { liveId });
     let res;
     try {
         let strictQuality = false;
@@ -97,6 +107,9 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
             streamPriorities: this.streamPriorities,
             sourcePriorities: this.sourcePriorities,
             strictQuality: strictQuality,
+            cookie: this.auth,
+            formatPriorities: this.formatPriorities,
+            doubleScreen: this.doubleScreen,
         });
     }
     catch (err) {
@@ -111,7 +124,12 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
     this.usedSource = stream.source;
     // TODO: emit update event
     let isEnded = false;
+    let isCutting = false;
     const onEnd = (...args) => {
+        if (isCutting) {
+            isCutting = false;
+            return;
+        }
         if (isEnded)
             return;
         isEnded = true;
@@ -125,11 +143,18 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
     const recorder = new FFMPEGRecorder({
         url: stream.url,
         outputOptions: ffmpegOutputOptions,
+        inputOptions: ffmpegInputOptions,
         segment: this.segment ?? 0,
-        getSavePath: (opts) => getSavePath({ owner, title, startTime: opts.startTime }),
+        getSavePath: (opts) => getSavePath({ owner, title: opts.title ?? title, startTime: opts.startTime }),
         disableDanma: this.disableProvideCommentsWhenRecording,
         videoFormat: this.videoFormat ?? "auto",
-    }, onEnd);
+        headers: {
+            Cookie: this.auth,
+        },
+    }, onEnd, async () => {
+        const info = await getInfo(this.channelId);
+        return info;
+    });
     const savePath = getSavePath({
         owner,
         title,
@@ -141,8 +166,14 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
         this.state = "idle";
         throw err;
     }
-    const handleVideoCreated = async ({ filename }) => {
-        this.emit("videoFileCreated", { filename });
+    const handleVideoCreated = async ({ filename, title, cover }) => {
+        this.emit("videoFileCreated", { filename, cover });
+        if (title && this?.liveInfo) {
+            this.liveInfo.title = title;
+        }
+        if (cover && this?.liveInfo) {
+            this.liveInfo.cover = cover;
+        }
         const extraDataController = recorder.getExtraDataController();
         extraDataController?.setMeta({
             room_id: this.channelId,
@@ -166,14 +197,16 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
         }
         this.emit("progress", progress);
     });
-    const client = new DouYinDanmaClient(liveInfo.liveId);
+    const client = new DouYinDanmaClient(liveInfo.liveId, {
+        cookie: this.auth,
+    });
     client.on("chat", (msg) => {
         const extraDataController = recorder.getExtraDataController();
         if (!extraDataController)
             return;
         const comment = {
             type: "comment",
-            timestamp: Date.now(),
+            timestamp: Number(msg.eventTime) * 1000,
             text: msg.content,
             color: "#ffffff",
             sender: {
@@ -185,7 +218,6 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
                 // },
             },
         };
-        // console.log("comment", comment);
         this.emit("Message", comment);
         extraDataController.addMessage(comment);
     });
@@ -197,10 +229,12 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
             return;
         const gift = {
             type: "give_gift",
-            timestamp: Number(msg.sendTime),
+            timestamp: Number(msg.common.createTime) > 9999999999
+                ? Number(msg.common.createTime)
+                : Number(msg.common.createTime) * 1000,
             name: msg.gift.name,
             price: 1,
-            count: Number(msg.totalCount),
+            count: Number(msg.totalCount ?? 1),
             color: "#ffffff",
             sender: {
                 uid: msg.user.id,
@@ -211,10 +245,15 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
                 // },
             },
         };
-        // console.log("gift", gift);
         this.emit("Message", gift);
         extraDataController.addMessage(gift);
     });
+    client.on("reconnect", (attempts) => {
+        this.emit("DebugLog", {
+            type: "common",
+            text: `danma has reconnect ${attempts}`,
+        });
+    });
     // client.on("open", () => {
     //   console.log("open");
     // });
@@ -232,6 +271,16 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
     }
     const ffmpegArgs = recorder.getArguments();
     recorder.run();
+    const cut = singleton(async () => {
+        if (!this.recordHandle)
+            return;
+        if (isCutting)
+            return;
+        isCutting = true;
+        await recorder.stop();
+        recorder.createCommand();
+        recorder.run();
+    });
     const stop = singleton(async (reason) => {
         if (!this.recordHandle)
             return;
@@ -261,6 +310,7 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
         ffmpegArgs,
         savePath: savePath,
         stop,
+        cut,
     };
     this.emit("RecordStart", this.recordHandle);
     return this.recordHandle;
@@ -270,13 +320,26 @@ export const provider = {
     name: "抖音",
     siteURL: "https://live.douyin.com/",
     matchURL(channelURL) {
-        // TODO: 暂时不支持 v.douyin.com
-        return /https?:\/\/live\.douyin\.com\//.test(channelURL);
+        // 支持 v.douyin.com 和 live.douyin.com
+        return /https?:\/\/(live|v)\.douyin\.com\//.test(channelURL);
     },
     async resolveChannelInfoFromURL(channelURL) {
         if (!this.matchURL(channelURL))
             return null;
-        const id = path.basename(new URL(channelURL).pathname);
+        let id;
+        if (channelURL.includes("v.douyin.com")) {
+            // 处理短链接
+            try {
+                id = await resolveShortURL(channelURL);
+            }
+            catch (err) {
+                throw new Error(`解析抖音短链接失败: ${err?.message}`);
+            }
+        }
+        else {
+            // 处理常规直播链接
+            id = path.basename(new URL(channelURL).pathname);
+        }
         const info = await getInfo(id);
         return {
             id: info.roomId,

package/lib/stream.d.ts

@@ -12,6 +12,9 @@ export declare function getInfo(channelId: string): Promise<{
 export declare function getStream(opts: Pick<Recorder, "channelId" | "quality" | "streamPriorities" | "sourcePriorities"> & {
     rejectCache?: boolean;
     strictQuality?: boolean;
+    cookie?: string;
+    formatPriorities?: Array<"flv" | "hls">;
+    doubleScreen?: boolean;
 }): Promise<{
     currentStream: {
         name: string;

package/lib/stream.js

@@ -13,48 +13,40 @@ export async function getInfo(channelId) {
     };
 }
 export async function getStream(opts) {
-    const info = await getRoomInfo(opts.channelId);
+    const info = await getRoomInfo(opts.channelId, {
+        retryOnSpecialCode: true,
+        doubleScreen: opts.doubleScreen ?? true,
+        auth: opts.cookie,
+    });
     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",
-        },
-    ];
+    // 抖音为自动cdn，所以指定选择第一个
     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) {
+    const formatPriorities = opts.formatPriorities || ["flv", "hls"];
+    // 查找指定质量的流
+    let targetStream = sources.streams.find((s) => s.quality === opts.quality);
+    let qualityName = targetStream?.name ?? "未知";
+    if (!targetStream && 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 (!targetStream) {
+        targetStream = sources.streams.find((stream) => stream.flv || stream.hls);
+        if (targetStream) {
+            qualityName = targetStream.name;
         }
     }
+    if (!targetStream) {
+        throw new Error("未找到对应的流");
+    }
+    // 根据格式优先级选择 URL
+    let url;
+    for (const format of formatPriorities) {
+        url = targetStream[format];
+        if (url)
+            break;
+    }
     if (!url) {
         throw new Error("未找到对应的流");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bililive-tools/douyin-recorder",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "@bililive-tools douyin recorder implemention",
   "main": "./lib/index.js",
   "type": "module",
@@ -37,8 +37,8 @@
     "axios": "^1.7.8",
     "lodash-es": "^4.17.21",
     "mitt": "^3.0.1",
-    "@bililive-tools/manager": "^1.2.0",
-    "douyin-danma-listener": "0.1.1"
+    "douyin-danma-listener": "0.2.0",
+    "@bililive-tools/manager": "^1.3.0"
   },
   "devDependencies": {
     "@types/node": "*"