gstreamer和QML：在QML窗口上绘图

Question

I have been trying to draw a gstreamer camera output onto a QML object for months now. At least on my ARM system none of the qt-gstreamer qml components really worked with the camera output (I can show the test video source) but never anything from the camera.

So, I went to the old school of rendering onto a regular qt window with the following example:

#include <glib.h>
#include <gst/gst.h>
#include <gst/video/videooverlay.h>

#include <QApplication>
#include <QTimer>
#include <QWidget>

int main(int argc, char *argv[])
{
    if (!g_thread_supported ())
        g_thread_init (NULL);

    gst_init (&argc, &argv);
    QApplication app(argc, argv);
    app.connect(&app, SIGNAL(lastWindowClosed()), &app, SLOT(quit ()));

    // prepare the pipeline

    GstElement *pipeline = gst_pipeline_new ("xvoverlay");
    GstElement *src = gst_element_factory_make ("v4l2src", NULL);
    GstElement *sink = gst_element_factory_make ("xvimagesink", NULL);
    gst_bin_add_many (GST_BIN (pipeline), src, sink, NULL);
    gst_element_link (src, sink);

    // prepare the ui

    QWidget window;
    window.resize(320, 240);
    window.show();

    WId xwinid = window.winId();
    gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (sink), xwinid);

    // run the pipeline

    GstStateChangeReturn sret = gst_element_set_state (pipeline,
                                                       GST_STATE_PLAYING);
    if (sret == GST_STATE_CHANGE_FAILURE) {
        gst_element_set_state (pipeline, GST_STATE_NULL);
        gst_object_unref (pipeline);
        // Exit application
        QTimer::singleShot(0, QApplication::activeWindow(), SLOT(quit()));
    }

    int ret = app.exec();

    window.hide();
    gst_element_set_state (pipeline, GST_STATE_NULL);
    gst_object_unref (pipeline);

    return ret;
}

Here I am window ID of the QWidget and overlaying the video in it. This is the only thing that ever worked for me.

However, now I wonder, if it is possible to get the window ID of an underlying qt graphical element. So, for example if I have something like:

ApplicationWindow {
    id: rootWindow
    objectName: "window"
    visible: true
    width: 800
    height: 480
    color: "#FFFFFF"    

    Rectangle {
       width: 100
       height: 100
       color: "red"
       border.color: "black"
       border.width: 5
       radius: 10
    }
}

Is it possible to get the ID of the underlying graphical window object or does that not exist? is there some component which has its own graphical ID that I can use in QML and then query from my C++ app and use it to overlay the video?

Answer 1

There are a few pieces to this puzzle. First, getting the window ID of the QML window. You can get this from the application engine.

QObject* m_rootObject = engine->rootObjects().first();
WId wid = -1;
if(m_rootObject) {
    QWindow *window = qobject_cast<QWindow *>(m_rootObject);
    if(window) {
        wid = window->winId();
    }
}

Next, you need to set the handler on the video sink. I recommend using glimagesing , because the automatic one does not implement the interface, and the X11 one is linux-only.

data.video_sink = gst_element_factory_make("glimagesink", "data.video_sink");
gst_video_overlay_set_window_handle (GST_VIDEO_OVERLAY (data.video_sink), wid);

Now, this will overlay the entire window, which is probably not what you want. The final piece of the puzzle: Expose a wrapper to QML with a QRect property, then you can set the bounds of the target area as follows:

Binding {
  target: videowrapper
  property: "rect"
  value: {
    var pos = mapToItem(window.contentItem, 0, 0)
    console.log(pos)
    return Qt.rect(pos.x, pos.y, placeholder.width, placeholder.height)
  }
}

And then based on that property, you can do something like

void VideoShow::set_bounds(int x, int y, int width, int height) {
    gst_video_overlay_set_render_rectangle(GST_VIDEO_OVERLAY (data.video_sink), x, y, width, height);
}

Probably the "subwindow" approach would be better, but this works. Only limitation is that it's literally an overlay on top of the UI, so any UI elements will draw below the frame.