PCHelper

const obs = require('obs-studio-node');   // 加载 OBS 库

obs.InputFactory.create();                // 创建视频输入源

obs.SceneFactory.create('test-scene');    // 创建直播场景

obs.NodeObs.OBS_content_createSourcePreviewDisplay();  // 创建预览显示区域

obs.NodeObs.OBS_content_moveDisplay();    // 调整显示区域位置

obs.NodeObs.OBS_settings_saveSettings();  // 保存 OBS 配置参数

obs.NodeObs.OBS_settings_getSettings();   // 获取 OBS 配置参数

obs.NodeObs.OBS_service_startStreaming(); // 开始推流

obs.NodeObs.OBS_service_stopStreaming(true); // 停止推流

obs.SceneFactory.create('test-scene').add(source); // 将输入源添加到场景中

getTrtcUrl() {
    const { trtcAppid } = getPlatformInfo();
    const role = trtcRole;
    const userid = longHandleToString(this.userId);
    const roomId = longHandleToString(this.roomId);
    const sig = this.sig;
    const streamid = this.streamid;
    
    // 构建 TRTC 自定义参数
    const str = `{"Str_uc_params":{"userdefine_push_args":"${this.trtcStr}"}}`;
    const trtcStr = encodeURIComponent(str);
    
    // 拼接完整的 TRTC 推流地址
    const trtcURL = `trtc://xxx?appid=${trtcAppid}&userid=${userid}&roomid=${roomId}&sig=${sig}&role=${role}&streamid=${streamid}&trtc_str=${trtcStr}`;
    console.log('trtcurl:', trtcURL);

    return trtcURL;
}

// 发送用户音量状态的 SEI 信息
function sendUserVolumeSEI(msg: MultiChatRoomEventMsg) {
    let muteLog = '透传静音状态SEI ';
    const seiData = new Map<string, any>();
    const anchorList = [];

    // 遍历所有主播信息，构建静音状态列表
    Object.entries(msg.chat_room_info.anchor_infos).forEach(([k, v]) => {
        const muteDict = new Map<string, any>();
        muteDict.set('uid', v.basic_info.uid.low);
        muteDict.set('mute', v.is_mute ?? false);
        anchorList.push(muteDict);
        muteLog += `uid:${v.basic_info.uid.low} mute:${v.is_mute ?? false}`;
    });

    seiData.set('anchor_list', anchorList);
    seiData.set('host_uid', this.roomService.state.info.userId);
    console.log(`🌼${muteLog}`);
    
    // 通过 IPC 发送到 main 进程
    this.streamingService.sendCustSEI('multi_link_mic', seiData);
}

bool TRTCController::sendSEIMsg(
    const uint8_t* data, 
    uint32_t dataSize, 
    int32_t repeatCount) {
    
    if (data == nullptr) {
        blog(LOG_ERROR, "send sei msg data = null");
        return false;
    }
    
    // 在数据前添加 SEI 标识头
    int seiSize = dataSize + SEI_START_TAG_LEN;
    char* seiData = (char*)malloc(seiSize);
    memset(seiData, 0, seiSize);
    memcpy(seiData, SEI_START_TAG, SEI_START_TAG_LEN);
    memcpy(seiData + SEI_START_TAG_LEN, data, dataSize);
    
    blog(LOG_INFO, "send sei msg:%s,data size:%d,repeat count:%d", 
         seiData, seiSize, repeatCount);
    
    // 调用 TRTC SDK 发送 SEI 数据
    bool ret = getTRTCShareInstance()->sendSEIMsg(
        (const uint8_t*)seiData, seiSize, repeatCount);
    
    free(seiData);
    seiData = nullptr;

    return ret;
}

/**
 * 创建渲染窗口
 * - 处理 DPI 缩放转换
 * - 启动独立的渲染线程异步创建窗口
 */
void RenderWindowManager::createWindow(HWND hwnd, int x, int y, int w, int h) {
    // 如果子窗口已存在，仅更新位置
    if (subHwnd != NULL) {
        info("sub hwnd exits, refresh windows position:%d,%d,%d,%d", x, y, w, h);
        setWindowPosition(x, y, w, h, hwnd);
        return;
    }
    
    parentHwnd = hwnd;
    // 将 DIP 坐标转换为实际像素坐标
    this->x = getPixelFromDip(x);
    this->y = getPixelFromDip(y);
    this->w = getPixelFromDip(w);
    this->h = getPixelFromDip(h);
    
    registerWndClass();
    
    // 启动渲染线程
    renderThread = (HANDLE)_beginthreadex(
        NULL, 0, &render_msg_thread, (void*)this, 0, &renderThreadId);
    
    std::unique_lock<std::mutex> lock(mMutex);
    // 等待窗口创建完成（约 100-200ms）
    mCondVar.wait(lock);

    info("create windows ok:%x ,position :%d,%d,%d,%d", subHwnd, x, y, w, h);
}

/**
 * 更新 SDL 渲染内容
 * - 创建 YUV 纹理并更新数据
 * - 处理视频缩放和居中显示
 */
void RenderWindowManager::updateSDLRender(LiveStreamVideoFrame* videoFrame) {
    if (sdlRender == nullptr) {
        return;
    }
    
    // 首次渲染时创建纹理
    if (sdlTexture == nullptr) {
        sdlTexture = SDL_CreateTexture(
            sdlRender, 
            SDL_PIXELFORMAT_IYUV, 
            SDL_TEXTUREACCESS_STREAMING, 
            videoFrame->width, 
            videoFrame->height);
        SDL_SetTextureScaleMode(sdlTexture, SDL_ScaleMode::SDL_ScaleModeBest);
    }
    
    int width = videoFrame->width;
    int height = videoFrame->height;

    // 解析 YUV 数据指针
    char* pY = videoFrame->data;
    char* pU = videoFrame->data + width * height;
    char* pV = videoFrame->data + width * height + ((width * height) >> 2);
    
    // 更新 YUV 纹理数据
    SDL_UpdateYUVTexture(
        sdlTexture, NULL, 
        (Uint8*)pY, width, 
        (Uint8*)pU, width / 2, 
        (Uint8*)pV, width / 2);
    
    SDL_RenderClear(sdlRender);
    
    // 计算缩放和裁剪参数，保持宽高比
    int srcW = width;
    int srcH = height;
    int srcX = 0;
    int srcY = 0;
    
    if (w > h) {
        srcH = width * h / w;
        srcY = (height - srcH) / 2;
    } else {
        srcW = height * w / h;
        srcX = (width - srcW) / 2;
    }

    SDL_Rect dstRect = {0, 0, w, h};
    SDL_Rect srcRect = {srcX, srcY, srcW, srcH};

    SDL_RenderCopy(sdlRender, sdlTexture, &srcRect, &dstRect);
    SDL_RenderPresent(sdlRender);
}

/**
 * 销毁渲染窗口
 * - 清理 SDL 资源（纹理、渲染器、窗口）
 * - 关闭渲染线程
 */
void RenderWindowManager::destroyWindow() {
    // 释放 SDL 纹理
    if (sdlTexture != nullptr) {
        SDL_DestroyTexture(sdlTexture);
        sdlTexture = nullptr;
    }
    
    // 释放 SDL 渲染器
    if (sdlRender != nullptr) {
        SDL_RenderClear(sdlRender);
        SDL_DestroyRenderer(sdlRender);
        sdlRender = nullptr;
    }
    
    // 释放 SDL 窗口
    if (sdlWindow != nullptr) {
        SDL_DestroyWindow(sdlWindow);
        sdlWindow = nullptr;
    }
    
    // 销毁 Windows 窗口
    ShowWindow(subHwnd, SW_HIDE);
    DestroyWindow(subHwnd);
    
    // 关闭渲染线程
    if (renderThread != nullptr) {
        CloseHandle(renderThread);
        renderThread = nullptr;
    }
    
    subHwnd = NULL;
    info("destroy window and sdl info!!!");
}