Bug 1107 - Refine PixelFormat, GLPixelBuffer and DirectDataBufferInt/BufferedImageInt

- PixelFormat
  Refine definition allowing complete format conversion by its attributes
  instead of static 'knowledge'.

  - PixelFormat has_a *new* PixelFormat.Composition

  - PixelFormat.Composition contains all pixel component layout
    information as required for inspection and conversion.
    Component names are enumerated via PixelFormat.CType.

  - PixelFormatUtil.convert(..) utilizes generic conversion
    based on PixelFormat.Composition rather static type mapping.
    However, a int32 RGBA static conversion is still supported for performance.
    Utilizes Bitstream for varying pixel component bit-width.

  - Complete w/ hashCode() and equals(..)

- GLPixelBuffer
  - Take 'pack' mode into account when determine GLPixelAttributes,
    i.e. on GLES pack=true (e.g. glReadPixel) only RGBA is guaranteed to work.
    Hence querying GLPixelAttributes requires the GLProfile, PixelFormat and pack mode.

  - Complete GLPixelAttributes conversions from PixelFormat or GL format/data-type,
    while taking GL data-type into account, as well as pack-mode.

  - Complete w/ hashCode() and equals(..)

  - SingletonGLPixelBufferProvider queries singleton GLPixelBuffer via
      - PixelFormat.Composition hostPixelComp,
      - GLPixelAttributes pixelAttributes,
      - boolean pack
    which comprise a unique key, allowing the implementation to utilize
    a hash map. This is implemented in AWTSingletonGLPixelBufferProvider.
    This allows distinct singleton GLPixelBuffer for different
    host PixelFormat (conversion) and GLPixelAttributes (depending on GLProfile).

  - Removes field 'componentCount' which was 'hacked in' to pass
    information about an optional host memory layout.
    Implementations utilizing conversion, e.g. AWTGLPixelBuffer,
    can implement GLPixelBufferProvider's
      'PixelFormat.Composition getHostPixelComp(final GLProfile glp, final int componentCount)'
    and manage such implementation details, see use-case GLJPanel.

- DirectDataBufferInt/BufferedImageInt: Expose underlying NIO ByteBuffer

- AWTMisc.createCursor(..) uses DirectDataBufferInt.BufferedImageInt exposed
  NIO ByteBuffer, allowing to use generic PixelFormatUtil.convert(..).

1 files changed, 341 insertions, 148 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLPixelBuffer.java b/src/jogl/classes/com/jogamp/opengl/util/GLPixelBuffer.java
index a09321d75..00bbd6ce7 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/GLPixelBuffer.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLPixelBuffer.java
@@ -58,41 +58,100 @@ public class GLPixelBuffer {
         /** Allow {@link GL2ES3#GL_PACK_ROW_LENGTH}, or {@link GL2ES2#GL_UNPACK_ROW_LENGTH}. */
         boolean getAllowRowStride();
 
-        /** Called first to determine {@link GLPixelAttributes}. */
-        GLPixelAttributes getAttributes(GL gl, int componentCount);
+        /**
+         * Returns RGB[A] {@link GLPixelAttributes} matching {@link GL}, {@code componentCount} and {@code pack}.
+         *
+         * @param gl the corresponding current {@link GL} context object
+         * @param componentCount RGBA component count, i.e. 1 (luminance, alpha or red), 3 (RGB) or 4 (RGBA)
+         * @param pack {@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.
+         *             {@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.
+         */
+        GLPixelAttributes getAttributes(GL gl, int componentCount, boolean pack);
+
+        /**
+         * Returns the host {@link PixelFormat.Composition} matching {@link GL} and {@code componentCount}
+         * if required by implementation, otherwise {@code null}.
+         *
+         * @param glp the corresponding current {@link GL} context object
+         * @param componentCount RGBA component count, i.e. 1 (luminance, alpha or red), 3 (RGB) or 4 (RGBA)
+         */
+        PixelFormat.Composition getHostPixelComp(final GLProfile glp, final int componentCount);
 
         /**
          * Allocates a new {@link GLPixelBuffer} object.
          * <p>
-         * Being called to gather the initial {@link GLPixelBuffer},
-         * or a new replacement {@link GLPixelBuffer} if {@link GLPixelBuffer#requiresNewBuffer(GL, int, int, int)}.
-         * </p>
-         * <p>
          * The minimum required {@link Buffer#remaining() remaining} byte size equals to <code>minByteSize</code>, if &gt; 0,
          * otherwise utilize {@link GLBuffers#sizeof(GL, int[], int, int, int, int, int, boolean)}
          * to calculate it.
          * </p>
          *
-         * @param gl the corresponding current GL context object
-         * @param pixelAttributes the desired {@link GLPixelAttributes}
+         * @param gl the corresponding current {@link GL} context object
+         * @param hostPixComp host {@link PixelFormat pixel format}, i.e. of the source or sink depending on {@code pack},
+         *                    e.g. fetched via {@link #getHostPixelComp(GLProfile, int)}.
+         *                    If {@code null}, {@code pixelAttributes} instance maybe used or an exception is thrown,
+         *                    depending on implementation semantics.
+         * @param pixelAttributes the desired {@link GLPixelAttributes}, e.g. fetched via {@link #getAttributes(GL, int, boolean)}
+         * @param pack {@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.
+         *             {@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.
          * @param width in pixels
          * @param height in pixels
          * @param depth in pixels
-         * @param pack true for read mode GPU -> CPU, otherwise false for write mode CPU -> GPU
          * @param minByteSize if &gt; 0, the pre-calculated minimum byte-size for the resulting buffer, otherwise ignore.
+         * @see #getHostPixelComp(GLProfile, int)
+         * @see #getAttributes(GL, int, boolean)
          */
-        GLPixelBuffer allocate(GL gl, GLPixelAttributes pixelAttributes, int width, int height, int depth, boolean pack, int minByteSize);
+        GLPixelBuffer allocate(GL gl, PixelFormat.Composition hostPixComp, GLPixelAttributes pixelAttributes,
+                               boolean pack, int width, int height, int depth, int minByteSize);
     }
 
     /** Single {@link GLPixelBuffer} provider. */
     public static interface SingletonGLPixelBufferProvider extends GLPixelBufferProvider {
-        /** Return the last {@link #allocate(GL, GLPixelAttributes, int, int, int, boolean, int) allocated} {@link GLPixelBuffer} w/ {@link GLPixelAttributes#componentCount}. */
-        GLPixelBuffer getSingleBuffer(GLPixelAttributes pixelAttributes);
         /**
-         * Initializes the single {@link GLPixelBuffer} w/ a given size, if not yet {@link #allocate(GL, GLPixelAttributes, int, int, int, boolean, int) allocated}.
+         * {@inheritDoc}
+         * <p>
+         * Being called to gather the initial {@link GLPixelBuffer},
+         * or a new replacement {@link GLPixelBuffer} if {@link GLPixelBuffer#requiresNewBuffer(GL, int, int, int)}.
+         * </p>
+         */
+        @Override
+        GLPixelBuffer allocate(GL gl, PixelFormat.Composition hostPixComp, GLPixelAttributes pixelAttributes,
+                               boolean pack, int width, int height, int depth, int minByteSize);
+
+        /**
+         * Return the last {@link #allocate(GL, PixelFormat.Composition, GLPixelAttributes, boolean, int, int, int, int) allocated} {@link GLPixelBuffer}
+         * matching the given parameter.
+         * <p>
+         * May return {@code null} if none has been allocated yet.
+         * </p>
+         * <p>
+         * Returned {@link GLPixelBuffer} may be {@link GLPixelBuffer#isValid() invalid}.
+         * </p>
+         * @param hostPixComp host {@link PixelFormat pixel format}, i.e. of the source or sink depending on {@code pack},
+         *                    e.g. fetched via {@link #getHostPixelComp(GLProfile, int)}.
+         *                    If {@code null}, {@code pixelAttributes} instance maybe used or an exception is thrown,
+         *                    depending on implementation semantics.
+         * @param pixelAttributes the desired {@link GLPixelAttributes}, e.g. fetched via {@link #getAttributes(GL, int, boolean)}
+         * @param pack {@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.
+         *             {@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.
+         */
+        GLPixelBuffer getSingleBuffer(PixelFormat.Composition hostPixelComp, GLPixelAttributes pixelAttributes, boolean pack);
+        /**
+         * Initializes the single {@link GLPixelBuffer} w/ a given size,
+         * if not yet {@link #allocate(GL, PixelFormat.Composition, GLPixelAttributes, boolean, int, int, int, int) allocated}.
+         *
+         * @param glp
+         * @param componentCount RGBA component count, i.e. 1 (luminance, alpha or red), 3 (RGB) or 4 (RGBA)
+         * @param pack {@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.
+         *             {@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.
+         * @param width
+         * @param height
+         * @param depth
          * @return the newly initialized single {@link GLPixelBuffer}, or null if already allocated.
          */
-        GLPixelBuffer initSingleton(int componentCount, int width, int height, int depth, boolean pack);
+        GLPixelBuffer initSingleton(GLProfile glp, int componentCount, boolean pack, int width, int height, int depth);
+
+        /** Dispose all resources.*/
+        void dispose();
     }
 
     public static class DefaultGLPixelBufferProvider implements GLPixelBufferProvider {
@@ -110,36 +169,24 @@ public class GLPixelBuffer {
         public boolean getAllowRowStride() { return allowRowStride; }
 
         @Override
-        public GLPixelAttributes getAttributes(final GL gl, final int componentCount) {
-            final GLContext ctx = gl.getContext();
-            final int dFormat, dType;
-
-            if( 1 == componentCount ) {
-                if( gl.isGL3ES3() ) {
-                    // RED is supported on ES3 and >= GL3 [core]; ALPHA is deprecated on core
-                    dFormat = GL2ES2.GL_RED;
-                } else {
-                    // ALPHA is supported on ES2 and GL2, i.e. <= GL3 [core] or compatibility
-                    dFormat = GL.GL_ALPHA;
-                }
-                dType   = GL.GL_UNSIGNED_BYTE;
-            } else if( 3 == componentCount ) {
-                dFormat = GL.GL_RGB;
-                dType   = GL.GL_UNSIGNED_BYTE;
-            } else if( 4 == componentCount ) {
-                final int _dFormat = ctx.getDefaultPixelDataFormat();
-                final int dComps = GLBuffers.componentCount(_dFormat);
-                if( dComps == componentCount ) {
-                    dFormat = _dFormat;
-                    dType   = ctx.getDefaultPixelDataType();
-                } else {
-                    dFormat = GL.GL_RGBA;
-                    dType   = GL.GL_UNSIGNED_BYTE;
-                }
-            } else {
+        public GLPixelAttributes getAttributes(final GL gl, final int componentCount, final boolean pack) {
+            final GLPixelAttributes res = GLPixelAttributes.convert(gl, componentCount, pack);
+            if( null == res ) {
                 throw new GLException("Unsupported componentCount "+componentCount+", contact maintainer to enhance");
+            } else {
+                return res;
             }
-            return new GLPixelAttributes(componentCount, dFormat, dType);
+        }
+
+        /**
+         * {@inheritDoc}
+         * <p>
+         * Returns {@code null}!
+         * </p>
+         */
+        @Override
+        public PixelFormat.Composition getHostPixelComp(final GLProfile glp, final int componentCount) {
+            return null;
         }
 
         /**
@@ -149,13 +196,15 @@ public class GLPixelBuffer {
          * </p>
          */
         @Override
-        public GLPixelBuffer allocate(final GL gl, final GLPixelAttributes pixelAttributes, final int width, final int height, final int depth, final boolean pack, final int minByteSize) {
+        public GLPixelBuffer allocate(final GL gl, final PixelFormat.Composition hostPixComp, final GLPixelAttributes pixelAttributes,
+                                      final boolean pack, final int width, final int height, final int depth, final int minByteSize) {
+            // unused: hostPixComp
             if( minByteSize > 0 ) {
-                return new GLPixelBuffer(pixelAttributes, width, height, depth, pack, Buffers.newDirectByteBuffer(minByteSize), getAllowRowStride());
+                return new GLPixelBuffer(pixelAttributes, pack, width, height, depth, Buffers.newDirectByteBuffer(minByteSize), getAllowRowStride());
             } else {
                 final int[] tmp = { 0 };
-                final int byteSize = GLBuffers.sizeof(gl, tmp, pixelAttributes.bytesPerPixel, width, height, depth, pack);
-                return new GLPixelBuffer(pixelAttributes, width, height, depth, pack, Buffers.newDirectByteBuffer(byteSize), getAllowRowStride());
+                final int byteSize = GLBuffers.sizeof(gl, tmp, pixelAttributes.pfmt.comp.bytesPerPixel(), width, height, depth, pack);
+                return new GLPixelBuffer(pixelAttributes, pack, width, height, depth, Buffers.newDirectByteBuffer(byteSize), getAllowRowStride());
             }
         }
     }
@@ -163,74 +212,190 @@ public class GLPixelBuffer {
     /**
      * Default {@link GLPixelBufferProvider} with {@link GLPixelBufferProvider#getAllowRowStride()} == <code>false</code>,
      * utilizing best match for {@link GLPixelAttributes}
-     * and {@link GLPixelBufferProvider#allocate(GL, GLPixelAttributes, int, int, int, boolean, int) allocating} a {@link ByteBuffer}.
+     * and {@link GLPixelBufferProvider#allocate(GL, PixelFormat.Composition, GLPixelAttributes, boolean, int, int, int, int) allocating} a {@link ByteBuffer}.
      */
     public static final GLPixelBufferProvider defaultProviderNoRowStride = new DefaultGLPixelBufferProvider(false);
 
     /**
      * Default {@link GLPixelBufferProvider} with {@link GLPixelBufferProvider#getAllowRowStride()} == <code>true</code>,
      * utilizing best match for {@link GLPixelAttributes}
-     * and {@link GLPixelBufferProvider#allocate(GL, GLPixelAttributes, int, int, int, boolean, int) allocating} a {@link ByteBuffer}.
+     * and {@link GLPixelBufferProvider#allocate(GL, PixelFormat.Composition, GLPixelAttributes, boolean, int, int, int, int) allocating} a {@link ByteBuffer}.
      */
     public static final GLPixelBufferProvider defaultProviderWithRowStride = new DefaultGLPixelBufferProvider(true);
 
     /** Pixel attributes. */
     public static class GLPixelAttributes {
         /** Undefined instance of {@link GLPixelAttributes}, having componentCount:=0, format:=0 and type:= 0. */
-        public static final GLPixelAttributes UNDEF = new GLPixelAttributes(0, 0, 0, false);
-
-        /** Pixel <i>source</i> component count, i.e. number of meaningful components. */
-        public final int componentCount;
-        /** The OpenGL pixel data format */
-        public final int format;
-        /** The OpenGL pixel data type  */
-        public final int type;
-        /** The OpenGL pixel size in bytes  */
-        public final int bytesPerPixel;
+        public static final GLPixelAttributes UNDEF = new GLPixelAttributes(null, PixelFormat.LUMINANCE, 0, 0, true, false);
 
         /**
-         * Deriving {@link #componentCount} via GL <code>dataFormat</code>, i.e. {@link GLBuffers#componentCount(int)} if &gt; 0.
-         * @param dataFormat GL data format
-         * @param dataType GL data type
+         * Returns the matching {@link PixelFormat} for the given GL format and type if exists,
+         * otherwise returns <code>null</code>.
          */
-        public GLPixelAttributes(final int dataFormat, final int dataType) {
-            this(0 < dataFormat ? GLBuffers.componentCount(dataFormat) : 0, dataFormat, dataType);
+        public static final PixelFormat getPixelFormat(final int glFormat, final int glDataType) {
+            PixelFormat pixFmt = null;
+
+            switch(glFormat) {
+                case GL.GL_ALPHA:
+                case GL.GL_LUMINANCE:
+                case GL2ES2.GL_RED:
+                    pixFmt = PixelFormat.LUMINANCE;
+                    break;
+                case GL.GL_RGB:
+                    switch(glDataType) {
+                        case GL2GL3.GL_UNSIGNED_SHORT_5_6_5_REV:
+                            pixFmt = PixelFormat.RGB565;
+                            break;
+                        case GL.GL_UNSIGNED_SHORT_5_6_5:
+                            pixFmt = PixelFormat.BGR565;
+                            break;
+                        case GL.GL_UNSIGNED_BYTE:
+                            pixFmt = PixelFormat.RGB888;
+                            break;
+                    }
+                    break;
+                case GL.GL_RGBA:
+                    switch(glDataType) {
+                        case GL2GL3.GL_UNSIGNED_SHORT_1_5_5_5_REV:
+                            pixFmt = PixelFormat.RGBA5551;
+                            break;
+                        case GL.GL_UNSIGNED_SHORT_5_5_5_1:
+                            pixFmt = PixelFormat.ABGR1555;
+                            break;
+                        case GL.GL_UNSIGNED_BYTE:
+                            pixFmt = PixelFormat.RGBA8888;
+                            break;
+                        case GL2GL3.GL_UNSIGNED_INT_8_8_8_8:
+                            pixFmt = PixelFormat.ABGR8888;
+                            break;
+                    }
+                    break;
+                case GL2GL3.GL_BGR:
+                    if( GL.GL_UNSIGNED_BYTE == glDataType ) {
+                        pixFmt = PixelFormat.BGR888;
+                    }
+                    break;
+                case GL.GL_BGRA:
+                    switch(glDataType) {
+                        case GL2GL3.GL_UNSIGNED_INT_8_8_8_8:
+                            pixFmt = PixelFormat.ARGB8888;
+                            break;
+                        case GL.GL_UNSIGNED_BYTE:
+                            pixFmt = PixelFormat.BGRA8888;
+                            break;
+                    }
+                    break;
+            }
+            return pixFmt;
         }
+
         /**
-         * Using user specified source {@link #componentCount}.
-         * @param componentCount source component count
-         * @param dataFormat GL data format
-         * @param dataType GL data type
+         * Returns the matching {@link GLPixelAttributes} for the given byte sized RGBA {@code componentCount} and {@link GL} if exists,
+         * otherwise returns {@code null}.
+         *
+         * @param gl the corresponding current {@link GL} context object
+         * @param componentCount RGBA component count, i.e. 1 (luminance, alpha or red), 3 (RGB) or 4 (RGBA)
+         * @param pack {@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.
+         *             {@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.
          */
-        public GLPixelAttributes(final int componentCount, final int dataFormat, final int dataType) {
-            this(componentCount, dataFormat, dataType, true);
+        public static GLPixelAttributes convert(final GL gl, final int componentCount, final boolean pack) {
+            final int dFormat, dType;
+            final boolean glesReadMode = pack && gl.isGLES();
+
+            if( 1 == componentCount && !glesReadMode ) {
+                if( gl.isGL3ES3() ) {
+                    // RED is supported on ES3 and >= GL3 [core]; ALPHA is deprecated on core
+                    dFormat = GL2ES2.GL_RED;
+                } else {
+                    // ALPHA is supported on ES2 and GL2, i.e. <= GL3 [core] or compatibility
+                    dFormat = GL.GL_ALPHA;
+                }
+                dType   = GL.GL_UNSIGNED_BYTE;
+            } else if( 3 == componentCount && !glesReadMode ) {
+                dFormat = GL.GL_RGB;
+                dType   = GL.GL_UNSIGNED_BYTE;
+            } else if( 4 == componentCount || glesReadMode ) {
+                final GLContext ctx = gl.getContext();
+                final int _dFormat = ctx.getDefaultPixelDataFormat();
+                final int dComps = GLBuffers.componentCount(_dFormat);
+                if( dComps == componentCount || 4 == dComps ) { // accept if desired component count or 4 components
+                    dFormat = _dFormat;
+                    dType   = ctx.getDefaultPixelDataType();
+                } else {
+                    dFormat = GL.GL_RGBA;
+                    dType   = GL.GL_UNSIGNED_BYTE;
+                }
+            } else {
+                return null;
+            }
+            return new GLPixelAttributes(dFormat, dType);
         }
 
         /**
-         * Returns the matching {@link GLPixelAttributes} for the given {@link PixelFormat} and {@link GLProfile} if exists,
-         * otherwise returns <code>null</code>.
+         * Returns the matching {@link GLPixelAttributes} for the given {@link GLProfile}, {@link PixelFormat} and {@code pack} if exists,
+         * otherwise returns {@code null}.
+         * @param glp the corresponding {@link GLProfile}
+         * @param pixFmt the to be matched {@link PixelFormat pixel format}
+         * @param pack {@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.
+         *             {@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.
          */
-        public static final GLPixelAttributes convert(final PixelFormat pixFmt, final GLProfile glp) {
+        public static final GLPixelAttributes convert(final GLProfile glp, final PixelFormat pixFmt, final boolean pack) {
+            final int[] df = new int[1];
+            final int[] dt = new int[1];
+            convert(glp, pixFmt, pack, df, dt);
+            if( 0 != df[0] ) {
+                return new GLPixelAttributes(null, pixFmt, df[0], dt[0], true /* not used */, true);
+            }
+            return null;
+        }
+        private static final int convert(final GLProfile glp, final PixelFormat pixFmt, final boolean pack,
+                                         final int[] dfRes, final int[] dtRes) {
+            final boolean glesReadMode = pack && glp.isGLES();
             int df = 0; // format
             int dt = GL.GL_UNSIGNED_BYTE; // data type
             switch(pixFmt) {
                 case LUMINANCE:
-                    if( glp.isGL3ES3() ) {
-                        // RED is supported on ES3 and >= GL3 [core]; ALPHA/LUMINANCE is deprecated on core
-                        df = GL2ES2.GL_RED;
-                    } else {
-                        // ALPHA/LUMINANCE is supported on ES2 and GL2, i.e. <= GL3 [core] or compatibility
-                        df = GL.GL_LUMINANCE;
+                    if( !glesReadMode ) {
+                        if( glp.isGL3ES3() ) {
+                            // RED is supported on ES3 and >= GL3 [core]; ALPHA/LUMINANCE is deprecated on core
+                            df = GL2ES2.GL_RED;
+                        } else {
+                            // ALPHA/LUMINANCE is supported on ES2 and GL2, i.e. <= GL3 [core] or compatibility
+                            df = GL.GL_LUMINANCE;
+                        }
                     }
                     break;
-                case BGR888:
+                case RGB565:
                     if( glp.isGL2GL3() ) {
-                        df = GL2GL3.GL_BGR;
+                        df = GL.GL_RGB; dt = GL2GL3.GL_UNSIGNED_SHORT_5_6_5_REV;
+                    }
+                    break;
+                case BGR565:
+                    if( glp.isGL2GL3() ) {
+                        df = GL.GL_RGB; dt = GL.GL_UNSIGNED_SHORT_5_6_5;
+                    }
+                    break;
+                case RGBA5551:
+                    if( glp.isGL2GL3() ) {
+                        df = GL.GL_RGBA; dt = GL2GL3.GL_UNSIGNED_SHORT_1_5_5_5_REV;
+                    }
+                    break;
+                case ABGR1555:
+                    if( glp.isGL2GL3() ) {
+                        df = GL.GL_RGBA; dt = GL.GL_UNSIGNED_SHORT_5_5_5_1;
                     }
                     break;
                 case RGB888:
-                    df = GL.GL_RGB;
+                    if( !glesReadMode ) {
+                        df = GL.GL_RGB;
+                    }
+                    break;
+                case BGR888:
+                    if( glp.isGL2GL3() ) {
+                        df = GL2GL3.GL_BGR;
+                    }
                     break;
+                case RGBx8888:
                 case RGBA8888:
                     df = GL.GL_RGBA;
                     break;
@@ -239,85 +404,107 @@ public class GLPixelBuffer {
                         df = GL.GL_RGBA; dt = GL2GL3.GL_UNSIGNED_INT_8_8_8_8;
                     }
                     break;
-                case BGRA8888:
-                    df = GL.GL_BGRA;
-                    break;
                 case ARGB8888:
                     if( glp.isGL2GL3() ) {
                         df = GL.GL_BGRA; dt = GL2GL3.GL_UNSIGNED_INT_8_8_8_8;
                     }
                     break;
-                default:
+                case BGRx8888:
+                case BGRA8888:
+                    if( glp.isGL2GL3() ) { // FIXME: or if( !glesReadMode ) ? BGRA n/a on GLES
+                        df = GL.GL_BGRA;
+                    }
                     break;
             }
-            if( 0 != df ) {
-                return new GLPixelAttributes(pixFmt.componentCount, df, dt, true);
-            }
-            return null;
+            dfRes[0] = df;
+            dtRes[0] = dt;
+            return df;
         }
-        private GLPixelAttributes(final int componentCount, final int dataFormat, final int dataType, final boolean checkArgs) {
-            this.componentCount = componentCount;
-            this.format = dataFormat;
-            this.type = dataType;
-            this.bytesPerPixel = ( 0 < dataFormat && 0 < dataType ) ? GLBuffers.bytesPerPixel(dataFormat, dataType) : 0;
-            if( checkArgs ) {
-                if( 0 == componentCount || 0 == format || 0 == type ) {
-                    throw new GLException("Zero components, format and/or type: "+this);
-                }
-                if( 0 == bytesPerPixel ) {
-                    throw new GLException("Zero bytesPerPixel: "+this);
-                }
+
+        /** The OpenGL pixel data format */
+        public final int format;
+        /** The OpenGL pixel data type  */
+        public final int type;
+
+        /** {@link PixelFormat} describing the {@link PixelFormat.Composition component} layout */
+        public final PixelFormat pfmt;
+
+        @Override
+        public final int hashCode() {
+            // 31 * x == (x << 5) - x
+            int hash = pfmt.hashCode();
+            hash = ((hash << 5) - hash) + format;
+            return ((hash << 5) - hash) + type;
+        }
+
+        @Override
+        public final boolean equals(final Object obj) {
+            if(this == obj)  { return true; }
+            if( obj instanceof GLPixelAttributes ) {
+                final GLPixelAttributes other = (GLPixelAttributes) obj;
+                return format == other.format &&
+                       type == other.type &&
+                       pfmt.equals(other.pfmt);
+            } else {
+                return false;
             }
         }
 
         /**
-         * Returns the matching {@link PixelFormat} of this {@link GLPixelAttributes} if exists,
-         * otherwise returns <code>null</code>.
+         * Create a new {@link GLPixelAttributes} instance based on GL format and type.
+         * @param dataFormat GL data format
+         * @param dataType GL data type
+         * @throws GLException if {@link PixelFormat} could not be determined, see {@link #getPixelFormat(int, int)}.
          */
-        public final PixelFormat getPixelFormat() {
-            final PixelFormat pixFmt;
-            // FIXME: Take 'type' into consideration and complete mapping!
-            switch(format) {
-                case GL.GL_ALPHA:
-                case GL.GL_LUMINANCE:
-                case GL2ES2.GL_RED:
-                    pixFmt = PixelFormat.LUMINANCE;
-                    break;
-                case GL.GL_RGB:
-                    pixFmt = PixelFormat.RGB888;
-                    break;
-                case GL.GL_RGBA:
-                    pixFmt = PixelFormat.RGBA8888;
-                    break;
-                case GL2GL3.GL_BGR:
-                    pixFmt = PixelFormat.BGR888;
-                    break;
-                case GL.GL_BGRA:
-                    pixFmt = PixelFormat.BGRA8888;
-                    break;
-                default:
-                    switch( bytesPerPixel ) {
-                        case 1:
-                            pixFmt = PixelFormat.LUMINANCE;
-                            break;
-                        case 3:
-                            pixFmt = PixelFormat.RGB888;
-                            break;
-                        case 4:
-                            pixFmt = PixelFormat.RGBA8888;
-                            break;
-                        default:
-                            pixFmt = null;
-                            break;
-                    }
-                    break;
+        public GLPixelAttributes(final int dataFormat, final int dataType) throws GLException {
+            this(null, null, dataFormat, dataType, true /* not used */, true);
+        }
+
+        /**
+         * Create a new {@link GLPixelAttributes} instance based on {@link GLProfile}, {@link PixelFormat} and {@code pack}.
+         * @param glp the corresponding {@link GLProfile}
+         * @param pixFmt the to be matched {@link PixelFormat pixel format}
+         * @param pack {@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.
+         *             {@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.
+         * @throws GLException if GL format or type could not be determined, see {@link #convert(GLProfile, PixelFormat, boolean)}.
+         */
+        public GLPixelAttributes(final GLProfile glp, final PixelFormat pixFmt, final boolean pack) throws GLException {
+            this(glp, pixFmt, 0, 0, pack, true);
+        }
+
+        private GLPixelAttributes(final GLProfile glp, final PixelFormat pixFmt,
+                                  final int dataFormat, final int dataType, final boolean pack, final boolean checkArgs) throws GLException {
+            if( checkArgs && ( 0 == dataFormat || 0 == dataType ) ) {
+                if( null == pixFmt || null == glp ) {
+                    throw new GLException("Zero format and/or type w/o pixFmt or glp: "+this);
+                }
+                final int[] df = new int[1];
+                final int[] dt = new int[1];
+                if( 0 == convert(glp, pixFmt, pack, df, dt) ) {
+                    throw new GLException("Could not find format and type for "+pixFmt+" and "+glp+", "+this);
+                }
+                this.format = df[0];
+                this.type = dt[0];
+                this.pfmt = pixFmt;
+            } else {
+                this.format = dataFormat;
+                this.type = dataType;
+                this.pfmt = null != pixFmt ? pixFmt : getPixelFormat(dataFormat, dataType);
+                if( null == this.pfmt ) {
+                    throw new GLException("Could not find PixelFormat for format and/or type: "+this);
+                }
+            }
+            if( checkArgs ) {
+                final int bytesPerPixel = GLBuffers.bytesPerPixel(this.format, this.type);
+                if( 0 == bytesPerPixel ) {
+                    throw new GLException("Zero bytesPerPixel: "+this);
+                }
             }
-            return pixFmt;
         }
 
         @Override
         public String toString() {
-            return "PixelAttributes[comp "+componentCount+", fmt 0x"+Integer.toHexString(format)+", type 0x"+Integer.toHexString(type)+", bytesPerPixel "+bytesPerPixel+"]";
+            return "PixelAttributes[fmt 0x"+Integer.toHexString(format)+", type 0x"+Integer.toHexString(type)+", "+pfmt+"]";
         }
     }
 
@@ -339,14 +526,18 @@ public class GLPixelBuffer {
     public final int height;
     /** Depth in pixels. */
     public final int depth;
-    /** Data packing direction. If <code>true</code> for read mode GPU -> CPU, <code>false</code> for write mode CPU -> GPU. */
+    /**
+     * Data packing direction.
+     * <p>{@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.</p>
+     * <p>{@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.</p>
+     */
     public final boolean pack;
     /** Byte size of the buffer. Actually the number of {@link Buffer#remaining()} bytes when passed in ctor. */
     public final int byteSize;
     /**
      * Buffer holding the pixel data. If {@link #rewind()}, it holds <code>byteSize</code> {@link Buffer#remaining()} bytes.
      * <p>
-     * By default the {@link Buffer} is a {@link ByteBuffer}, due to {@link DefProvider#allocate(GL, GLPixelAttributes, int, int, int, boolean, int)}.
+     * By default the {@link Buffer} is a {@link ByteBuffer}, due to {@link DefProvider#allocate(GL, PixelFormat.Composition, GLPixelAttributes, boolean, int, int, int, int)}.
      * However, other {@link GLPixelBufferProvider} may utilize different {@link Buffer} types.
      * </p>
      */
@@ -375,14 +566,16 @@ public class GLPixelBuffer {
 
     /**
      * @param pixelAttributes the desired {@link GLPixelAttributes}
+     * @param pack {@code true} for read mode GPU -> CPU, e.g. {@link GL#glReadPixels(int, int, int, int, int, int, Buffer) glReadPixels}.
+     *             {@code false} for write mode CPU -> GPU, e.g. {@link GL#glTexImage2D(int, int, int, int, int, int, int, int, Buffer) glTexImage2D}.
      * @param width in pixels
      * @param height in pixels
      * @param depth in pixels
-     * @param pack true for read mode GPU -> CPU, otherwise false for write mode CPU -> GPU
      * @param buffer the backing array
      * @param allowRowStride If <code>true</code>, allow row-stride, otherwise not. See {@link #requiresNewBuffer(GL, int, int, int)}.
+     * @param hostPixelComp the host {@link PixelFormat.Composition}
      */
-    public GLPixelBuffer(final GLPixelAttributes pixelAttributes, final int width, final int height, final int depth, final boolean pack, final Buffer buffer, final boolean allowRowStride) {
+    public GLPixelBuffer(final GLPixelAttributes pixelAttributes, final boolean pack, final int width, final int height, final int depth, final Buffer buffer, final boolean allowRowStride) {
         this.pixelAttributes = pixelAttributes;
         this.width = width;
         this.height = height;
@@ -462,7 +655,7 @@ public class GLPixelBuffer {
      * @param newWidth new width in pixels
      * @param newHeight new height in pixels
      * @param newByteSize if &gt; 0, the pre-calculated minimum byte-size for the resulting buffer, otherwise ignore.
-     * @see GLPixelBufferProvider#allocate(GL, GLPixelAttributes, int, int, int, boolean, int)
+     * @see GLPixelBufferProvider#allocate(GL, PixelFormat.Composition, GLPixelAttributes, boolean, int, int, int, int)
      */
     public boolean requiresNewBuffer(final GL gl, final int newWidth, final int newHeight, int newByteSize) {
         if( !isValid() ) {
@@ -470,7 +663,7 @@ public class GLPixelBuffer {
         }
         if( 0 >= newByteSize ) {
             final int[] tmp = { 0 };
-            newByteSize = GLBuffers.sizeof(gl, tmp, pixelAttributes.bytesPerPixel, newWidth, newHeight, 1, true);
+            newByteSize = GLBuffers.sizeof(gl, tmp, pixelAttributes.pfmt.comp.bytesPerPixel(), newWidth, newHeight, 1, true);
         }
         if( allowRowStride ) {
             return byteSize < newByteSize;