Ticket #5324: openglvid_8.diff

libs/libmythtv/openglcontext.cpp

@@ -7 +7 @@
 #define LOC QString("GLCtx: ")
 #define LOC_ERR QString("GLCtx, Error: ")
 
+ContextLocker::ContextLocker(OpenGLContext *ctx)
+              : m_ctx(ctx)
+{
+    if (m_ctx)
+        m_ctx->MakeCurrent(true);
+}
+ContextLocker::~ContextLocker()
+{
+    if (m_ctx)
+        m_ctx->MakeCurrent(false);
+}
+
 class PrivateContext
 {
   public:
@@ -36 +48 @@
     vector<GLuint> m_framebuffers;
 };
 
-OpenGLContext::OpenGLContext() :
+OpenGLContext::OpenGLContext(QMutex *lock) :
     m_priv(new PrivateContext()),
     m_display(NULL), m_screen_num(0),
     m_major_ver(1), m_minor_ver(2),
     m_extensions(QString::null), m_ext_supported(0),
-    m_max_tex_size(0), m_viewport(0,0)
+    m_max_tex_size(0), m_viewport(0,0),
+    m_lock(lock), m_lock_level(0)
 {
     if (!init_opengl())
         VERBOSE(VB_PLAYBACK, LOC_ERR + "Failed to initialize OpenGL support.");
@@ -63 +76 @@
 
     glFlush();
 
-    MakeCurrent(false);
-
     if (m_priv->m_glx_window)
     {
         X11S(glXDestroyWindow(m_display, m_priv->m_glx_window));
@@ -77 +88 @@
         m_priv->m_gl_window = 0;
     }
 
+    MakeCurrent(false);
+
     if (m_priv->m_glx_context)
     {
         X11S(glXDestroyContext(m_display, m_priv->m_glx_context));
@@ -89 +102 @@
 
 void OpenGLContext::Hide(void)
 {
+    MakeCurrent(true);
     X11S(XUnmapWindow(m_display, m_priv->m_gl_window));
+    MakeCurrent(false);
 }
 
 void OpenGLContext::Show(void)
 {
+    MakeCurrent(true);
     X11S(XMapWindow(m_display, m_priv->m_gl_window));
+    MakeCurrent(false);
 }
 
 // locking ok
@@ -245 +262 @@
         ((has_gl_fbuffer_object_support(m_extensions)) ? kGLExtFBufObj : 0) |
         ((minor >= 3) ? kGLXPBuffer : 0);
 
+    MakeCurrent(true);
     Init2DState();
+    MakeCurrent(false);
 
     return true;
 }
@@ -253 +272 @@
 // locking ok
 bool OpenGLContext::MakeCurrent(bool current)
 {
-    bool ok;
+    bool ok = true;
 
     if (current)
     {
-        if (IsGLXSupported(1,3))
-        {
-            X11S(ok = glXMakeCurrent(m_display,
-                                     m_priv->m_glx_window,
-                                     m_priv->m_glx_context));
-        }
-        else
+        m_lock->lock();
+        if (m_lock_level == 0)
         {
-            X11S(ok = glXMakeCurrent(m_display,
-                                     m_priv->m_gl_window,
-                                     m_priv->m_glx_context));
+            if (IsGLXSupported(1,3))
+            {
+                X11S(ok = glXMakeCurrent(m_display,
+                                         m_priv->m_glx_window,
+                                         m_priv->m_glx_context));
+            }
+            else
+            {
+                X11S(ok = glXMakeCurrent(m_display,
+                                         m_priv->m_gl_window,
+                                         m_priv->m_glx_context));
+            }
         }
+        m_lock_level++;
     }
     else
     {
-        X11S(ok = glXMakeCurrent(m_display, None, NULL));
+        m_lock_level--;
+        if (m_lock_level == 0)
+        {
+            X11S(ok = glXMakeCurrent(m_display, None, NULL));
+        }
+        else if (m_lock_level < 0)
+        {
+            VERBOSE(VB_PLAYBACK, LOC_ERR + "Mis-matched calls to MakeCurrent");
+        }
+        m_lock->unlock();
     }
 
     if (!ok)
-        VERBOSE(VB_PLAYBACK, LOC + "Could not make context current.");
+        VERBOSE(VB_PLAYBACK, LOC_ERR + "Could not make context current.");
 
     return ok;
 }
@@ -298 +331 @@
 // locking ok
 void OpenGLContext::Flush(void)
 {
+    MakeCurrent(true);
     glFlush();
+    MakeCurrent(false);
 }
 
 // locking ok
@@ -359 +394 @@
 // locking ok
 void OpenGLContext::SetupTextureFilters(uint tex, int filt)
 {
+    MakeCurrent(true);
     glBindTexture(GetTextureType(), tex);
     glTexParameteri(GetTextureType(), GL_TEXTURE_MIN_FILTER, filt);
     glTexParameteri(GetTextureType(), GL_TEXTURE_MAG_FILTER, filt);
     glTexParameteri(GetTextureType(), GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GetTextureType(), GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    MakeCurrent(false);
 }
 
 // locking ok
@@ -391 +428 @@
 // locking ok
 void OpenGLContext::DeleteTextures(void)
 {
-    MakeCurrent(true);
-
     vector<GLuint>::iterator it;
     for (it = m_priv->m_textures.begin(); it !=m_priv->m_textures.end(); it++)
         glDeleteTextures(1, &(*(it)));
     m_priv->m_textures.clear();
 
     Flush();
-
-    MakeCurrent(false);
 }
 
 int OpenGLContext::GetTextureType(void) const
@@ -484 +517 @@
 
 void OpenGLContext::BindFragmentProgram(uint fp)
 {
+    MakeCurrent(true);
     gMythGLBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, fp);
+    MakeCurrent(false);
 }
 
 void OpenGLContext::InitFragmentParams(
     uint fp, float a, float b, float c, float d)
 {
+    MakeCurrent(true);
     gMythGLProgramEnvParameter4fARB(
         GL_FRAGMENT_PROGRAM_ARB, fp, a, b, c, d);
+    MakeCurrent(false);
 }
 
 void OpenGLContext::DeletePrograms(void)
 {
-    MakeCurrent(true);
-
     vector<GLuint>::iterator it;
     for (it = m_priv->m_programs.begin(); it != m_priv->m_programs.end(); it++)
         gMythGLDeleteProgramsARB(1, &(*(it)));
     m_priv->m_programs.clear();
 
     Flush();
-
-    MakeCurrent(false);
 }
 
 // locking ok
@@ -619 +652 @@
 
 void OpenGLContext::DeleteFrameBuffers(void)
 {
-    MakeCurrent(true);
-
     vector<GLuint>::iterator it;
     for (it = m_priv->m_framebuffers.begin();
          it != m_priv->m_framebuffers.end(); it++)
@@ -630 +661 @@
     m_priv->m_framebuffers.clear();
 
     Flush();
-
-    MakeCurrent(false);
 }
 
 // locking ok
 void OpenGLContext::BindFramebuffer(uint fb)
 {
+    MakeCurrent(true);
     gMythGLBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
+    MakeCurrent(false);
 }
 
 bool OpenGLContext::IsGLXSupported(
@@ -655 +686 @@
 
 void OpenGLContext::Init2DState(void)
 {
-    MakeCurrent(true);
     glDisable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // for gl osd
     glDisable(GL_DEPTH_TEST);
     glDepthMask(GL_FALSE);
     glDisable(GL_CULL_FACE);
+
     EnableTextures();;
+
     glShadeModel(GL_FLAT);
     glDisable(GL_POLYGON_SMOOTH);
     glDisable(GL_LINE_SMOOTH);
@@ -669 +701 @@
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     glClear(GL_COLOR_BUFFER_BIT);
     glFlush();
-    MakeCurrent(false);
 }
 
 void OpenGLContext::SetViewPort(const QSize &size)
@@ -678 +709 @@
         size.height() == m_viewport.height())
         return;
 
+    MakeCurrent(true);
+
     m_viewport = size;
 
     glViewport(0, 0, size.width(), size.height());
@@ -687 +720 @@
             0, size.height() - 1, 1, -1); // aargh...
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
+
+    MakeCurrent(false);
 }

libs/libmythtv/openglcontext.h

@@ -23 +23 @@
     kGLXPBuffer    = 0x08,
 } GLFeatures;
 
+class OpenGLContext;
+
+class ContextLocker
+{
+    public:
+        ContextLocker(OpenGLContext *ctx);
+        ~ContextLocker();
+
+    private:
+        OpenGLContext *m_ctx;
+};
+
 #ifdef USING_OPENGL
 
 class OpenGLContext
 {
   public:
-    OpenGLContext();
+    OpenGLContext(QMutex *lock);
     ~OpenGLContext();
 
     bool Create(Display *display, Window window, uint screen_num,
@@ -87 +99 @@
     uint            m_ext_supported;
     uint            m_max_tex_size;
     QSize           m_viewport;
+    QMutex         *m_lock;
+    int             m_lock_level;
 };
 
 #else // if !USING_OPENGL
@@ -94 +108 @@
 class OpenGLContext
 {
   public:
-    OpenGLContext() { }
+    OpenGLContext(QMutex*) { }
     ~OpenGLContext() { }
 
     bool Create(Display*, Window, uint, const QSize&) { return false; }

libs/libmythtv/openglvideo.cpp

@@ -53 +53 @@
 
 OpenGLVideo::~OpenGLVideo()
 {
+    ContextLocker ctx_lock(gl_context);
     Teardown();
 }
 
@@ -61 +62 @@
 {
     ShutDownYUV2RGB();
 
-    gl_context->MakeCurrent(true);
-
     for (uint i = 0; i < inputTextures.size(); i++)
         gl_context->DeleteTexture(inputTextures[i]);
     inputTextures.clear();
@@ -83 +82 @@
         }
     }
     filters.clear();
-
-    gl_context->MakeCurrent(false);
 }
 
 // locking ok
@@ -94 +91 @@
                        bool viewport_control, bool osd)
 {
     gl_context            = glcontext;
+    if (!gl_context)
+        return false;
+
+    ContextLocker ctx_lock(gl_context);
+
     actual_video_dim      = videoDim;
     video_dim             = videoDim;
     if (video_dim.height() == 1088)
@@ -347 +349 @@
     VERBOSE(VB_PLAYBACK, LOC + QString("Creating %1 filter.")
             .arg(FilterToString(filter)));
 
-    gl_context->MakeCurrent(true);
-
     OpenGLFilter *temp = new OpenGLFilter();
 
     temp->numInputs = 1;
@@ -405 +405 @@
     VERBOSE(VB_PLAYBACK, QString("Removing %1 filter")
             .arg(FilterToString(filter)));
 
-    gl_context->MakeCurrent(true);
-
     gl_context->DeleteFragmentProgram(filters[filter]->fragmentProgram);
 
     vector<GLuint> temp;
@@ -422 +420 @@
 
     filters.erase(filter);
 
-    gl_context->MakeCurrent(false);
-
     return true;
 }
 
 // locking ok
 bool OpenGLVideo::AddDeinterlacer(const QString &filter)
 {
+    ContextLocker ctx_lock(gl_context);
+
     QString current_deinterlacer = GetDeinterlacer();
 
     if (current_deinterlacer == filter)
@@ -552 +550 @@
 // locking ok
 void OpenGLVideo::UpdateInputFrame(const VideoFrame *frame)
 {
+    ContextLocker ctx_lock(gl_context);
+
     if (frame->width  != actual_video_dim.width()  ||
         frame->height != actual_video_dim.height() ||
         frame->width  < 1 ||
@@ -600 +600 @@
 void OpenGLVideo::UpdateInput(const unsigned char *buf, const int *offsets,
                               uint texture_index, int format, QSize size)
 {
+    ContextLocker ctx_lock(gl_context);
+
     inputUpdated = false;
 
     if (texture_index >= inputTextures.size())
@@ -640 +642 @@
 // TODO shouldn't this take a QSize, not QRect?
 void OpenGLVideo::SetVideoResize(const QRect &rect)
 {
+    ContextLocker ctx_lock(gl_context);
+
     bool abort = ((rect.right()  > video_dim.width())  ||
                   (rect.bottom() > video_dim.height()) ||
                   (rect.width()  > video_dim.width())  ||
@@ -662 +666 @@
 // locking ok
 void OpenGLVideo::DisableVideoResize(void)
 {
+    ContextLocker ctx_lock(gl_context);
+
     videoResize     = false;
     videoResizeRect = QRect(0, 0, 0, 0);
 }
@@ -695 +701 @@
     if (deinterlacing == hardwareDeinterlacing)
         return;
 
+    ContextLocker ctx_lock(gl_context);
+
     VERBOSE(VB_PLAYBACK, LOC + QString("Turning %1 deinterlacing.")
             .arg(deinterlacing ? "on" : "off"));
 
@@ -723 +731 @@
         }
     }
 
-    gl_context->MakeCurrent(true);
     SetFiltering();
-    gl_context->MakeCurrent(false);
 }
 
 // locking ok
@@ -735 +741 @@
     if (inputTextures.empty() || filters.empty())
         return;
 
+    ContextLocker ctx_lock(gl_context);
+
     vector<GLuint> inputs = inputTextures;
     QSize inputsize = inputTextureSize;
     uint  numfilters = filters.size();
@@ -1041 +1049 @@
     if (!useColourControl)
         return -1;
 
+    ContextLocker ctx_lock(gl_context);
+
     int ret = -1;
     switch (attribute)
     {

libs/libmythtv/videoout_xv.cpp

@@ -122 +122 @@
       xv_colorkey(0),   xv_draw_colorkey(false),
       xv_chroma(0),
 
-      gl_context_lock(false), gl_context(NULL),
+      gl_context_lock(true), gl_context(NULL),
       gl_videochain(NULL), gl_pipchain(NULL),
       gl_osdchain(NULL),
 
@@ -219 +219 @@
 
     if (gl_videochain)
     {
-        QMutexLocker locker(&gl_context_lock);
+        ContextLocker ctx_lock(gl_context);
         gl_videochain->SetVideoRect(display_video_rect, video_rect);
     }
 }
@@ -943 +943 @@
 #ifdef USING_OPENGL_VIDEO
     ok = gl_context;
 
-    gl_context_lock.lock();    
+    gl_context_lock.lock();
 
     if (!ok)
     {
-        gl_context = new OpenGLContext();
+        gl_context = new OpenGLContext(&gl_context_lock);
 
         ok = gl_context->Create(
             XJ_disp, XJ_win, XJ_screen_num,
             display_visible_rect.size());
     }
 
+    gl_context_lock.unlock();
+
     if (ok)
     {
+        ContextLocker ctx_lock(gl_context);
         gl_context->Show();
-        gl_context->MakeCurrent(true);
         gl_videochain = new OpenGLVideo();
         ok = gl_videochain->Init(gl_context, db_use_picture_controls,
                                  video_dim, display_visible_rect,
                                  display_video_rect, video_rect, true);
-        gl_context->MakeCurrent(false);
     }
 
-    gl_context_lock.unlock();
-
     if (ok)
     {
+        ContextLocker ctx_lock(gl_context);
         InstallXErrorHandler(XJ_disp);
 
         ok = CreateBuffers(OpenGL);
@@ -994 +994 @@
             if (!m_deintfiltername.isEmpty() &&
                 !m_deintfiltername.contains("opengl"))
             {
-                QMutexLocker locker(&gl_context_lock);
                 gl_videochain->SetSoftwareDeinterlacer(m_deintfiltername);
             }
 
@@ -1413 +1412 @@
 
     if (osd_renderer == "opengl2")
     {
-        QMutexLocker locker(&gl_context_lock);
+        ContextLocker ctx_lock(gl_context);
         gl_use_osd_opengl2 = true;
 
-        gl_context->MakeCurrent(true);
-
         gl_osdchain = new OpenGLVideo();
         if (!gl_osdchain->Init(
                 gl_context, false,
@@ -1435 +1432 @@
         {
             gl_osdchain->SetMasterViewport(gl_videochain->GetViewPort());
         }
-
-        gl_context->MakeCurrent(false);
     }
 
     if (osd_renderer == "chromakey")
@@ -1777 +1772 @@
     if (enable && m_deinterlacing && (OpenGL != VideoOutputSubType()))
         return m_deinterlacing;
 
+    ContextLocker ctx_lock(gl_context);
+
     if (enable)
     {
         if (m_deintfiltername == "")
@@ -1789 +1786 @@
         else if (!m_deintfiltername.contains("opengl"))
         {
             // make sure opengl deinterlacing is disabled
-            gl_context_lock.lock();
             gl_videochain->SetDeinterlacing(false);
-            gl_context_lock.unlock();
 
             if (!m_deintFiltMan || !m_deintFilter)
                 return VideoOutput::SetupDeinterlace(enable);
@@ -1799 +1794 @@
     }
 
     if (gl_videochain)
-    {
-        QMutexLocker locker(&gl_context_lock);
         gl_videochain->SetDeinterlacing(enable);
-    }
 
     m_deinterlacing = enable;
 
@@ -1815 +1807 @@
     (void) interlaced;
     (void) overridefilter;
 
+    ContextLocker ctx_lock(gl_context);
+
     m_deintfiltername = db_vdisp_profile->GetFilteredDeint(overridefilter);
 
     if (!m_deintfiltername.contains("opengl"))
     {
-        gl_context_lock.lock();
         gl_videochain->SetDeinterlacing(false);
-        gl_context_lock.unlock();
 
         gl_videochain->SetSoftwareDeinterlacer(QString::null);
 
@@ -1851 +1843 @@
     if (!gl_videochain)
         return false;
 
-    QMutexLocker locker(&gl_context_lock);
-
     if (m_deinterlacing && !m_deintfiltername.isEmpty()) 
     {
         if (gl_videochain->GetDeinterlacer() != m_deintfiltername)
@@ -2347 +2337 @@
 #endif // USING_XVMC
 
     // OpenGL stuff
-    gl_context_lock.lock();
+    if (gl_context)
+        gl_context->MakeCurrent(true);
 
     if (gl_videochain)
     {
@@ -2366 +2357 @@
     }
 
     if (gl_context)
+    {
         gl_context->Hide();
+        gl_context->MakeCurrent(false);
+    }
 
     gl_use_osd_opengl2 = false;
     gl_pip_ready = false;
     gl_osd_ready = false;
     allowpreviewepg = true;
-
-    gl_context_lock.unlock();
     // end OpenGL stuff
 
     vbuffers.DeleteBuffers();
@@ -2716 +2708 @@
 {
     (void) t;
 
-    QMutexLocker locker(&gl_context_lock);
+    ContextLocker ctx_lock(gl_context);
 
     if (!buffer)
         buffer = vbuffers.GetScratchFrame();
@@ -2727 +2719 @@
     if (buffer->codec != FMT_YV12)
         return;
 
-    gl_context->MakeCurrent(true);
     gl_videochain->PrepareFrame(t, m_deinterlacing, framesPlayed);
 
     if (gl_pip_ready && gl_pipchain)
@@ -2737 +2728 @@
         gl_osdchain->PrepareFrame(t, m_deinterlacing, framesPlayed);
 
     gl_context->Flush();
-    gl_context->MakeCurrent(false);
 
     if (vbuffers.GetScratchFrame() == buffer)
         vbuffers.SetLastShownFrameToScratch();
@@ -3106 +3096 @@
     else if (VideoOutputSubType() == XVideo)
         ShowXVideo(scan);
     else if (VideoOutputSubType() == OpenGL)
-    {
-        QMutexLocker locker(&gl_context_lock);
         gl_context->SwapBuffers();
-    }
 
     X11S(XSync(XJ_disp, False));
 }
@@ -3714 +3701 @@
     (void) filterList;
     (void) pipPlayer;
 
-    QMutexLocker locker(&gl_context_lock);
+    ContextLocker ctx_lock(gl_context);
 
     bool pauseframe = false;
     if (!frame)
@@ -3724 +3711 @@
         pauseframe = true;
     }
 
-    // disable image processing for offscreen rendering
-    gl_context->MakeCurrent(true);
-
     if (filterList)
         filterList->ProcessFrame(frame);
 
@@ -3749 +3733 @@
 
     if (gl_videochain)
         gl_videochain->UpdateInputFrame(frame);
-
-    gl_context->MakeCurrent(false);
 }
 
 void VideoOutputXv::ProcessFrameMem(VideoFrame *frame, OSD *osd,