Skia: Add Command Buffer support to Linux/Mac

src/gpu/gl/command_buffer/SkCommandBufferGLContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include <EGL/egl.h>
 
 #include "SkOnce.h"
 #include "gl/GrGLInterface.h"
 #include "gl/GrGLAssembleInterface.h"
 #include "gl/command_buffer/SkCommandBufferGLContext.h"
+#include "../ports/SkOSLibrary.h"
 
 typedef EGLDisplay (*GetDisplayProc)(EGLNativeDisplayType display_id);
 typedef EGLBoolean (*InitializeProc)(EGLDisplay dpy, EGLint *major, EGLint *minor);
 typedef EGLBoolean (*TerminateProc)(EGLDisplay dpy);
 typedef EGLBoolean (*ChooseConfigProc)(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config);
 typedef EGLBoolean (*GetConfigAttrib)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value);
 typedef EGLSurface (*CreateWindowSurfaceProc)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list);
 typedef EGLSurface (*CreatePbufferSurfaceProc)(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list);
 typedef EGLBoolean (*DestroySurfaceProc)(EGLDisplay dpy, EGLSurface surface);
 typedef EGLContext (*CreateContextProc)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list);
 typedef EGLBoolean (*DestroyContextProc)(EGLDisplay dpy, EGLContext ctx);
 typedef EGLBoolean (*MakeCurrentProc)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
 typedef EGLBoolean (*SwapBuffersProc)(EGLDisplay dpy, EGLSurface surface);
 typedef __eglMustCastToProperFunctionPointerType (*GetProcAddressProc)(const char* procname);
 
 static GetDisplayProc gfGetDisplay = nullptr;
 static InitializeProc gfInitialize = nullptr;
 static TerminateProc gfTerminate = nullptr;
 static ChooseConfigProc gfChooseConfig = nullptr;
 static GetConfigAttrib gfGetConfigAttrib = nullptr;
 static CreateWindowSurfaceProc gfCreateWindowSurface = nullptr;
 static CreatePbufferSurfaceProc gfCreatePbufferSurface = nullptr;
 static DestroySurfaceProc gfDestroySurface = nullptr;
 static CreateContextProc gfCreateContext = nullptr;
 static DestroyContextProc gfDestroyContext = nullptr;
 static MakeCurrentProc gfMakeCurrent = nullptr;
 static SwapBuffersProc gfSwapBuffers = nullptr;
 static GetProcAddressProc gfGetProcAddress = nullptr;
 
-static HMODULE ghLibrary = nullptr;
+static void* gLibrary = nullptr;
 static bool gfFunctionsLoadedSuccessfully = false;
 
 static void load_command_buffer_functions() {
-    if (!ghLibrary) {
-        ghLibrary = LoadLibrary("command_buffer_gles2.dll");
-
-        if (ghLibrary) {
-            gfGetDisplay = (GetDisplayProc)::GetProcAddress(ghLibrary, "eglGetDisplay");
-            gfInitialize = (InitializeProc)::GetProcAddress(ghLibrary, "eglInitialize");
-            gfTerminate = (TerminateProc)::GetProcAddress(ghLibrary, "eglTerminate");
-            gfChooseConfig = (ChooseConfigProc)::GetProcAddress(ghLibrary, "eglChooseConfig");
-            gfGetConfigAttrib = (GetConfigAttrib)::GetProcAddress(ghLibrary, "eglGetConfigAttrib");
-            gfCreateWindowSurface = (CreateWindowSurfaceProc)::GetProcAddress(ghLibrary, "eglCreateWindowSurface");
-            gfCreatePbufferSurface = (CreatePbufferSurfaceProc)::GetProcAddress(ghLibrary, "eglCreatePbufferSurface");
-            gfDestroySurface = (DestroySurfaceProc)::GetProcAddress(ghLibrary, "eglDestroySurface");
-            gfCreateContext = (CreateContextProc)::GetProcAddress(ghLibrary, "eglCreateContext");
-            gfDestroyContext = (DestroyContextProc)::GetProcAddress(ghLibrary, "eglDestroyContext");
-            gfMakeCurrent = (MakeCurrentProc)::GetProcAddress(ghLibrary, "eglMakeCurrent");
-            gfSwapBuffers = (SwapBuffersProc)::GetProcAddress(ghLibrary, "eglSwapBuffers");
-            gfGetProcAddress = (GetProcAddressProc)::GetProcAddress(ghLibrary, "eglGetProcAddress");
+    if (!gLibrary) {
+#if defined _WIN32
+        gLibrary = DynamicLoadLibrary("command_buffer_gles2.dll");
+#else
+        gLibrary = DynamicLoadLibrary("libcommand_buffer_gles2.so");
+#endif // defined _WIN32
+        if (gLibrary) {
+            gfGetDisplay = (GetDisplayProc)GetProcedureAddress(gLibrary, "eglGetDisplay");
+            gfInitialize = (InitializeProc)GetProcedureAddress(gLibrary, "eglInitialize");
+            gfTerminate = (TerminateProc)GetProcedureAddress(gLibrary, "eglTerminate");
+            gfChooseConfig = (ChooseConfigProc)GetProcedureAddress(gLibrary, "eglChooseConfig");
+            gfGetConfigAttrib = (GetConfigAttrib)GetProcedureAddress(gLibrary, "eglGetConfigAttrib");
+            gfCreateWindowSurface = (CreateWindowSurfaceProc)GetProcedureAddress(gLibrary, "eglCreateWindowSurface");
+            gfCreatePbufferSurface = (CreatePbufferSurfaceProc)GetProcedureAddress(gLibrary, "eglCreatePbufferSurface");
+            gfDestroySurface = (DestroySurfaceProc)GetProcedureAddress(gLibrary, "eglDestroySurface");
+            gfCreateContext = (CreateContextProc)GetProcedureAddress(gLibrary, "eglCreateContext");
+            gfDestroyContext = (DestroyContextProc)GetProcedureAddress(gLibrary, "eglDestroyContext");
+            gfMakeCurrent = (MakeCurrentProc)GetProcedureAddress(gLibrary, "eglMakeCurrent");
+            gfSwapBuffers = (SwapBuffersProc)GetProcedureAddress(gLibrary, "eglSwapBuffers");
+            gfGetProcAddress = (GetProcAddressProc)GetProcedureAddress(gLibrary, "eglGetProcAddress");
 
             gfFunctionsLoadedSuccessfully = gfGetDisplay && gfInitialize && gfTerminate &&
                                             gfChooseConfig && gfCreateWindowSurface &&
                                             gfCreatePbufferSurface && gfDestroySurface &&
                                             gfCreateContext && gfDestroyContext && gfMakeCurrent &&
                                             gfSwapBuffers && gfGetProcAddress;
 
         }                        
     }                            
 }
 
 static GrGLFuncPtr command_buffer_get_gl_proc(void* ctx, const char name[]) {
-    GrGLFuncPtr proc = (GrGLFuncPtr) GetProcAddress((HMODULE)ctx, name);
+    GrGLFuncPtr proc = (GrGLFuncPtr) GetProcedureAddress(ctx, name);
     if (proc) {
         return proc;
     }
     if (!gfFunctionsLoadedSuccessfully) {
         return nullptr;
     }
     return gfGetProcAddress(name);
 }
 
 SK_DECLARE_STATIC_ONCE(loadCommandBufferOnce);
 void LoadCommandBufferOnce() {
     SkOnce(&loadCommandBufferOnce, load_command_buffer_functions);
 }
 
 const GrGLInterface* GrGLCreateCommandBufferInterface() {
     LoadCommandBufferOnce();
     if (!gfFunctionsLoadedSuccessfully) {
         return nullptr;
     }
-    return GrGLAssembleGLESInterface(ghLibrary, command_buffer_get_gl_proc);
+    return GrGLAssembleGLESInterface(gLibrary, command_buffer_get_gl_proc);
 }
 
 SkCommandBufferGLContext::SkCommandBufferGLContext()
     : fContext(EGL_NO_CONTEXT)
     , fDisplay(EGL_NO_DISPLAY)
     , fSurface(EGL_NO_SURFACE) {
 
     static const EGLint configAttribs[] = {
         EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
         EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
@@ skipping 155 matching lines @@
     gfGetConfigAttrib(fDisplay, surfaceConfig, EGL_STENCIL_SIZE, &result);
     return result;
 }
 
 int SkCommandBufferGLContext::getSampleCount() {
     EGLint result = 0;
     EGLConfig surfaceConfig = static_cast<EGLConfig>(fConfig);
     gfGetConfigAttrib(fDisplay, surfaceConfig, EGL_SAMPLES, &result);
     return result;
 }