subprojects/gst-plugins-good/ext/qt/qtglrenderer.cc

   1 #include <QObject>
   2 #include <QQmlEngine>
   3 #include <QQmlComponent>
   4 #include <QWindow>
   5 #include <QQuickRenderControl>
   6 #include <QQuickWindow>
   7 #include <QQuickItem>
   8 #include <QOpenGLContext>
   9 #include <QOpenGLFunctions>
  10 #include <QOpenGLFramebufferObject>
  11 #include <QAnimationDriver>
  12
  13 #include <gst/gl/gl.h>
  14 #include "gstqtgl.h"
  15
  16 #include "qtglrenderer.h"
  17 #include "gstqtglutility.h"
  18
  19 #define GST_CAT_DEFAULT gst_qt_gl_renderer_debug
  20 GST_DEBUG_CATEGORY_STATIC (GST_CAT_DEFAULT);
  21
  22 static void
  23 init_debug (void)
  24 {
  25   static gsize _debug;
  26
  27   if (g_once_init_enter (&_debug)) {
  28     GST_DEBUG_CATEGORY_INIT (GST_CAT_DEFAULT, "qtglrenderer", 0,
  29         "Qt OpenGL Renderer");
  30     g_once_init_leave (&_debug, 1);
  31   }
  32 }
  33
  34 /* Needs to be based on QWindow otherwise (at least) windows and nvidia
  35  * proprietary on linux does not work
  36  * We also need to override the size handling to get the correct output size
  37  */
  38 class GstBackingSurface : public QWindow
  39 {
  40 public:
  41     GstBackingSurface();
  42     ~GstBackingSurface();
  43
  44     void setSize (int width, int height);
  45     QSize size() const override;
  46
  47 private:
  48     QSize m_size;
  49 };
  50
  51 GstBackingSurface::GstBackingSurface()
  52     : m_size(QSize())
  53 {
  54     /* we do OpenGL things so need an OpenGL surface */
  55     setSurfaceType(QSurface::OpenGLSurface);
  56 }
  57
  58 GstBackingSurface::~GstBackingSurface()
  59 {
  60 }
  61
  62 QSize GstBackingSurface::size () const
  63 {
  64     return m_size;
  65 }
  66
  67 void GstBackingSurface::setSize (int width, int height)
  68 {
  69     m_size = QSize (width, height);
  70 }
  71
  72 class GstAnimationDriver : public QAnimationDriver
  73 {
  74 public:
  75     GstAnimationDriver();
  76
  77     void setNextTime(qint64 ms);
  78     void advance() override;
  79     qint64 elapsed() const override;
  80 private:
  81     qint64 m_elapsed;
  82     qint64 m_next;
  83 };
  84
  85 GstAnimationDriver::GstAnimationDriver()
  86     : m_elapsed(0),
  87       m_next(0)
  88 {
  89 }
  90
  91 void GstAnimationDriver::advance()
  92 {
  93     m_elapsed = m_next;
  94     advanceAnimation();
  95 }
  96
  97 qint64 GstAnimationDriver::elapsed() const
  98 {
  99     return m_elapsed;
 100 }
 101
 102 void GstAnimationDriver::setNextTime(qint64 ms)
 103 {
 104     m_next = ms;
 105 }
 106
 107 typedef enum
 108 {
 109   STATE_ERROR = -1,
 110   STATE_NEW = 0,
 111   STATE_WAITING_FOR_WINDOW,
 112   STATE_WINDOW_CREATED,
 113   STATE_READY,
 114 } SharedRenderDataState;
 115
 116 struct SharedRenderData
 117 {
 118   int refcount;
 119   SharedRenderDataState state;
 120   GMutex lock;
 121   GCond cond;
 122   GstAnimationDriver *m_animationDriver;
 123   QOpenGLContext *m_context;
 124   GstBackingSurface *m_surface;
 125   QThread *m_renderThread;
 126 };
 127
 128 static struct SharedRenderData *
 129 shared_render_data_new (void)
 130 {
 131   struct SharedRenderData *ret = g_new0 (struct SharedRenderData, 1);
 132
 133   g_atomic_int_set (&ret->refcount, 1);
 134   g_mutex_init (&ret->lock);
 135
 136   return ret;
 137 }
 138
 139 static void
 140 shared_render_data_free (struct SharedRenderData * data)
 141 {
 142   GST_DEBUG ("%p freeing shared render data", data);
 143
 144   g_mutex_clear (&data->lock);
 145
 146   if (data->m_animationDriver) {
 147     data->m_animationDriver->uninstall();
 148     delete data->m_animationDriver;
 149   }
 150   data->m_animationDriver = nullptr;
 151   if (data->m_context)
 152     delete data->m_context;
 153   data->m_context = nullptr;
 154   if (data->m_surface)
 155     data->m_surface->deleteLater();
 156   data->m_surface = nullptr;
 157 }
 158
 159 static struct SharedRenderData *
 160 shared_render_data_ref (struct SharedRenderData * data)
 161 {
 162   GST_TRACE ("%p reffing shared render data", data);
 163   g_atomic_int_inc (&data->refcount);
 164   return data;
 165 }
 166
 167 static void
 168 shared_render_data_unref (struct SharedRenderData * data)
 169 {
 170   GST_TRACE ("%p unreffing shared render data", data);
 171   if (g_atomic_int_dec_and_test (&data->refcount))
 172     shared_render_data_free (data);
 173 }
 174
 175 void
 176 GstQuickRenderer::deactivateContext ()
 177 {
 178 }
 179
 180 void
 181 GstQuickRenderer::activateContext ()
 182 {
 183 }
 184
 185 struct FBOUserData
 186 {
 187   GstGLContext * context;
 188   QOpenGLFramebufferObject * fbo;
 189 };
 190
 191 static void
 192 delete_cxx_gl_context (GstGLContext * context, struct FBOUserData * data)
 193 {
 194   GST_TRACE ("freeing Qfbo %p", data->fbo);
 195   delete data->fbo;
 196 }
 197
 198 static void
 199 notify_fbo_delete (struct FBOUserData * data)
 200 {
 201   gst_gl_context_thread_add (data->context,
 202       (GstGLContextThreadFunc) delete_cxx_gl_context, data);
 203   gst_object_unref (data->context);
 204   g_free (data);
 205 }
 206
 207 GstQuickRenderer::GstQuickRenderer()
 208     : gl_context(NULL),
 209       m_fbo(nullptr),
 210       m_quickWindow(nullptr),
 211       m_renderControl(nullptr),
 212       m_qmlEngine(nullptr),
 213       m_qmlComponent(nullptr),
 214       m_rootItem(nullptr),
 215       gl_allocator(NULL),
 216       gl_params(NULL),
 217       gl_mem(NULL),
 218       m_sharedRenderData(NULL)
 219 {
 220   init_debug ();
 221 }
 222
 223 static gpointer
 224 dup_shared_render_data (gpointer data, gpointer user_data)
 225 {
 226   struct SharedRenderData *render_data = (struct SharedRenderData *) data;
 227
 228   if (render_data)
 229     return shared_render_data_ref (render_data);
 230
 231   return NULL;
 232 }
 233
 234 class CreateSurfaceEvent : public QEvent
 235 {
 236 public:
 237   CreateSurfaceEvent (CreateSurfaceWorker * worker)
 238       : QEvent(CreateSurfaceEvent::type())
 239   {
 240     m_worker = worker;
 241   }
 242
 243   ~CreateSurfaceEvent()
 244   {
 245     GST_TRACE ("%p destroying create surface event", this);
 246     delete m_worker;
 247   }
 248
 249   static QEvent::Type type()
 250   {
 251     if (customEventType == QEvent::None) {
 252       int generatedType = QEvent::registerEventType();
 253       customEventType = static_cast<QEvent::Type>(generatedType);
 254     }
 255     return customEventType;
 256   }
 257
 258 private:
 259   static QEvent::Type customEventType;
 260   CreateSurfaceWorker *m_worker;
 261 };
 262
 263 QEvent::Type CreateSurfaceEvent::customEventType = QEvent::None;
 264
 265
 266 CreateSurfaceWorker::CreateSurfaceWorker (struct SharedRenderData * rdata)
 267 {
 268   m_sharedRenderData = shared_render_data_ref (rdata);
 269 }
 270
 271 CreateSurfaceWorker::~CreateSurfaceWorker ()
 272 {
 273   shared_render_data_unref (m_sharedRenderData);
 274 }
 275
 276 bool CreateSurfaceWorker::event(QEvent * ev)
 277 {
 278     if (ev->type() == CreateSurfaceEvent::type()) {
 279         GST_TRACE ("%p creating surface", m_sharedRenderData);
 280         /* create the window surface in the main thread */
 281         g_mutex_lock (&m_sharedRenderData->lock);
 282         m_sharedRenderData->m_surface = new GstBackingSurface;
 283         m_sharedRenderData->m_surface->create();
 284         GST_TRACE ("%p created surface %p", m_sharedRenderData,
 285             m_sharedRenderData->m_surface);
 286         g_cond_broadcast (&m_sharedRenderData->cond);
 287         g_mutex_unlock (&m_sharedRenderData->lock);
 288     }
 289
 290     return QObject::event(ev);
 291 }
 292
 293 bool GstQuickRenderer::init (GstGLContext * context, GError ** error)
 294 {
 295     g_return_val_if_fail (GST_IS_GL_CONTEXT (context), false);
 296     g_return_val_if_fail (gst_gl_context_get_current () == context, false);
 297
 298     QVariant qt_native_context = qt_opengl_native_context_from_gst_gl_context (context);
 299
 300     if (qt_native_context.isNull()) {
 301         g_set_error (error, GST_RESOURCE_ERROR, GST_RESOURCE_ERROR_NOT_FOUND,
 302             "Could not convert from the provided GstGLContext to a Qt "
 303             "native context");
 304         return false;
 305     }
 306
 307     struct SharedRenderData *render_data = NULL, *old_render_data;
 308     do {
 309         if (render_data)
 310             shared_render_data_unref (render_data);
 311
 312         old_render_data = render_data = (struct SharedRenderData *)
 313                 g_object_dup_data (G_OBJECT (context),
 314                 "qt.gl.render.shared.data", dup_shared_render_data, NULL);
 315         if (!render_data)
 316             render_data = shared_render_data_new ();
 317     } while (old_render_data != render_data
 318             && !g_object_replace_data (G_OBJECT (context),
 319                 "qt.gl.render.shared.data", old_render_data, render_data,
 320                 NULL, NULL));
 321     m_sharedRenderData = render_data;
 322     GST_TRACE ("%p retrieved shared render data %p", this, m_sharedRenderData);
 323
 324     g_mutex_lock (&m_sharedRenderData->lock);
 325     if (m_sharedRenderData->state == STATE_ERROR) {
 326         g_set_error (error, GST_RESOURCE_ERROR, GST_RESOURCE_ERROR_NOT_FOUND,
 327             "In an error state from a previous attempt");
 328         g_mutex_unlock (&m_sharedRenderData->lock);
 329         return false;
 330     }
 331
 332     if (m_sharedRenderData->state != STATE_READY) {
 333         /* this state handling and locking is so that two qtglrenderer's will
 334          * not attempt to create an OpenGL context without freeing the previous
 335          * OpenGL context and cause a leak.  It also only allows one
 336          * CreateSurfaceEvent() to be posted to the main thread
 337          * (QCoreApplication::instance()->thread()) while still allowing
 338          * multiple waiters to wait for the window to be created */
 339         if (m_sharedRenderData->state == STATE_NEW) {
 340             QCoreApplication *app = QCoreApplication::instance ();
 341
 342             if (!app) {
 343                 g_set_error (error, GST_RESOURCE_ERROR, GST_RESOURCE_ERROR_NOT_FOUND,
 344                     "Could not retrieve QCoreApplication instance");
 345                 m_sharedRenderData->state = STATE_ERROR;
 346                 g_mutex_unlock (&m_sharedRenderData->lock);
 347                 return false;
 348             }
 349
 350             m_sharedRenderData->m_renderThread = QThread::currentThread();
 351             m_sharedRenderData->m_context = new QOpenGLContext;
 352             GST_TRACE ("%p new QOpenGLContext %p", this, m_sharedRenderData->m_context);
 353             m_sharedRenderData->m_context->setNativeHandle(qt_native_context);
 354
 355             CreateSurfaceWorker *w = new CreateSurfaceWorker (m_sharedRenderData);
 356             GST_TRACE ("%p posting create surface event to main thread with "
 357                 "worker %p", this, w);
 358             w->moveToThread (app->thread());
 359             app->postEvent (w, new CreateSurfaceEvent (w));
 360             m_sharedRenderData->state = STATE_WAITING_FOR_WINDOW;
 361         }
 362
 363         if (m_sharedRenderData->state == STATE_WAITING_FOR_WINDOW) {
 364             gint64 end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND;
 365             while (!m_sharedRenderData->m_surface) {
 366                 /* XXX: This might deadlock with the main thread if the
 367                  * QCoreApplication is not running and will not be able to
 368                  * execute.  We only wait for 5 seconds until a better
 369                  * approach can be found here */
 370                 if (!g_cond_wait_until (&m_sharedRenderData->cond,
 371                         &m_sharedRenderData->lock, end_time)) {
 372                     g_set_error (error, GST_RESOURCE_ERROR,
 373                         GST_RESOURCE_ERROR_NOT_FOUND,
 374                         "Could not create Qt window within 5 seconds");
 375                     m_sharedRenderData->state = STATE_ERROR;
 376                     g_mutex_unlock (&m_sharedRenderData->lock);
 377                     return false;
 378                 }
 379             }
 380
 381             GST_TRACE ("%p surface successfully created", this);
 382             m_sharedRenderData->state = STATE_WINDOW_CREATED;
 383         }
 384
 385         if (m_sharedRenderData->state == STATE_WINDOW_CREATED) {
 386             /* Qt does some things that may require the OpenGL context current
 387              * in ->create() so that it has the necessry information to create
 388              * the QOpenGLContext from the native handle. This may fail if the
 389              * OpenGL context is already current in another thread so we need
 390              * to deactivate the context from GStreamer's thread before asking
 391              * Qt to create the QOpenGLContext with ->create().
 392              */
 393             gst_gl_context_activate (context, FALSE);
 394             m_sharedRenderData->m_context->create();
 395             m_sharedRenderData->m_context->doneCurrent();
 396
 397             if (!m_sharedRenderData->m_context->makeCurrent(m_sharedRenderData->m_surface)) {
 398                 g_set_error (error, GST_RESOURCE_ERROR, GST_RESOURCE_ERROR_NOT_FOUND,
 399                     "Could not make Qt OpenGL context current");
 400                 /* try to keep the same OpenGL context state */
 401                 gst_gl_context_activate (context, TRUE);
 402                 m_sharedRenderData->state = STATE_ERROR;
 403                 g_mutex_unlock (&m_sharedRenderData->lock);
 404                 return false;
 405             }
 406
 407             if (!gst_gl_context_activate (context, TRUE)) {
 408                 g_set_error (error, GST_RESOURCE_ERROR, GST_RESOURCE_ERROR_NOT_FOUND,
 409                     "Could not make OpenGL context current again");
 410                 m_sharedRenderData->state = STATE_ERROR;
 411                 g_mutex_unlock (&m_sharedRenderData->lock);
 412                 return false;
 413             }
 414             m_sharedRenderData->state = STATE_READY;
 415         }
 416     }
 417
 418     m_renderControl = new QQuickRenderControl();
 419     /* Create a QQuickWindow that is associated with our render control. Note that this
 420      * window never gets created or shown, meaning that it will never get an underlying
 421      * native (platform) window.
 422      */
 423     m_quickWindow = new QQuickWindow(m_renderControl);
 424     /* after QQuickWindow creation as QQuickRenderControl requires it */
 425     m_renderControl->prepareThread (m_sharedRenderData->m_renderThread);
 426     g_mutex_unlock (&m_sharedRenderData->lock);
 427
 428     /* Create a QML engine. */
 429     m_qmlEngine = new QQmlEngine;
 430     if (!m_qmlEngine->incubationController())
 431         m_qmlEngine->setIncubationController(m_quickWindow->incubationController());
 432
 433     gl_context = static_cast<GstGLContext*>(gst_object_ref (context));
 434     gl_allocator = (GstGLBaseMemoryAllocator *) gst_gl_memory_allocator_get_default (gl_context);
 435     gl_params = (GstGLAllocationParams *)
 436         gst_gl_video_allocation_params_new_wrapped_texture (gl_context,
 437             NULL, &this->v_info, 0, NULL, GST_GL_TEXTURE_TARGET_2D, GST_GL_RGBA8,
 438             0, NULL, (GDestroyNotify) notify_fbo_delete);
 439
 440     /* This is a gross hack relying on the internals of Qt and GStreamer
 441      * however it's the only way to remove this warning on shutdown of all
 442      * resources.
 443      *
 444      * GLib-CRITICAL **: 17:35:24.988: g_main_context_pop_thread_default: assertion 'g_queue_peek_head (stack) == context' failed
 445      *
 446      * The reason is that libgstgl has a GMainContext that it pushes as the
 447      * thread default context.  Then later, Qt pushes a thread default main
 448      * context.  The detruction order of the GMainContext's is reversed as
 449      * GStreamer will explicitly pop the thread default main context however
 450      * Qt pops when the thread is about to be destroyed.  GMainContext is
 451      * unhappy with the ordering of the pops.
 452      */
 453     GMainContext *gst_main_context = g_main_context_ref_thread_default ();
 454
 455     /* make Qt allocate and push a thread-default GMainContext if it is
 456      * going to */
 457     QEventLoop loop;
 458     if (loop.processEvents())
 459         GST_LOG ("pending QEvents processed");
 460
 461     GMainContext *qt_main_context = g_main_context_ref_thread_default ();
 462
 463     if (qt_main_context == gst_main_context) {
 464         g_main_context_unref (qt_main_context);
 465         g_main_context_unref (gst_main_context);
 466     } else {
 467         /* We flip the order of the GMainContext's so that the destruction
 468          * order can be preserved. */
 469         g_main_context_pop_thread_default (qt_main_context);
 470         g_main_context_pop_thread_default (gst_main_context);
 471         g_main_context_push_thread_default (qt_main_context);
 472         g_main_context_push_thread_default (gst_main_context);
 473         g_main_context_unref (qt_main_context);
 474         g_main_context_unref (gst_main_context);
 475     }
 476
 477     return true;
 478 }
 479
 480 GstQuickRenderer::~GstQuickRenderer()
 481 {
 482     gst_gl_allocation_params_free (gl_params);
 483     gst_clear_object (&gl_allocator);
 484 }
 485
 486 void GstQuickRenderer::stopGL ()
 487 {
 488     GST_DEBUG ("%p stop QOpenGLContext curent: %p stored: %p", this,
 489         QOpenGLContext::currentContext(), m_sharedRenderData->m_context);
 490     g_assert (QOpenGLContext::currentContext() == m_sharedRenderData->m_context);
 491
 492     if (m_renderControl)
 493         m_renderControl->invalidate();
 494
 495     if (m_fbo)
 496         delete m_fbo;
 497     m_fbo = nullptr;
 498
 499     QEventLoop loop;
 500     if (loop.processEvents())
 501         GST_LOG ("%p pending QEvents processed", this);
 502
 503     if (m_sharedRenderData)
 504         shared_render_data_unref (m_sharedRenderData);
 505     m_sharedRenderData = NULL;
 506
 507     /* XXX: reset the OpenGL context and drawable as Qt may have clobbered it.
 508      * Fixes any attempt to access OpenGL after shutting down qmlgloverlay. */
 509     gst_gl_context_activate (gl_context, FALSE);
 510     gst_gl_context_activate (gl_context, TRUE);
 511 }
 512
 513 void GstQuickRenderer::cleanup()
 514 {
 515     if (gl_context)
 516         gst_gl_context_thread_add (gl_context,
 517             (GstGLContextThreadFunc) GstQuickRenderer::stop_c, this);
 518
 519     /* Delete the render control first since it will free the scenegraph resources.
 520      * Destroy the QQuickWindow only afterwards. */
 521     if (m_renderControl)
 522         delete m_renderControl;
 523     m_renderControl = nullptr;
 524
 525     if (m_qmlComponent)
 526         delete m_qmlComponent;
 527     m_qmlComponent = nullptr;
 528     if (m_quickWindow)
 529         delete m_quickWindow;
 530     m_quickWindow = nullptr;
 531     if (m_qmlEngine)
 532         delete m_qmlEngine;
 533     m_qmlEngine = nullptr;
 534     if (m_rootItem)
 535         delete m_rootItem;
 536     m_rootItem = nullptr;
 537
 538     gst_clear_object (&gl_context);
 539 }
 540
 541 void GstQuickRenderer::ensureFbo()
 542 {
 543     if (m_fbo && m_fbo->size() != m_sharedRenderData->m_surface->size()) {
 544         GST_INFO ("%p removing old framebuffer created with size %ix%i",
 545             this, m_fbo->size().width(), m_fbo->size().height());
 546         delete m_fbo;
 547         m_fbo = nullptr;
 548     }
 549
 550     if (!m_fbo) {
 551         m_fbo = new QOpenGLFramebufferObject(m_sharedRenderData->m_surface->size(),
 552                 QOpenGLFramebufferObject::CombinedDepthStencil);
 553         m_quickWindow->setRenderTarget(m_fbo);
 554         GST_DEBUG ("%p new framebuffer created with size %ix%i", this,
 555             m_fbo->size().width(), m_fbo->size().height());
 556     }
 557 }
 558
 559 void
 560 GstQuickRenderer::renderGstGL ()
 561 {
 562     const GstGLFuncs *gl = gl_context->gl_vtable;
 563
 564     GST_TRACE ("%p current QOpenGLContext %p", this,
 565         QOpenGLContext::currentContext());
 566     m_quickWindow->resetOpenGLState();
 567
 568     m_sharedRenderData->m_animationDriver->advance();
 569
 570     QEventLoop loop;
 571     if (loop.processEvents())
 572         GST_LOG ("pending QEvents processed");
 573
 574     loop.exit();
 575
 576     ensureFbo();
 577
 578     /* Synchronization and rendering happens here on the render thread. */
 579     if (m_renderControl->sync())
 580         GST_LOG ("sync successful");
 581
 582     /* Meanwhile on this thread continue with the actual rendering. */
 583     m_renderControl->render();
 584
 585     GST_DEBUG ("wrapping Qfbo %p with texture %u", m_fbo, m_fbo->texture());
 586     struct FBOUserData *data = g_new0 (struct FBOUserData, 1);
 587     data->context = (GstGLContext *) gst_object_ref (gl_context);
 588     data->fbo = m_fbo;
 589     gl_params->user_data = static_cast<gpointer> (data);
 590     gl_params->gl_handle = GINT_TO_POINTER (m_fbo->texture());
 591     gl_mem = (GstGLMemory *) gst_gl_base_memory_alloc (gl_allocator, gl_params);
 592
 593     m_fbo = nullptr;
 594
 595     m_quickWindow->resetOpenGLState ();
 596     /* Qt doesn't seem to reset this, breaking glimagesink */
 597     if (gl->DrawBuffer)
 598       gl->DrawBuffer (GL_BACK);
 599 }
 600
 601 GstGLMemory *GstQuickRenderer::generateOutput(GstClockTime input_ns)
 602 {
 603     m_sharedRenderData->m_animationDriver->setNextTime(input_ns / GST_MSECOND);
 604
 605     /* run an event loop to update any changed values for rendering */
 606     QEventLoop loop;
 607     if (loop.processEvents())
 608         GST_LOG ("pending QEvents processed");
 609
 610     GST_LOG ("generating output for time %" GST_TIME_FORMAT " ms: %"
 611         G_GUINT64_FORMAT, GST_TIME_ARGS (input_ns), input_ns / GST_MSECOND);
 612
 613     m_quickWindow->update();
 614
 615     /* Polishing happens on the gui thread. */
 616     m_renderControl->polishItems();
 617
 618     /* TODO: an async version could be used where */
 619     gst_gl_context_thread_add (gl_context,
 620             (GstGLContextThreadFunc) GstQuickRenderer::render_gst_gl_c, this);
 621
 622     GstGLMemory *tmp = gl_mem;
 623     gl_mem = NULL;
 624
 625     return tmp;
 626 }
 627
 628 void GstQuickRenderer::initializeGstGL ()
 629 {
 630     GST_TRACE ("current QOpenGLContext %p", QOpenGLContext::currentContext());
 631     if (!m_sharedRenderData->m_context->makeCurrent(m_sharedRenderData->m_surface)) {
 632         m_errorString = "Failed to make Qt's wrapped OpenGL context current";
 633         return;
 634     }
 635     GST_INFO ("current QOpenGLContext %p", QOpenGLContext::currentContext());
 636
 637     /* XXX: Avoid an assertion inside QSGDefaultRenderContext::initialize()
 638      * from an unused (in this scenario) property when using multiple
 639      * QQuickRenderControl's with the same QOpenGLContext.
 640      *
 641      * First noticed with Qt 5.15.  Idea from:
 642      * https://forum.qt.io/topic/55888/is-it-impossible-that-2-qquickrendercontrol-use-same-qopenglcontext/2
 643      *
 644      * ASSERT: "!m_gl->property(QSG_RENDERCONTEXT_PROPERTY).isValid()" in file /path/to/qt5/qtdeclarative/src/quick/scenegraph/qsgdefaultrendercontext.cpp, line 121
 645      */
 646     m_sharedRenderData->m_context->setProperty("_q_sgrendercontext", QVariant());
 647
 648     m_renderControl->initialize(m_sharedRenderData->m_context);
 649
 650     /* 1. QAnimationDriver's are thread-specific
 651      * 2. QAnimationDriver controls the 'animation time' that the Qml scene is
 652      *    rendered at
 653      */
 654     /* FIXME: what happens with multiple qmlgloverlay elements?  Do we need a
 655      * shared animation driver? */
 656     g_mutex_lock (&m_sharedRenderData->lock);
 657     if (m_sharedRenderData->m_animationDriver == nullptr) {
 658         m_sharedRenderData->m_animationDriver = new GstAnimationDriver;
 659         m_sharedRenderData->m_animationDriver->install();
 660     }
 661     g_mutex_unlock (&m_sharedRenderData->lock);
 662     /* XXX: reset the OpenGL context drawable as Qt may have clobbered it.
 663      * Fixes glimagesink output where Qt replaces the Surface to use in its
 664      * own MakeCurrent call.  Qt does this on it's OpenGL initialisation
 665      * the the rendering engine. */
 666     gst_gl_context_activate (gl_context, FALSE);
 667     gst_gl_context_activate (gl_context, TRUE);
 668 }
 669
 670 void GstQuickRenderer::initializeQml()
 671 {
 672     disconnect(m_qmlComponent, &QQmlComponent::statusChanged, this,
 673             &GstQuickRenderer::initializeQml);
 674
 675     if (m_qmlComponent->isError()) {
 676         const QList<QQmlError> errorList = m_qmlComponent->errors();
 677         for (const QQmlError &error : errorList)
 678             m_errorString += error.toString();
 679         return;
 680     }
 681
 682     QObject *rootObject = m_qmlComponent->create();
 683     if (m_qmlComponent->isError()) {
 684         const QList<QQmlError> errorList = m_qmlComponent->errors();
 685         for (const QQmlError &error : errorList)
 686             m_errorString += error.toString();
 687         delete rootObject;
 688         return;
 689     }
 690
 691     m_rootItem = qobject_cast<QQuickItem *>(rootObject);
 692     if (!m_rootItem) {
 693         m_errorString += "root QML item is not a QQuickItem";
 694         delete rootObject;
 695         return;
 696     }
 697
 698     /* The root item is ready. Associate it with the window. */
 699     m_rootItem->setParentItem(m_quickWindow->contentItem());
 700
 701     /* Update item and rendering related geometries. */
 702     updateSizes();
 703
 704     /* Initialize the render control and our OpenGL resources. */
 705     gst_gl_context_thread_add (gl_context,
 706             (GstGLContextThreadFunc) GstQuickRenderer::initialize_gst_gl_c, this);
 707 }
 708
 709 void GstQuickRenderer::updateSizes()
 710 {
 711     GstBackingSurface *surface =
 712             static_cast<GstBackingSurface *>(m_sharedRenderData->m_surface);
 713     /* Behave like SizeRootObjectToView. */
 714     QSize size = surface->size();
 715
 716     m_rootItem->setWidth(size.width());
 717     m_rootItem->setHeight(size.height());
 718
 719     m_quickWindow->setGeometry(0, 0, size.width(), size.height());
 720
 721     gst_video_info_set_format (&v_info, GST_VIDEO_FORMAT_RGBA, size.width(),
 722         size.height());
 723     GstGLVideoAllocationParams *params = (GstGLVideoAllocationParams *) (gl_params);
 724     gst_video_info_set_format (params->v_info, GST_VIDEO_FORMAT_RGBA, size.width(),
 725         size.height());
 726 }
 727
 728 void GstQuickRenderer::setSize(int w, int h)
 729 {
 730     static_cast<GstBackingSurface *>(m_sharedRenderData->m_surface)->setSize(w, h);
 731     updateSizes();
 732 }
 733
 734 bool GstQuickRenderer::setQmlScene (const gchar * scene, GError ** error)
 735 {
 736     /* replacing the scene is not supported */
 737     g_return_val_if_fail (m_qmlComponent == NULL, false);
 738
 739     m_errorString = "";
 740
 741     m_qmlComponent = new QQmlComponent(m_qmlEngine);
 742     /* XXX: do we need to provide a propper base name? */
 743     m_qmlComponent->setData(QByteArray (scene), QUrl(""));
 744     if (m_qmlComponent->isLoading())
 745         /* TODO: handle async properly */
 746         connect(m_qmlComponent, &QQmlComponent::statusChanged, this,
 747                 &GstQuickRenderer::initializeQml);
 748     else
 749         initializeQml();
 750
 751     if (m_errorString != "") {
 752         QByteArray string = m_errorString.toUtf8();
 753         g_set_error (error, GST_RESOURCE_ERROR, GST_RESOURCE_ERROR_SETTINGS,
 754             "%s", string.constData());
 755         return FALSE;
 756     }
 757
 758     return TRUE;
 759 }
 760
 761 QQuickItem * GstQuickRenderer::rootItem() const
 762 {
 763     return m_rootItem;
 764 }