[Gnash-commit] [SCM] Gnash branch, openvg, updated. c22cbb7585b050913462ec1ef1d481c6ff3f0c96

[Rob Savoye]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Gnash".

The branch, openvg has been updated
       via  c22cbb7585b050913462ec1ef1d481c6ff3f0c96 (commit)
       via  3aaf0a31ae37b8fe828f67e767b5eb4ab7210200 (commit)
       via  f35f035190e4b97abe22959949d4c270052c60da (commit)
      from  8178d1b50b8354a09bea59289d4e9840e85164be (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit//commit/?id=c22cbb7585b050913462ec1ef1d481c6ff3f0c96


commit c22cbb7585b050913462ec1ef1d481c6ff3f0c96
Author: Rob Savoye <address@hidden>
Date:   Tue Nov 2 14:15:44 2010 -0600

    add new accessors for EGL config data

diff --git a/librender/eglDevice.h b/librender/eglDevice.h
index bc4f2ba..0b7e7c0 100644
--- a/librender/eglDevice.h
+++ b/librender/eglDevice.h
@@ -71,7 +71,8 @@ class EGLDevice
     void printEGLSurface() { return printEGLSurface(_eglSurface); };
     void printEGLSurface(EGLSurface surface);
 
-    // Accessors for the setting needed by higher level code
+    // Accessors for the settings needed by higher level code.
+    // Surface accessors
     EGLint getWidth() {
         EGLint value;
         eglQuerySurface(_eglDisplay, _eglSurface, EGL_WIDTH, &value);
@@ -92,10 +93,89 @@ class EGLDevice
         eglQuerySurface(_eglDisplay, _eglSurface, EGL_HORIZONTAL_RESOLUTION, 
&value);
         return value;
     }
+    bool isSurfaceSingleBuffered() {
+        EGLint value;
+        eglQuerySurface(_eglDisplay, _eglSurface, EGL_RENDER_BUFFER, &value);
+        if (value == EGL_SINGLE_BUFFER) {
+            return true;
+        }
+        return false;
+    }
+    
+    bool isSurfaceBackBuffered() {
+        EGLint value;
+        eglQuerySurface(_eglDisplay, _eglSurface, EGL_RENDER_BUFFER, &value);
+        if (value == EGL_BACK_BUFFER) {
+            return true;
+        }
+        return false;
+    }
+
+    bool isBufferDestroyed() {
+        EGLint value;
+        eglQuerySurface(_eglDisplay, _eglSurface, EGL_SWAP_BEHAVIOR, &value);
+        if (value == EGL_BUFFER_DESTROYED) {
+            return true;
+        }
+        return false;
+    }
+    bool isMultiSample() {
+        EGLint value;
+        eglQuerySurface(_eglDisplay, _eglSurface, EGL_MULTISAMPLE_RESOLVE, 
&value);
+        if (value == EGL_MULTISAMPLE_RESOLVE_BOX) {
+            return true;
+        }
+        return false;
+    }
+    EGLint getSurfaceID() {
+        EGLint value;
+        eglQuerySurface(_eglDisplay, _eglSurface, EGL_CONFIG_ID, &value);
+        return value;
+    }
+
+    // Context accessors
+    EGLint getContextID() {
+        EGLint value;
+        eglQueryContext(_eglDisplay, _eglContext, EGL_CONFIG_ID, &value);
+        return value;
+    }
+    bool supportsClient(rtype_t rtype) {
+        EGLint value;
+        eglQueryContext(_eglDisplay, _eglContext, EGL_CONTEXT_CLIENT_TYPE, 
&value);
+        std::string str;
+        if ((value == EGL_OPENGL_ES_API) && (rtype == EGLDevice::OPENGLES2)) {
+            return true;
+        }
+        if ((value == EGL_OPENGL_ES_API) && (rtype == EGLDevice::OPENGLES1)) {
+            return true;
+        }
+        if ((value == EGL_OPENVG_API) && (rtype == EGLDevice::OPENVG)){
+            return true;
+        }
+        return false;
+    }
+    bool isContextSingleBuffered() {
+        EGLint value;
+        eglQueryContext(_eglDisplay, _eglContext, EGL_RENDER_BUFFER, &value);
+        if (value == EGL_SINGLE_BUFFER) {
+            return true;
+        }
+        return false;
+    }
+    bool isContextBackBuffered() {
+        EGLint value;
+        eglQueryContext(_eglDisplay, _eglContext, EGL_RENDER_BUFFER, &value);
+        if (value == EGL_BACK_BUFFER) {
+            return true;
+        }
+        return false;
+    }
+
+    // Config accessors
     bool supportsRenderer(rtype_t rtype) {
         EGLint value;
-        eglQuerySurface(_eglDisplay, _eglSurface, EGL_HEIGHT, &value);
         eglGetConfigAttrib(_eglDisplay, _eglConfig, EGL_RENDERABLE_TYPE, 
&value);
+        
         if (value > 0) {
             std::string str;
             if ((value & EGL_OPENGL_ES2_BIT) && (rtype == 
EGLDevice::OPENGLES2)) {
@@ -110,24 +190,40 @@ class EGLDevice
         }
         return false;
     }
-    bool isSingleBuffered() {
+    bool isNativeRender() {
         EGLint value;
-        eglQuerySurface(_eglDisplay, _eglSurface, EGL_RENDER_BUFFER, &value);
-        if (value == EGL_SINGLE_BUFFER) {
-            return true;
-        }
-        return false;
+        eglGetConfigAttrib(_eglDisplay, _eglConfig, EGL_NATIVE_RENDERABLE, 
&value);
+        return value;
     }
-    
-    bool isBackBuffered() {
+    EGLint getSamples() {
         EGLint value;
-        eglQuerySurface(_eglDisplay, _eglSurface, EGL_RENDER_BUFFER, &value);
-        if (value == EGL_BACK_BUFFER) {
-            return true;
-        }
-        return false;
+        eglGetConfigAttrib(_eglDisplay, _eglConfig, EGL_SAMPLES, &value);
+        return value;
     }
-
+    EGLint getSampleBuffers() {
+        EGLint value; 
+        eglGetConfigAttrib(_eglDisplay, _eglConfig, EGL_SAMPLE_BUFFERS, 
&value);
+        return value;
+    }
+    EGLint getDepth() {
+        EGLint value;
+        eglGetConfigAttrib(_eglDisplay, _eglConfig, EGL_DEPTH_SIZE, &value);
+        return value;
+    }
+    EGLint getMaxSwapInterval() {
+        EGLint value;
+        eglGetConfigAttrib(_eglDisplay, _eglConfig, EGL_MAX_SWAP_INTERVAL, 
&value);
+        return value;
+    }
+    EGLint getMinSwapInterval() {
+        EGLint value;
+        eglGetConfigAttrib(_eglDisplay, _eglConfig, EGL_MIN_SWAP_INTERVAL, 
&value);
+        return value;
+    }
+    // bool i() {
+    //     EGLint value;
+    //     return value;
+    // }
     
 protected:
     EGLConfig           _eglConfig;

http://git.savannah.gnu.org/cgit//commit/?id=3aaf0a31ae37b8fe828f67e767b5eb4ab7210200


commit 3aaf0a31ae37b8fe828f67e767b5eb4ab7210200
Author: Rob Savoye <address@hidden>
Date:   Tue Nov 2 14:15:13 2010 -0600

    add tests for all the new accessors

diff --git a/librender/test_egl.cpp b/librender/test_egl.cpp
index 85b3667..f52ae7c 100644
--- a/librender/test_egl.cpp
+++ b/librender/test_egl.cpp
@@ -120,6 +120,13 @@ test_egl(EGLDevice &egl, EGLDevice::rtype_t rtype)
         runtest.fail("EGLDevice::getErrorString()");
     }
     
+    // Surface config info tests
+    if (egl.getSurfaceID()) {
+        runtest.pass("EGLDevice::getSurfaceID()");
+    } else {
+        runtest.fail("EGLDevice::getSurfaceID()");
+    }
+    
     if (egl.getWidth()) {
         runtest.pass("EGLDevice::getWidth()");
     } else {
@@ -144,17 +151,87 @@ test_egl(EGLDevice &egl, EGLDevice::rtype_t rtype)
         runtest.fail("EGLDevice::getHorzRes()");
     }
     
-    if (egl.supportsRenderer(EGLDevice::OPENVG)) {
+    if (egl.supportsRenderer(rtype)) {
         runtest.pass("EGLDevice::supportsRenderer()");
     } else {
         runtest.fail("EGLDevice::supportsRenderer()");
     }
     
-    if (egl.isSingleBuffered() != egl.isBackBuffered()) {
-        runtest.pass("EGLDevice::isSingleBuffered()");
+    if (egl.isSurfaceSingleBuffered() != egl.isSurfaceBackBuffered()) {
+        runtest.pass("EGLDevice::isSurface*Buffered()");
+    } else {
+        runtest.fail("EGLDevice::isSurface*Buffered()");
+    }
+
+    if (egl.isBufferDestroyed()) {
+        runtest.pass("EGLDevice::isBufferDestroyed()");
+    } else {
+        runtest.fail("EGLDevice::isBufferDestroyed()");
+    }
+    
+    if (!egl.isMultiSample()) {
+        runtest.pass("EGLDevice::isMultiSample()");
+    } else {
+        runtest.fail("EGLDevice::isMultiSample()");
+    }
+
+    // Context accessor tests
+    if (egl.getContextID()) {
+        runtest.pass("EGLDevice::getContextID()");
+    } else {
+        runtest.fail("EGLDevice::getContextID()");
+    }
+    
+    if (egl.supportsClient(rtype)) {
+        runtest.pass("EGLDevice::supportsClient()");
     } else {
-        runtest.fail("EGLDevice::isSingleBuffered()");
+        runtest.fail("EGLDevice::supportsClient()");
     }
+    
+    if (egl.isContextSingleBuffered() != egl.isContextBackBuffered()) {
+        runtest.pass("EGLDevice::isContext*Buffered()");
+    } else {
+        runtest.fail("EGLDevice::isContext*Buffered()");
+    }
+    
+    if (egl.isNativeRender()) {
+        runtest.pass("EGLDevice::isNativeRender()");
+    } else {
+        runtest.fail("EGLDevice::isNativeRender()");
+    }
+
+    if (egl.getSamples() == 0) {
+        runtest.pass("EGLDevice::getSamples()");
+    } else {
+        runtest.fail("EGLDevice::getSamples()");
+    }
+    
+    if (egl.getSampleBuffers() == 0) {
+        runtest.pass("EGLDevice::getSampleBuffers()");
+    } else {
+        runtest.fail("EGLDevice::getSampleBuffers()");
+    }
+    
+    if (egl.getDepth()) {
+        runtest.pass("EGLDevice::getDepth()");
+    } else {
+        runtest.fail("EGLDevice::getDepth()");
+    }
+    
+    if (egl.getMaxSwapInterval() == 0) {
+        runtest.pass("EGLDevice::getMaxSwapInterval()");
+    } else {
+        runtest.fail("EGLDevice::getMaxSwapInterval()");
+    }
+    
+    if (egl.getMinSwapInterval() == 0) {
+        runtest.pass("EGLDevice::getMinSwapInterval()");
+    } else {
+        runtest.fail("EGLDevice::getMinSwapInterval()");
+    }
+    
+
+
 }
 
 // Local Variables:

http://git.savannah.gnu.org/cgit//commit/?id=f35f035190e4b97abe22959949d4c270052c60da


commit f35f035190e4b97abe22959949d4c270052c60da
Author: Rob Savoye <address@hidden>
Date:   Sun Oct 31 10:12:41 2010 -0600

    use EGL_RENDER_BUFFER to get the right values

diff --git a/librender/eglDevice.h b/librender/eglDevice.h
index 83c981b..bc4f2ba 100644
--- a/librender/eglDevice.h
+++ b/librender/eglDevice.h
@@ -112,7 +112,7 @@ class EGLDevice
     }
     bool isSingleBuffered() {
         EGLint value;
-        eglQuerySurface(_eglDisplay, _eglSurface, EGL_SINGLE_BUFFER, &value);
+        eglQuerySurface(_eglDisplay, _eglSurface, EGL_RENDER_BUFFER, &value);
         if (value == EGL_SINGLE_BUFFER) {
             return true;
         }
@@ -121,7 +121,7 @@ class EGLDevice
     
     bool isBackBuffered() {
         EGLint value;
-        eglQuerySurface(_eglDisplay, _eglSurface, EGL_BACK_BUFFER, &value);
+        eglQuerySurface(_eglDisplay, _eglSurface, EGL_RENDER_BUFFER, &value);
         if (value == EGL_BACK_BUFFER) {
             return true;
         }

-----------------------------------------------------------------------

Summary of changes:
 librender/eglDevice.h  |  128 ++++++++++++++++++++++++++++++++++++++++++------
 librender/test_egl.cpp |   85 ++++++++++++++++++++++++++++++--
 2 files changed, 193 insertions(+), 20 deletions(-)


hooks/post-receive
-- 
Gnash