Bug 942: GLBufferObjectTracker: Tracking GLBufferStorage accurately, synchronized and secure [1/2]

GLBufferSizeTracker becomes GLBufferObjectTracker
and tracks the buffer's data store, GLBufferStorage, accurately, synchronized and secure.

Synchronization is required, since the GLBufferStorage can be
shared across many GLContext on multiple threads.

This requires all GLBufferStorage lifecycle affecting GL functions
to utilize synchronized GLBufferObjectTracker methods
while passing a native GL-func callback.

These GL functions are:
  - glBufferData, glBufferStorage (GL 4.4), glNamedBufferDataEXT
    Creating the GLBufferStorage object
  - glMapBuffer, glMapBufferRange, and their *Named*EXT variants
  - glUnmapBuffer, glUnmapNamedBufferEXT

'glDeleteBuffers' can simply notify the GLBufferObjectTracker

No more HashMap is required to associate the mapped buffer address
to the mapped ByteBuffer.

GLBufferObjectTracker simply utilizes a
   buffer-name (int) -> GLBufferStorage
map.

+++

The security aspect shall be implemented by validating all arguments
whether they match the required GL constraints,
as well as validating tracked states like 'size'.

The following functions will throw an GLException accordingly:
  - glBufferData, glNamedBufferDataEXT
     * @throws GLException if size is less-than zero
     * @throws GLException if a native GL-Error occurs

  - glBufferStorage (GL 4.4)
     * @throws GLException if size is less-or-eqaul zero
     * @throws GLException if a native GL-Error occurs

  - glMapBuffer, and it's *Named*EXT variant
    * @throws GLException if buffer is not bound to target
    * @throws GLException if buffer is not tracked
    * @throws GLException if buffer is already mapped
    * @throws GLException if buffer has invalid store size, i.e. less-than zero

  - glMapBufferRange, and it's *Named*EXT variant
    * @throws GLException if buffer is not bound to target
    * @throws GLException if buffer is not tracked
    * @throws GLException if buffer is already mapped
    * @throws GLException if buffer has invalid store size, i.e. less-than zero
    * @throws GLException if buffer mapping range does not fit, incl. offset

  - glMapBufferRange, and it's *Named*EXT variant
    Only clear mapped buffer reference of GLBufferStorage
    if native unmap was successful.

Further more special error handling shall be applied to:
  - glMapBuffer, and it's *Named*EXT variant,
    glMapBuffer, and it's *Named*EXT variant
    - A zero GLBufferStorage size will avoid a native call and
      returns null
    - A null native mapping result indicating an error will
     not cause a GLException but returns null
     This allows the user to handle this case.

3 files changed, 232 insertions, 11 deletions

diff --git a/src/jogl/classes/javax/media/opengl/GLBase.java b/src/jogl/classes/javax/media/opengl/GLBase.java
index a19a99196..3ac12f0a1 100644
--- a/src/jogl/classes/javax/media/opengl/GLBase.java
+++ b/src/jogl/classes/javax/media/opengl/GLBase.java
@@ -505,26 +505,97 @@ public interface GLBase {
    public void glDepthRange(double zNear, double zFar);
 
    /**
-    * @param target a GL buffer (VBO) target as used in {@link GL#glBindBuffer(int, int)}, ie {@link GL#GL_ELEMENT_ARRAY_BUFFER}, {@link GL#GL_ARRAY_BUFFER}, ..
-    * @return the GL buffer (VBO) name bound to a target via {@link GL#glBindBuffer(int, int)} or 0 if unbound.
+    * @deprecated Avoid original GL API namespace conflict. Use {@link #getBoundBuffer(int)}
     */
    public int glGetBoundBuffer(int target);
+   /**
+    * @param target a GL buffer (VBO) target as used in {@link GL#glBindBuffer(int, int)}, ie {@link GL#GL_ELEMENT_ARRAY_BUFFER}, {@link GL#GL_ARRAY_BUFFER}, ..
+    * @return the GL buffer name bound to a target via {@link GL#glBindBuffer(int, int)} or 0 if unbound.
+    * @see #getBufferStorage(int)
+    */
+   public int getBoundBuffer(int target);
 
    /**
-    * @param buffer a GL buffer name, generated with {@link GL#glGenBuffers(int, int[], int)} and used in {@link GL#glBindBuffer(int, int)}, {@link GL#glBufferData(int, long, java.nio.Buffer, int)} or {@link GL2#glNamedBufferDataEXT(int, long, java.nio.Buffer, int)} for example.
-    * @return the size of the given GL buffer
+    * @deprecated Use {@link #getBufferStorage(int)}.
     */
-   public long glGetBufferSize(int buffer);
+   public long glGetBufferSize(int bufferName);
+   /**
+    * @param bufferName a GL buffer name, generated with e.g. {@link GL#glGenBuffers(int, int[], int)} and used in {@link GL#glBindBuffer(int, int)}, {@link GL#glBufferData(int, long, java.nio.Buffer, int)} or {@link GL2#glNamedBufferDataEXT(int, long, java.nio.Buffer, int)}.
+    * @return the size of the given GL buffer storage, see {@link GLBufferStorage}
+    * @see #getBoundBuffer(int)
+    */
+   public GLBufferStorage getBufferStorage(int bufferName);
 
    /**
-    * @return true if a VBO is bound to {@link GL#GL_ARRAY_BUFFER} via {@link GL#glBindBuffer(int, int)}, otherwise false
+    * Returns the {@link GLBufferStorage} instance as mapped via OpenGL's native {@link GL#glMapBuffer(int, int) glMapBuffer(..)} implementation.
+    * <p>
+    * Throws a {@link GLException} if GL-function constraints are not met.
+    * </p>
+    * <p>
+    * {@link GL#glMapBuffer(int, int)} wrapper calls this method and returns {@link GLBufferStorage#getMappedBuffer()}.
+    * </p>
+    * <p>
+    * A zero {@link GLBufferStorage#getSize()} will avoid a native call and returns the unmapped {@link GLBufferStorage}.
+    * </p>
+    * <p>
+    * A null native mapping result indicating an error will
+    * not cause a GLException but returns the unmapped {@link GLBufferStorage}.
+    * This allows the user to handle this case.
+    * </p>
+    * @param target denotes the buffer via it's bound target
+    * @param access the mapping access mode
+    * @throws GLException if buffer is not bound to target
+    * @throws GLException if buffer is not tracked
+    * @throws GLException if buffer is already mapped
+    * @throws GLException if buffer has invalid store size, i.e. less-than zero
+    */
+   public GLBufferStorage mapBuffer(int target, int access) throws GLException;
+
+   /**
+    * Returns the {@link GLBufferStorage} instance as mapped via OpenGL's native {@link GL#glMapBufferRange(int, long, long, int) glMapBufferRange(..)} implementation.
+    * <p>
+    * Throws a {@link GLException} if GL-function constraints are not met.
+    * </p>
+    * <p>
+    * {@link GL#glMapBufferRange(int, long, long, int)} wrapper calls this method and returns {@link GLBufferStorage#getMappedBuffer()}.
+    * </p>
+    * <p>
+    * A zero {@link GLBufferStorage#getSize()} will avoid a native call and returns the unmapped {@link GLBufferStorage}.
+    * </p>
+    * <p>
+    * A null native mapping result indicating an error will
+    * not cause a GLException but returns the unmapped {@link GLBufferStorage}.
+    * This allows the user to handle this case.
+    * </p>
+    * @param target denotes the buffer via it's bound target
+    * @param offset offset of the mapped buffer's storage
+    * @param length length of the mapped buffer's storage
+    * @param access the mapping access mode
+    * @throws GLException if buffer is not bound to target
+    * @throws GLException if buffer is not tracked
+    * @throws GLException if buffer is already mapped
+    * @throws GLException if buffer has invalid store size, i.e. less-than zero
+    * @throws GLException if buffer mapping range does not fit, incl. offset
+    */
+   public GLBufferStorage mapBufferRange(final int target, final long offset, final long length, final int access) throws GLException;
+
+   /**
+    * @deprecated Avoid original GL API namespace conflict. Use {@link #isVBOArrayBound()}
     */
    public boolean glIsVBOArrayBound();
+   /**
+    * @return true if a VBO is bound to {@link GL#GL_ARRAY_BUFFER} via {@link GL#glBindBuffer(int, int)}, otherwise false
+    */
+   public boolean isVBOArrayBound();
 
    /**
-    * @return true if a VBO is bound to {@link GL#GL_ELEMENT_ARRAY_BUFFER} via {@link GL#glBindBuffer(int, int)}, otherwise false
+    * @deprecated Avoid original GL API namespace conflict. Use {@link #isVBOElementArrayBound()}
     */
    public boolean glIsVBOElementArrayBound();
+   /**
+    * @return true if a VBO is bound to {@link GL#GL_ELEMENT_ARRAY_BUFFER} via {@link GL#glBindBuffer(int, int)}, otherwise false
+    */
+   public boolean isVBOElementArrayBound();
 
    /**
     * Return the framebuffer name bound to this context,
diff --git a/src/jogl/classes/javax/media/opengl/GLBufferStorage.java b/src/jogl/classes/javax/media/opengl/GLBufferStorage.java
new file mode 100644
index 000000000..929ecf60a
--- /dev/null
+++ b/src/jogl/classes/javax/media/opengl/GLBufferStorage.java
@@ -0,0 +1,150 @@
+/**
+ * Copyright 2014 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+package javax.media.opengl;
+
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+
+/**
+ * OpenGL buffer storage object reflecting it's
+ * <ul>
+ *   <li>storage size</li>
+ *   <li>storage memory if mapped</li>
+ *   <li>mutable usage or immutable flags</li>
+ * </ul>
+ * <p>
+ * Buffer storage is created via:
+ * <ul>
+ *   <li><code>glBufferStorage</code> - storage creation with target</li>
+ *   <li>{@link GL#glBufferData(int, long, java.nio.Buffer, int)} - storage recreation with target</li>
+ *   <li>{@link GL2#glNamedBufferDataEXT(int, long, java.nio.Buffer, int)} - storage recreation, direct</li>
+ * </ul>
+ * Note that storage <i>recreation</i> as mentioned above also invalidate a previous storage instance,
+ * i.e. disposed the buffer's current storage if exist and attaches a new storage instance.
+ * </p>
+ * <p>
+ * Buffer storage is disposed via:
+ * <ul>
+ *   <li>{@link GL#glDeleteBuffers(int, IntBuffer)} - explicit, direct, via {@link #notifyBuffersDeleted(int, IntBuffer)} or {@link #notifyBuffersDeleted(int, int[], int)}</li>
+ *   <li>{@link GL#glBufferData(int, long, java.nio.Buffer, int)} - storage recreation via target</li>
+ *   <li>{@link GL2#glNamedBufferDataEXT(int, long, java.nio.Buffer, int)} - storage recreation, direct</li>
+ * </ul>
+ * </p>
+ * <p>
+ * GL buffer storage is mapped via
+ * <ul>
+ *
+ *   <li>{@link GL#mapBuffer(int, int)}</li>
+ *   <li>{@link GL#mapBufferRange(int, long, long, int)}</li>
+ *   <li>{@link GL2#mapNamedBuffer(int, int)}</li>
+ *   <li>{@link GL2#mapNamedBufferRange(int, long, long, int)}</li>
+ * </ul>
+ * </p>
+ * <p>
+ * GL buffer storage is unmapped via
+ * <ul>
+ *   <li>{@link GL#glUnmapBuffer(int)} - explicit via target</li>
+ *   <li>{@link GL2#glUnmapNamedBufferEXT(int)} - explicit direct</li>
+ *   <li>{@link GL#glBufferData(int, long, java.nio.Buffer, int)} - storage recreation via target</li>
+ *   <li>{@link GL2#glNamedBufferDataEXT(int, long, java.nio.Buffer, int)} - storage recreation, direct</li>
+ *   <li>{@link GL#glDeleteBuffers(int, IntBuffer)} - buffer deletion</li>
+ * </ul>
+ * </p>
+ */
+public abstract class GLBufferStorage {
+        private final int name;
+        private final long size;
+        private final int mutableUsage;
+        private final int immutableFlags;
+        protected ByteBuffer mappedBuffer;
+
+        protected GLBufferStorage(final int name, final long size, final int mutableUsage, final int immutableFlags) {
+            this.name = name;
+            this.size = size;
+            this.mutableUsage = mutableUsage;
+            this.immutableFlags = immutableFlags;
+            this.mappedBuffer = null;
+        }
+
+        /** Return the buffer name */
+        public final int getName() { return name; }
+
+        /** Return the buffer's storage size. */
+        public final long getSize() { return size; }
+
+        /**
+         * Returns <code>true</code> if buffer's storage is mutable, i.e.
+         * created via {@link GL#glBufferData(int, long, java.nio.Buffer, int)}.
+         * <p>
+         * Returns <code>false</code> if buffer's storage is immutable, i.e.
+         * created via <code>glBufferStorage</code>. FIXME: Add GL 4.4 support!
+         * </p>
+         * @return
+         */
+        public final boolean isMutableStorage() { return 0 != mutableUsage; }
+
+        /**
+         * Returns the mutable storage usage or 0 if storage is not {@link #isMutableStorage() mutable}.
+         */
+        public final int getMutableUsage() { return mutableUsage; }
+
+        /**
+         * Returns the immutable storage flags, invalid if storage is {@link #isMutableStorage() mutable}.
+         */
+        public final int getImmutableFlags() { return immutableFlags; }
+
+        /**
+         * Returns the mapped ByteBuffer, or null if not mapped.
+         * Mapping may occur via:
+         * <ul>
+         *   <li>{@link GL#glMapBuffer(int, int)}</li>
+         *   <li>{@link GL#glMapBufferRange(int, long, long, int)}</li>
+         *   <li>{@link GL2#glMapNamedBufferEXT(int, int)}</li>
+         *   <li>{@link GL2#glMapNamedBufferRangeEXT(int, long, long, int)}
+         * </ul>
+         */
+        public final ByteBuffer getMappedBuffer() { return mappedBuffer; }
+
+        public final String toString() {
+            return toString(false);
+        }
+        public final String toString(final boolean skipMappedBuffer) {
+            final String s0;
+            if( isMutableStorage() ) {
+                s0 = String.format("%s[name %s, size %d, mutable usage 0x%X", msgClazzName, name, size, mutableUsage);
+            } else {
+                s0 = String.format("%s[name %s, size %d, immutable flags 0x%X", msgClazzName, name, size, immutableFlags);
+            }
+            if(skipMappedBuffer) {
+                return s0+"]";
+            } else {
+                return s0+", mapped "+mappedBuffer+"]";
+            }
+        }
+        private final String msgClazzName = "GLBufferStorage";
+}
diff --git a/src/jogl/classes/javax/media/opengl/GLContext.java b/src/jogl/classes/javax/media/opengl/GLContext.java
index bec62c30d..0b0ed8e0d 100644
--- a/src/jogl/classes/javax/media/opengl/GLContext.java
+++ b/src/jogl/classes/javax/media/opengl/GLContext.java
@@ -1622,8 +1622,8 @@ public abstract class GLContext {
             final Integer valI = deviceVersionAvailable.get(key);
             if(null != valI) {
                 final int bits32 = valI.intValue();
-                final int major = ( bits32 & 0xFF000000 ) >> 24 ;
-                final int minor = ( bits32 & 0x00FF0000 ) >> 16 ;
+                final int major = ( bits32 & 0xFF000000 ) >>> 24 ;
+                final int minor = ( bits32 & 0x00FF0000 ) >>> 16 ;
                 final int ctp   = ( bits32 & 0x0000FFFF )       ;
                 sb.append(GLContext.getGLVersion(major, minor, ctp, null));
             } else {
@@ -1668,10 +1668,10 @@ public abstract class GLContext {
     final int bits32 = valI.intValue();
 
     if(null!=major) {
-        major[0] = ( bits32 & 0xFF000000 ) >> 24 ;
+        major[0] = ( bits32 & 0xFF000000 ) >>> 24 ;
     }
     if(null!=minor) {
-        minor[0] = ( bits32 & 0x00FF0000 ) >> 16 ;
+        minor[0] = ( bits32 & 0x00FF0000 ) >>> 16 ;
     }
     if(null!=ctp) {
         ctp[0]   = ( bits32 & 0x0000FFFF )       ;