When performing offscreen rendering on windows, attempt to use a pbuffer context.

src/utils/win/SkWGL_win.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkWGL.h"
 
@@ skipping 57 matching lines @@
                                              float *pfValues) const {
     return fGetPixelFormatAttribfv(hdc, iPixelFormat, iLayerPlane,
                                    nAttributes, piAttributes, pfValues);
 }
 HGLRC SkWGLExtensions::createContextAttribs(HDC hDC,
                                             HGLRC hShareContext,
                                             const int *attribList) const {
     return fCreateContextAttribs(hDC, hShareContext, attribList);
 }
 
+BOOL SkWGLExtensions::swapInterval(int interval) const {
+    return fSwapInterval(interval);
+}
+
+HPBUFFER SkWGLExtensions::createPbuffer(HDC hDC,
+                                        int iPixelFormat,
+                                        int iWidth,
+                                        int iHeight,
+                                        const int *piAttribList) const {
+    return fCreatePbuffer(hDC, iPixelFormat, iWidth, iHeight, piAttribList);
+}
+
+HDC SkWGLExtensions::getPbufferDC(HPBUFFER hPbuffer) const {
+    return fGetPbufferDC(hPbuffer);
+}
+
+int SkWGLExtensions::releasePbufferDC(HPBUFFER hPbuffer, HDC hDC) const {
+    return fReleasePbufferDC(hPbuffer, hDC);
+}
+
+BOOL SkWGLExtensions::destroyPbuffer(HPBUFFER hPbuffer) const {
+    return fDestroyPbuffer(hPbuffer);
+}
+
 namespace {
 
 struct PixelFormat {
     int fFormat;
     int fSampleCnt;
     int fChoosePixelFormatRank;
 };
 
 bool pf_less(const PixelFormat& a, const PixelFormat& b) {
     if (a.fSampleCnt < b.fSampleCnt) {
         return true;
     } else if (b.fSampleCnt < a.fSampleCnt) {
         return false;
     } else if (a.fChoosePixelFormatRank < b.fChoosePixelFormatRank) {
         return true;
     }
     return false;
 }
 }
 
 int SkWGLExtensions::selectFormat(const int formats[],
                                   int formatCount,
                                   HDC dc,
-                                  int desiredSampleCount) {
+                                  int desiredSampleCount) const {
     PixelFormat desiredFormat = {
         0,
         desiredSampleCount,
         0,
     };
     SkTDArray<PixelFormat> rankedFormats;
     rankedFormats.setCount(formatCount);
     for (int i = 0; i < formatCount; ++i) {
         static const int kQueryAttr = SK_WGL_SAMPLES;
         int numSamples;
@@ skipping 88 matching lines @@
 }
 
 #define GET_PROC(NAME, SUFFIX) f##NAME = \
                      (##NAME##Proc) wglGetProcAddress("wgl" #NAME #SUFFIX)
 
 SkWGLExtensions::SkWGLExtensions()
     : fGetExtensionsString(NULL)
     , fChoosePixelFormat(NULL)
     , fGetPixelFormatAttribfv(NULL)
     , fGetPixelFormatAttribiv(NULL)
-    , fCreateContextAttribs(NULL) {
+    , fCreateContextAttribs(NULL)
+    , fSwapInterval(NULL)
+    , fCreatePbuffer(NULL)
+    , fGetPbufferDC(NULL)
+    , fReleasePbufferDC(NULL)
+    , fDestroyPbuffer(NULL)
+ {
     HDC prevDC = wglGetCurrentDC();
     HGLRC prevGLRC = wglGetCurrentContext();
 
     PIXELFORMATDESCRIPTOR dummyPFD;
 
     ZeroMemory(&dummyPFD, sizeof(dummyPFD));
     dummyPFD.nSize = sizeof(dummyPFD);
     dummyPFD.nVersion = 1;
     dummyPFD.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
     dummyPFD.iPixelType = PFD_TYPE_RGBA;
     dummyPFD.cColorBits  = 32;
     dummyPFD.cDepthBits  = 0;
     dummyPFD.cStencilBits = 8;
     dummyPFD.iLayerType = PFD_MAIN_PLANE;
     HWND dummyWND = create_dummy_window();
     if (dummyWND) {
         HDC dummyDC = GetDC(dummyWND);
         int dummyFormat = ChoosePixelFormat(dummyDC, &dummyPFD);
         SetPixelFormat(dummyDC, dummyFormat, &dummyPFD);
         HGLRC dummyGLRC = wglCreateContext(dummyDC);
         SkASSERT(dummyGLRC);
         wglMakeCurrent(dummyDC, dummyGLRC);
 
         GET_PROC(GetExtensionsString, ARB);
         GET_PROC(ChoosePixelFormat, ARB);
         GET_PROC(GetPixelFormatAttribiv, ARB);
         GET_PROC(GetPixelFormatAttribfv, ARB);
         GET_PROC(CreateContextAttribs, ARB);
+        GET_PROC(SwapInterval, EXT);
+        GET_PROC(CreatePbuffer, ARB);
+        GET_PROC(GetPbufferDC, ARB);
+        GET_PROC(ReleasePbufferDC, ARB);
+        GET_PROC(DestroyPbuffer, ARB);
 
         wglMakeCurrent(dummyDC, NULL);
         wglDeleteContext(dummyGLRC);
         destroy_dummy_window(dummyWND);
     }
 
     wglMakeCurrent(prevDC, prevGLRC);
 }
 
-HGLRC SkCreateWGLContext(HDC dc, int msaaSampleCount, SkWGLContextRequest contextType) {
-    SkWGLExtensions extensions;
-    if (!extensions.hasExtension(dc, "WGL_ARB_pixel_format")) {
-        return NULL;
-    }
+///////////////////////////////////////////////////////////////////////////////
 
-    HDC prevDC = wglGetCurrentDC();
-    HGLRC prevGLRC = wglGetCurrentContext();
-    PIXELFORMATDESCRIPTOR pfd;
-
-    int format = 0;
-
-    static const int iAttrs[] = {
+static void get_pixel_formats_to_try(HDC dc, const SkWGLExtensions& extensions,
+                                     bool doubleBuffered, int msaaSampleCount,
+                                     int formatsToTry[2]) {
+    int iAttrs[] = {
         SK_WGL_DRAW_TO_WINDOW, TRUE,
-        SK_WGL_DOUBLE_BUFFER, TRUE,
+        SK_WGL_DOUBLE_BUFFER, (doubleBuffered ? TRUE : FALSE),
         SK_WGL_ACCELERATION, SK_WGL_FULL_ACCELERATION,
         SK_WGL_SUPPORT_OPENGL, TRUE,
         SK_WGL_COLOR_BITS, 24,
         SK_WGL_ALPHA_BITS, 8,
         SK_WGL_STENCIL_BITS, 8,
         0, 0
     };
 
     float fAttrs[] = {0, 0};
 
+    // Get a MSAA format if requested and possible.
     if (msaaSampleCount > 0 &&
         extensions.hasExtension(dc, "WGL_ARB_multisample")) {
         static const int kIAttrsCount = SK_ARRAY_COUNT(iAttrs);
         int msaaIAttrs[kIAttrsCount + 4];
         memcpy(msaaIAttrs, iAttrs, sizeof(int) * kIAttrsCount);
         SkASSERT(0 == msaaIAttrs[kIAttrsCount - 2] &&
                  0 == msaaIAttrs[kIAttrsCount - 1]);
         msaaIAttrs[kIAttrsCount - 2] = SK_WGL_SAMPLE_BUFFERS;
         msaaIAttrs[kIAttrsCount - 1] = TRUE;
         msaaIAttrs[kIAttrsCount + 0] = SK_WGL_SAMPLES;
         msaaIAttrs[kIAttrsCount + 1] = msaaSampleCount;
         msaaIAttrs[kIAttrsCount + 2] = 0;
         msaaIAttrs[kIAttrsCount + 3] = 0;
         unsigned int num;
         int formats[64];
         extensions.choosePixelFormat(dc, msaaIAttrs, fAttrs, 64, formats, &num);
         num = SkTMin(num, 64U);
-        int formatToTry = extensions.selectFormat(formats,
-                                                  num,
-                                                  dc,
-                                                  msaaSampleCount);
-        DescribePixelFormat(dc, formatToTry, sizeof(pfd), &pfd);
-        if (SetPixelFormat(dc, formatToTry, &pfd)) {
-            format = formatToTry;
-        }
+        formatsToTry[0] = extensions.selectFormat(formats, num, dc, msaaSampleCount);
     }
 
-    if (0 == format) {
-        // Either MSAA wasn't requested or creation failed
-        unsigned int num;
-        extensions.choosePixelFormat(dc, iAttrs, fAttrs, 1, &format, &num);
-        DescribePixelFormat(dc, format, sizeof(pfd), &pfd);
-        SkDEBUGCODE(BOOL set =) SetPixelFormat(dc, format, &pfd);
-        SkASSERT(TRUE == set);
-    }
+    // Get a non-MSAA format
+    int* format = -1 == formatsToTry[0] ? &formatsToTry[0] : &formatsToTry[1];
+    unsigned int num;
+    extensions.choosePixelFormat(dc, iAttrs, fAttrs, 1, format, &num);
+}
+
+static HGLRC create_gl_context(HDC dc, SkWGLExtensions extensions, SkWGLContextRequest contextType) {
+    HDC prevDC = wglGetCurrentDC();
+    HGLRC prevGLRC = wglGetCurrentContext();
 
     HGLRC glrc = NULL;
     if (kGLES_SkWGLContextRequest == contextType) {
         if (!extensions.hasExtension(dc, "WGL_EXT_create_context_es2_profile")) {
+            wglMakeCurrent(prevDC, prevGLRC);
             return NULL;
         }
         static const int glesAttribs[] = {
             SK_WGL_CONTEXT_MAJOR_VERSION, 3,
             SK_WGL_CONTEXT_MINOR_VERSION, 0,
             SK_WGL_CONTEXT_PROFILE_MASK,  SK_WGL_CONTEXT_ES2_PROFILE_BIT,
             0,
         };
         glrc = extensions.createContextAttribs(dc, NULL, glesAttribs);
         if (NULL == glrc) {
+            wglMakeCurrent(prevDC, prevGLRC);
             return NULL;
         }
     } else {
         if (kGLPreferCoreProfile_SkWGLContextRequest == contextType &&
             extensions.hasExtension(dc, "WGL_ARB_create_context")) {
             static const int kCoreGLVersions[] = {
                 4, 3,
                 4, 2,
                 4, 1,
                 4, 0,
@@ skipping 16 matching lines @@
             }
         }
     }
 
     if (NULL == glrc) {
         glrc = wglCreateContext(dc);
     }
     SkASSERT(glrc);
 
     wglMakeCurrent(prevDC, prevGLRC);
+
+    // This might help make the context non-vsynced.
+    if (extensions.hasExtension(dc, "WGL_EXT_swap_control")) {
+        extensions.swapInterval(-1);
+    }
     return glrc;
 }
+
+HGLRC SkCreateWGLContext(HDC dc, int msaaSampleCount, SkWGLContextRequest contextType) {
+    SkWGLExtensions extensions;
+    if (!extensions.hasExtension(dc, "WGL_ARB_pixel_format")) {
+        return NULL;
+    }
+
+    BOOL set = FALSE;
+
+    int pixelFormatsToTry[] = { -1, -1 };
+    get_pixel_formats_to_try(dc, extensions, true, msaaSampleCount, pixelFormatsToTry);

[robertphillips, 2014/06/30 20:33:21]

one line ?

[bsalomon, 2014/07/01 13:56:24]

It overflows 100 chars

+    for (int f = 0;
+         !set && -1 != pixelFormatsToTry[f] && f < SK_ARRAY_COUNT(pixelFormatsToTry);
+         ++f) {
+        PIXELFORMATDESCRIPTOR pfd;
+        DescribePixelFormat(dc, pixelFormatsToTry[f], sizeof(pfd), &pfd);
+        set = SetPixelFormat(dc, pixelFormatsToTry[f], &pfd);
+    }
+
+    if (!set) {
+        return NULL;
+    }
+
+    return create_gl_context(dc, extensions, contextType);}
+
+SkWGLPbufferContext* SkWGLPbufferContext::Create(HDC parentDC, int msaaSampleCount,
+                                                 SkWGLContextRequest contextType) {
+    SkWGLExtensions extensions;
+    if (!extensions.hasExtension(parentDC, "WGL_ARB_pixel_format") ||
+        !extensions.hasExtension(parentDC, "WGL_ARB_pbuffer")) {
+        return NULL;
+    }
+
+    // try for single buffer first
+    for (int dblBuffer = 0; dblBuffer < 2; ++dblBuffer) {
+        int pixelFormatsToTry[] = { -1, -1 };
+        get_pixel_formats_to_try(parentDC, extensions, (0 != dblBuffer), msaaSampleCount,
+                                 pixelFormatsToTry);
+        for (int f = 0; -1 != pixelFormatsToTry[f] && f < SK_ARRAY_COUNT(pixelFormatsToTry); ++f) {
+            HPBUFFER pbuf = extensions.createPbuffer(parentDC, pixelFormatsToTry[f], 1, 1, NULL);
+            if (0 != pbuf) {
+                HDC dc = extensions.getPbufferDC(pbuf);
+                if (NULL != dc) {
+                    HGLRC glrc = create_gl_context(dc, extensions, contextType);
+                    if (NULL != glrc) {
+                        return SkNEW_ARGS(SkWGLPbufferContext, (pbuf, dc, glrc));
+                    }
+                    extensions.releasePbufferDC(pbuf, dc);
+                }
+                extensions.destroyPbuffer(pbuf);
+            }
+        }
+    }
+    return NULL;
+}
+
+SkWGLPbufferContext::~SkWGLPbufferContext() {
+    SkASSERT(fExtensions.hasExtension(fDC, "WGL_ARB_pbuffer"));
+    wglDeleteContext(fGLRC);
+    fExtensions.releasePbufferDC(fPbuffer, fDC);
+    fExtensions.destroyPbuffer(fPbuffer);
+}
+
+SkWGLPbufferContext::SkWGLPbufferContext(HPBUFFER pbuffer, HDC dc, HGLRC glrc)
+    : fPbuffer(pbuffer)
+    , fDC(dc)
+    , fGLRC(glrc) {
+}