Add support for EGLImage to GrGLInterface

src/gpu/gl/GrGLAssembleInterface.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLAssembleInterface.h"
 #include "GrGLUtil.h"
 
 #define GET_PROC(F) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F)
 #define GET_PROC_SUFFIX(F, S) functions->f ## F = (GrGL ## F ## Proc) get(ctx, "gl" #F #S)
 #define GET_PROC_LOCAL(F) GrGL ## F ## Proc F = (GrGL ## F ## Proc) get(ctx, "gl" #F)
 
+#define GET_EGL_PROC_SUFFIX(F, S) functions->f ## F = (GrEGL ## F ## Proc) get(ctx, "egl" #F #S)
+
 const GrGLInterface* GrGLAssembleInterface(void* ctx, GrGLGetProc get) {
     GET_PROC_LOCAL(GetString);
     if (nullptr == GetString) {
         return nullptr;
     }
 
     const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
     if (nullptr == verStr) {
         return nullptr;
     }
 
     GrGLStandard standard = GrGLGetStandardInUseFromString(verStr);
 
     if (kGLES_GrGLStandard == standard) {
         return GrGLAssembleGLESInterface(ctx, get);
     } else if (kGL_GrGLStandard == standard) {
         return GrGLAssembleGLInterface(ctx, get);
     }
     return nullptr;
 }
 
+static void get_egl_query_and_display(GrEGLQueryStringProc* queryString, GrEGLDisplay* display,
+                                      void* ctx, GrGLGetProc get) {
+    *queryString = (GrEGLQueryStringProc) get(ctx, "eglQueryString");
+    *display = GR_EGL_NO_DISPLAY;
+    if (*queryString) {
+        GrEGLGetCurrentDisplayProc getCurrentDisplay =
+            (GrEGLGetCurrentDisplayProc) get(ctx, "eglGetCurrentDisplay");
+        if (getCurrentDisplay) {
+            *display = getCurrentDisplay();
+        } else {
+            *queryString = nullptr;
+        }
+    }
+}
+
 const GrGLInterface* GrGLAssembleGLInterface(void* ctx, GrGLGetProc get) {
     GET_PROC_LOCAL(GetString);
     GET_PROC_LOCAL(GetStringi);
     GET_PROC_LOCAL(GetIntegerv);
 
     // GetStringi may be nullptr depending on the GL version.
     if (nullptr == GetString || nullptr == GetIntegerv) {
         return nullptr;
     }
 
     const char* versionString = (const char*) GetString(GR_GL_VERSION);
     GrGLVersion glVer = GrGLGetVersionFromString(versionString);
 
     if (glVer < GR_GL_VER(1,5) || GR_GL_INVALID_VER == glVer) {
         // We must have array and element_array buffer objects.
         return nullptr;
     }
 
+    GrEGLQueryStringProc queryString;
+    GrEGLDisplay display;
+    get_egl_query_and_display(&queryString, &display, ctx, get);
     GrGLExtensions extensions;
-    if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv)) {
+    if (!extensions.init(kGL_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,
+                         display)) {
         return nullptr;
     }
 
     GrGLInterface* interface = new GrGLInterface();
     GrGLInterface::Functions* functions = &interface->fFunctions;
 
     GET_PROC(ActiveTexture);
     GET_PROC(AttachShader);
     GET_PROC(BindAttribLocation);
     GET_PROC(BindBuffer);
@@ skipping 395 matching lines @@
         // KHR_debug defines these methods to have no suffix in an OpenGL (not ES) context.
         GET_PROC(DebugMessageControl);
         GET_PROC(DebugMessageInsert);
         GET_PROC(DebugMessageCallback);
         GET_PROC(GetDebugMessageLog);
         GET_PROC(PushDebugGroup);
         GET_PROC(PopDebugGroup);
         GET_PROC(ObjectLabel);
     }
 
+    if (extensions.has("EGL_KHR_image") || extensions.has("EGL_KHR_image_base")) {
+        GET_EGL_PROC_SUFFIX(CreateImage, KHR);
+        GET_EGL_PROC_SUFFIX(DestroyImage, KHR);
+    }
+
     interface->fStandard = kGL_GrGLStandard;
     interface->fExtensions.swap(&extensions);
 
     return interface;
 }
 
 const GrGLInterface* GrGLAssembleGLESInterface(void* ctx, GrGLGetProc get) {
     GET_PROC_LOCAL(GetString);
     if (nullptr == GetString) {
         return nullptr;
     }
 
     const char* verStr = reinterpret_cast<const char*>(GetString(GR_GL_VERSION));
     GrGLVersion version = GrGLGetVersionFromString(verStr);
 
     if (version < GR_GL_VER(2,0)) {
         return nullptr;
     }
 
     GET_PROC_LOCAL(GetIntegerv);
     GET_PROC_LOCAL(GetStringi);
+    GrEGLQueryStringProc queryString;
+    GrEGLDisplay display;
+    get_egl_query_and_display(&queryString, &display, ctx, get);
     GrGLExtensions extensions;
-    if (!extensions.init(kGLES_GrGLStandard, GetString, GetStringi, GetIntegerv)) {
+    if (!extensions.init(kGLES_GrGLStandard, GetString, GetStringi, GetIntegerv, queryString,
+                         display)) {
         return nullptr;
     }
 
     GrGLInterface* interface = new GrGLInterface;
     GrGLInterface::Functions* functions = &interface->fFunctions;
 
     GET_PROC(ActiveTexture);
     GET_PROC(AttachShader);
     GET_PROC(BindAttribLocation);
     GET_PROC(BindBuffer);
@@ skipping 266 matching lines @@
         // APITRACE.
         if (!interface->fFunctions.fDebugMessageControl) {
             extensions.remove("GL_KHR_debug");
         }
     }
 
     if (extensions.has("GL_CHROMIUM_bind_uniform_location")) {
         GET_PROC_SUFFIX(BindUniformLocation, CHROMIUM);
     }
 
+    if (extensions.has("EGL_KHR_image") || extensions.has("EGL_KHR_image_base")) {
+        GET_EGL_PROC_SUFFIX(CreateImage, KHR);
+        GET_EGL_PROC_SUFFIX(DestroyImage, KHR);
+    }
+
     interface->fStandard = kGLES_GrGLStandard;
     interface->fExtensions.swap(&extensions);
 
     return interface;
 }