我刚好在Linux下做过类似的跨模块OpenGL渲染到Qt窗口的需求，针对你说的“获取Qt部件X窗口ID传给自定义OpenGL模块”这个方案，给你详细拆解下实现步骤和避坑点：

这个方案的本质是让独立的OpenGL上下文绑定到Qt创建的系统级X窗口——因为X窗口是跨框架的系统资源，只要拿到它的唯一ID（XID），就能在自定义模块里完成渲染绑定，完全不需要依赖Qt的OpenGL组件。

1. 从Qt部件获取X窗口ID #

首先要注意：Qt部件只有在显示之后才会创建真实的X窗口，所以不能在构造函数里直接拿winId()，得等部件完成初始化。

代码示例（Qt端） #

class VideoDisplayWidget : public QWidget {
    Q_OBJECT
public:
    explicit VideoDisplayWidget(QWidget* parent = nullptr) : QWidget(parent) {}

protected:
    void showEvent(QShowEvent* event) override {
        QWidget::showEvent(event);
        // 拿到X窗口ID，Linux下WId就是Xlib的Window类型
        WId xWindowId = this->winId();
        // 把XID传给自定义OpenGL模块，这里用线程安全的方式传递（比如原子变量、互斥保护的队列）
        OpenGLStreamer::instance()->setTargetWindow(reinterpret_cast<Window>(xWindowId));
    }

    void resizeEvent(QResizeEvent* event) override {
        QWidget::resizeEvent(event);
        // 窗口大小变化时通知OpenGL模块调整视口
        OpenGLStreamer::instance()->updateViewport(event->size().width(), event->size().height());
    }

    void closeEvent(QCloseEvent* event) override {
        QWidget::closeEvent(event);
        // 窗口销毁时通知OpenGL模块解绑上下文
        OpenGLStreamer::instance()->unbindWindow();
    }
};

2. 自定义OpenGL模块绑定X窗口 #

你的模块需要用Xlib和GLX（Linux下X窗口的OpenGL接口）来完成上下文绑定，核心是让OpenGL上下文关联到目标X窗口。

代码示例（自定义OpenGL模块端） #

#include <X11/Xlib.h>
#include <GL/glx.h>
#include <mutex>
#include <thread>
#include <chrono>

class OpenGLStreamer {
public:
    static OpenGLStreamer* instance() {
        static OpenGLStreamer inst;
        return &inst;
    }

    void init() {
        // 打开X Display，默认nullptr就是当前Display，和Qt共用同一个
        m_display = XOpenDisplay(nullptr);
        if (!m_display) {
            // 错误处理：比如打印日志或抛出异常
            return;
        }

        // 创建兼容的OpenGL上下文，这里通过目标窗口的属性获取匹配配置
        int attribs[] = {
            GLX_RGBA,
            GLX_DOUBLEBUFFER,
            GLX_DEPTH_SIZE, 24,
            None
        };
        GLXFBConfig fbConfig = glXChooseFBConfig(m_display, DefaultScreen(m_display), attribs, nullptr);
        m_glContext = glXCreateNewContext(m_display, fbConfig, GLX_RGBA_TYPE, nullptr, True);
    }

    void setTargetWindow(Window xid) {
        std::lock_guard<std::mutex> lock(m_mutex);
        m_targetWindow = xid;
        // 绑定上下文到目标窗口
        if (m_glContext && m_display) {
            glXMakeCurrent(m_display, m_targetWindow, m_glContext);
        }
    }

    void updateViewport(int width, int height) {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (glXGetCurrentContext() == m_glContext) {
            glViewport(0, 0, width, height);
        }
    }

    void unbindWindow() {
        std::lock_guard<std::mutex> lock(m_mutex);
        if (glXGetCurrentContext() == m_glContext) {
            glXMakeCurrent(m_display, None, nullptr);
        }
        m_targetWindow = 0;
    }

    // 多路视频流渲染函数（在独立线程中执行）
    void startRendering() {
        m_running = true;
        std::thread renderThread(&OpenGLStreamer::renderStreams, this);
        renderThread.detach();
    }

    void stopRendering() {
        m_running = false;
    }

private:
    OpenGLStreamer() = default;
    ~OpenGLStreamer() {
        stopRendering();
        if (m_glContext) {
            glXDestroyContext(m_display, m_glContext);
        }
        if (m_display) {
            XCloseDisplay(m_display);
        }
    }

    void renderStreams() {
        while (m_running) {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (!m_targetWindow || !glXGetCurrentContext()) {
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
                continue;
            }

            // 1. 处理多路视频流，更新纹理（这里假设已实现纹理加载逻辑）
            updateTextures();

            // 2. 渲染到窗口：清屏+绘制纹理四边形
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            drawTextures();

            // 3. 交换双缓冲，Qt窗口默认是双缓冲，必须调用才会显示画面
            glXSwapBuffers(m_display, m_targetWindow);
        }
    }

    // 占位函数：实际实现多路纹理更新逻辑
    void updateTextures() {}
    // 占位函数：实际实现纹理绘制逻辑
    void drawTextures() {}

    Display* m_display = nullptr;
    GLXContext m_glContext = nullptr;
    Window m_targetWindow = 0;
    bool m_running = false;
    std::mutex m_mutex;
};

• 上下文兼容性：必须保证自定义OpenGL上下文的配置（比如RGBA、双缓冲、深度缓冲区）和Qt窗口的Visual一致，不然会出现黑屏、花屏。最稳妥的方式是直接复用Qt窗口的Visual（通过QX11Info::visual()获取后传给模块）。
• 线程安全：所有OpenGL操作必须在模块的独立线程中执行，Qt UI线程只负责传递XID和窗口大小，绝对不能在UI线程调用OpenGL函数。
• 窗口生命周期：当Qt窗口隐藏、销毁时，一定要及时通知模块解绑上下文，避免悬空指针导致崩溃。
• 多纹理共享：如果是多路视频流，建议用共享OpenGL上下文——让每个视频解码线程创建的纹理对象可以被渲染线程共享，这样不用在渲染线程里重复创建纹理，大幅提升性能。

内容的提问来源于stack exchange，提问作者El Sampsa