Bug 935: NEWT PointerIcon: Utilize Toolkit Agnostic PixelFormat and Conversion Utilities (Allowing 'arbitrary' PointerIcon data input)

Commit fe28bc125429b38cdcd016746081f4a6d521c6fd added the notion of toolkit agnostic PixelFormat and conversion utilities,
utilized and further tested by this patch.

+++

- PointerIcon is a PixelRectangle
  and hence holds the decoded data.
  This allows on-the-fly conversion if required
  as well as recreation w/o PNG re-decoding.

- Using array-backed PointerIcon data where possible,
  allowing better performance when converting PixelFormat etc.

- NEWT Display adds 'createPointerIcon(final IOUtil.ClassResources pngResource...'
  method to support agnostic PointerIcon creation.

- NEWT Display adds methods to allow users to avoid PixelFormat and
  Buffer NIO type forced conversion:
    - PixelFormat getNativePointerIconPixelFormat()
    - boolean getNativePointerIconForceDirectNIO()

+++

PNGImage -> PNGPixelRect
  Deleted: com.jogamp.opengl.util.texture.spi.PNGImage
  Added:   com.jogamp.opengl.util.PNGPixelRect

  (We hope nobody was using PNGImage directly since it was a service-plugin for TextureIO)

  PNGPixelRect is a PixelRectangle

  PNGPixelRect actually is implemented OpenGL agnostic,
  however - since our PNGJ support lives under package 'jogamp.opengl.util.pngj'
  it cannot be moved up (yet).

  PNGPixelRect now handles all PixelFormat for the target format
  and also added support for grayscale+alpha (2 channels).
  The latter is force-converted to RGB* - similar to paletted.

  Further more, PNGPixelRect allows simply passing an OutputStream to write the PNG data.

  Used by: TextureIO and NEWT

+++

- OffscreenSurfaceLayer's setCursor(..) uses the agnostic PixelRectangle
  instead of a PNG resource.

- AWTMisc uses the PixelRectangle to produce the AWT Cursor
  and converts it to the required format.
  Hence same pixels are used for NEWT and AWT pointer/cursor icon.

- TestGearsES2Newt and NewtAWTReparentingKeyAdapter 'tests'
  iterate over 3 custom PointerIcon when pressed 'c'.

- JOGLNewtAppletBase uses the new custom PointerIcon
  'newt/data/crosshair-lumina-trans-32x32.png', which is included in NEWT (213 bytes only).

-

3 files changed, 359 insertions, 358 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/PNGPixelRect.java b/src/jogl/classes/com/jogamp/opengl/util/PNGPixelRect.java
new file mode 100644
index 000000000..1bbc12f32
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/PNGPixelRect.java
@@ -0,0 +1,335 @@
+/**
+ * Copyright 2012 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 com.jogamp.opengl.util;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+
+import javax.media.nativewindow.util.Dimension;
+import javax.media.nativewindow.util.DimensionImmutable;
+import javax.media.nativewindow.util.PixelFormat;
+import javax.media.nativewindow.util.PixelRectangle;
+import javax.media.nativewindow.util.PixelFormatUtil;
+
+import jogamp.opengl.Debug;
+import jogamp.opengl.util.pngj.ImageInfo;
+import jogamp.opengl.util.pngj.ImageLine;
+import jogamp.opengl.util.pngj.ImageLineHelper;
+import jogamp.opengl.util.pngj.PngReader;
+import jogamp.opengl.util.pngj.PngWriter;
+import jogamp.opengl.util.pngj.chunks.PngChunkPLTE;
+import jogamp.opengl.util.pngj.chunks.PngChunkTRNS;
+import jogamp.opengl.util.pngj.chunks.PngChunkTextVar;
+
+import com.jogamp.common.nio.Buffers;
+import com.jogamp.common.util.IOUtil;
+
+public class PNGPixelRect extends PixelRectangle.GenericPixelRect {
+    private static final boolean DEBUG = Debug.debug("PNG");
+
+    /**
+     * Reads a PNG image from the specified InputStream.
+     * <p>
+     * Implicitly converts the image to match the desired:
+     * <ul>
+     *   <li>{@link PixelFormat}, see {@link #getPixelformat()}</li>
+     *   <li><code>destStrideInBytes</code>, see {@link #getStride()}</li>
+     *   <li><code>destIsGLOriented</code>, see {@link #isGLOriented()}</li>
+     * </ul>
+     * </p>
+     *
+     * @param in input stream
+     * @param destFmt desired destination {@link PixelFormat} incl. conversion, maybe <code>null</code> to use source {@link PixelFormat}
+     * @param destDirectBuffer if true, using a direct NIO buffer, otherwise an array backed buffer
+     * @param destMinStrideInBytes used if greater than PNG's stride, otherwise using PNG's stride. Stride is width * bytes-per-pixel.
+     * @param destIsGLOriented
+     * @return the newly created PNGPixelRect instance
+     * @throws IOException
+     */
+    public static PNGPixelRect read(final InputStream in,
+                                    final PixelFormat ddestFmt, final boolean destDirectBuffer, final int destMinStrideInBytes,
+                                    final boolean destIsGLOriented) throws IOException {
+        final PngReader pngr = new PngReader(new BufferedInputStream(in), null);
+        final ImageInfo imgInfo = pngr.imgInfo;
+        final PngChunkPLTE plte = pngr.getMetadata().getPLTE();
+        final PngChunkTRNS trns = pngr.getMetadata().getTRNS();
+        final boolean indexed = imgInfo.indexed;
+        final boolean hasAlpha = indexed ? ( trns != null ) : imgInfo.alpha ;
+
+        if(DEBUG) {
+            System.err.println("PNGPixelRect: "+imgInfo);
+        }
+        final int channels = indexed ? ( hasAlpha ? 4 : 3 ) : imgInfo.channels ;
+        final boolean isGrayAlpha = 2 == channels && imgInfo.greyscale && imgInfo.alpha;
+        if ( ! ( 1 == channels || 3 == channels || 4 == channels || isGrayAlpha ) ) {
+            throw new RuntimeException("PNGPixelRect can only handle Lum/RGB/RGBA [1/3/4 channels] or Lum+A (GA) images for now. Channels "+channels + " Paletted: " + indexed);
+        }
+        final int bytesPerPixel = indexed ? channels : imgInfo.bytesPixel ;
+        if ( ! ( 1 == bytesPerPixel || 3 == bytesPerPixel || 4 == bytesPerPixel || isGrayAlpha ) ) {
+            throw new RuntimeException("PNGPixelRect can only handle Lum/RGB/RGBA [1/3/4 bpp] images for now. BytesPerPixel "+bytesPerPixel);
+        }
+        if( channels != bytesPerPixel ) {
+            throw new RuntimeException("PNGPixelRect currently only handles Channels [1/3/4] == BytePerPixel [1/3/4], channels: "+channels+", bytesPerPixel "+bytesPerPixel);
+        }
+        final int width = imgInfo.cols;
+        final int height = imgInfo.rows;
+        final double dpiX, dpiY;
+        {
+            final double[] dpi = pngr.getMetadata().getDpi();
+            dpiX = dpi[0];
+            dpiY = dpi[1];
+        }
+        final PixelFormat srcFmt;
+        if ( indexed ) {
+            if ( hasAlpha ) {
+                srcFmt = PixelFormat.RGBA8888;
+            } else {
+                srcFmt = PixelFormat.RGB888;
+            }
+        } else {
+            switch( channels ) {
+                case 1: srcFmt = PixelFormat.LUMINANCE; break;
+                case 2: srcFmt = isGrayAlpha ? PixelFormat.LUMINANCE : null; break;
+                case 3: srcFmt = PixelFormat.RGB888; break;
+                case 4: srcFmt = PixelFormat.RGBA8888; break;
+                default: srcFmt = null;
+            }
+            if( null == srcFmt ) {
+                throw new InternalError("XXX: channels: "+channels+", bytesPerPixel "+bytesPerPixel);
+            }
+        }
+        final PixelFormat destFmt;
+        if( null == ddestFmt ) {
+            if( isGrayAlpha ) {
+                destFmt = PixelFormat.BGRA8888; // save alpha value on gray-alpha
+            } else {
+                destFmt = srcFmt; // 1:1
+            }
+        } else {
+            destFmt = ddestFmt; // user choice
+        }
+        final int destStrideInBytes = Math.max(destMinStrideInBytes, destFmt.bytesPerPixel() * width);
+        final ByteBuffer destPixels = destDirectBuffer ? Buffers.newDirectByteBuffer(destStrideInBytes * height) :
+                                                         ByteBuffer.allocate(destStrideInBytes * height);
+        {
+            final int reqBytes = destStrideInBytes * height;
+            if( destPixels.limit() < reqBytes ) {
+                throw new IndexOutOfBoundsException("Dest buffer has insufficient bytes left, needs "+reqBytes+": "+destPixels);
+            }
+        }
+        final boolean vert_flip = destIsGLOriented;
+
+        int[] rgbaScanline = indexed ? new int[width * channels] : null;
+        if(DEBUG) {
+            System.err.println("PNGPixelRect: indexed "+indexed+", alpha "+hasAlpha+", grayscale "+imgInfo.greyscale+", channels "+channels+"/"+imgInfo.channels+
+                               ", bytesPerPixel "+bytesPerPixel+"/"+imgInfo.bytesPixel+
+                               ", grayAlpha "+isGrayAlpha+", pixels "+width+"x"+height+", dpi "+dpiX+"x"+dpiY+", format "+srcFmt);
+            System.err.println("PNGPixelRect: destFormat "+destFmt+" ("+ddestFmt+", bytesPerPixel "+destFmt.bytesPerPixel()+", fast-path "+(destFmt==srcFmt)+"), destDirectBuffer "+destDirectBuffer+", destIsGLOriented (flip) "+destIsGLOriented);
+            System.err.println("PNGPixelRect: destStrideInBytes "+destStrideInBytes+" (destMinStrideInBytes "+destMinStrideInBytes+")");
+        }
+
+        for (int row = 0; row < height; row++) {
+            final ImageLine l1 = pngr.readRow(row);
+            int lineOff = 0;
+            int dataOff = vert_flip ? ( height - 1 - row ) * destStrideInBytes : row * destStrideInBytes;
+            if( indexed ) {
+                for (int j = width - 1; j >= 0; j--) {
+                    rgbaScanline = ImageLineHelper.palette2rgb(l1, plte, trns, rgbaScanline); // reuse rgbaScanline and update if resized
+                    dataOff = getPixelRGBA8ToAny(destFmt, destPixels, dataOff, rgbaScanline, lineOff, hasAlpha);
+                    lineOff += bytesPerPixel;
+                }
+            } else if( 1 == channels ) {
+                for (int j = width - 1; j >= 0; j--) {
+                    dataOff = getPixelLUMToAny(destFmt, destPixels, dataOff, (byte)l1.scanline[lineOff++], (byte)0xff); // Luminance, 1 bytesPerPixel
+                }
+            } else if( isGrayAlpha ) {
+                for (int j = width - 1; j >= 0; j--) {
+                    dataOff = getPixelLUMToAny(destFmt, destPixels, dataOff, (byte)l1.scanline[lineOff++], (byte)l1.scanline[lineOff++]); // Luminance+Alpha, 2 bytesPerPixel
+                }
+            } else if( srcFmt == destFmt ) { // fast-path
+                for (int j = width - 1; j >= 0; j--) {
+                    dataOff = getPixelRGBSame(destPixels, dataOff, l1.scanline, lineOff, bytesPerPixel);
+                    lineOff += bytesPerPixel;
+                }
+            } else {
+                for (int j = width - 1; j >= 0; j--) {
+                    dataOff = getPixelRGBA8ToAny(destFmt, destPixels, dataOff, l1.scanline, lineOff, hasAlpha);
+                    lineOff += bytesPerPixel;
+                }
+            }
+        }
+        pngr.end();
+
+        return new PNGPixelRect(destFmt, new Dimension(width, height), destStrideInBytes, destIsGLOriented, destPixels, dpiX, dpiY);
+    }
+
+    private static final int getPixelLUMToAny(PixelFormat dest_fmt, ByteBuffer d, int dOff, byte lum, byte alpha) {
+        switch(dest_fmt) {
+            case LUMINANCE:
+                d.put(dOff++, lum);
+                break;
+            case BGR888:
+            case RGB888:
+                d.put(dOff++, lum);
+                d.put(dOff++, lum);
+                d.put(dOff++, lum);
+                break;
+            case ABGR8888:
+            case ARGB8888:
+                d.put(dOff++, alpha); // A
+                d.put(dOff++, lum);
+                d.put(dOff++, lum);
+                d.put(dOff++, lum);
+                break;
+            case BGRA8888:
+            case RGBA8888:
+                d.put(dOff++, lum);
+                d.put(dOff++, lum);
+                d.put(dOff++, lum);
+                d.put(dOff++, alpha); // A
+                break;
+            default:
+                throw new InternalError("Unhandled format "+dest_fmt);
+        }
+        return dOff;
+    }
+    private static final int getPixelRGBA8ToAny(final PixelFormat dest_fmt, final ByteBuffer d, int dOff, final int[] scanline, final int lineOff, final boolean srcHasAlpha) {
+        final int p = PixelFormatUtil.convertToInt32(dest_fmt, (byte)scanline[lineOff],   // R
+                                                               (byte)scanline[lineOff+1], // G
+                                                               (byte)scanline[lineOff+2], // B
+                                                               srcHasAlpha ? (byte)scanline[lineOff+3] : (byte)0xff); // A
+        final int dbpp = dest_fmt.bytesPerPixel();
+        d.put(dOff++, (byte) ( p ));                // 1
+        if( 1 < dbpp ) {
+            d.put(dOff++, (byte) ( p >>>  8 ));     // 2
+            d.put(dOff++, (byte) ( p >>> 16 ));     // 3
+            if( 4 == dbpp ) {
+                d.put(dOff++, (byte) ( p >>> 24 )); // 4
+            }
+        }
+        return dOff;
+    }
+    private static final int getPixelRGBSame(final ByteBuffer d, int dOff, final int[] scanline, final int lineOff, final int bpp) {
+        d.put(dOff++, (byte)scanline[lineOff]);             // R
+        if( 1 < bpp ) {
+            d.put(dOff++, (byte)scanline[lineOff + 1]);     // G
+            d.put(dOff++, (byte)scanline[lineOff + 2]);     // B
+            if( 4 == bpp ) {
+                d.put(dOff++, (byte)scanline[lineOff + 3]); // A
+            }
+        }
+        return dOff;
+    }
+    private int setPixelRGBA8(final ImageLine line, final int lineOff, final ByteBuffer d, final int dOff, final int bytesPerPixel, final boolean hasAlpha) {
+        final int b = hasAlpha ? 4-1 : 3-1;
+        if( d.limit() <= dOff + b ) {
+            throw new IndexOutOfBoundsException("Buffer has unsufficient bytes left, needs ["+dOff+".."+(dOff+b)+"]: "+d);
+        }
+        final int p = PixelFormatUtil.convertToInt32(hasAlpha ? PixelFormat.RGBA8888 : PixelFormat.RGB888, pixelformat, d, dOff);
+        line.scanline[lineOff    ] = 0xff &   p;              // R
+        line.scanline[lineOff + 1] = 0xff & ( p >>> 8 );      // G
+        line.scanline[lineOff + 2] = 0xff & ( p >>> 16 );     // B
+        if(hasAlpha) {
+            line.scanline[lineOff + 3] = 0xff & ( p >>> 24 ); // A
+        }
+        return dOff + pixelformat.bytesPerPixel();
+    }
+
+    /**
+     * Creates a PNGPixelRect from data supplied by the end user. Shares
+     * data with the passed ByteBuffer.
+     *
+     * @param pixelformat
+     * @param size
+     * @param strideInBytes
+     * @param isGLOriented see {@link #isGLOriented()}.
+     * @param pixels
+     * @param dpiX
+     * @param dpiY
+     */
+    public PNGPixelRect(final PixelFormat pixelformat, final DimensionImmutable size,
+                        final int strideInBytes, final boolean isGLOriented, final ByteBuffer pixels,
+                        final double dpiX, final double dpiY) {
+        super(pixelformat, size, strideInBytes, isGLOriented, pixels);
+        this.dpi = new double[] { dpiX, dpiY };
+    }
+    public PNGPixelRect(final PixelRectangle src, final double dpiX, final double dpiY) {
+        super(src);
+        this.dpi = new double[] { dpiX, dpiY };
+    }
+    private final double[] dpi;
+
+    /** Returns the dpi of the image. */
+    public double[] getDpi() { return dpi; }
+
+    public void write(final OutputStream outstream, final boolean closeOutstream) throws IOException {
+        final int width = size.getWidth();
+        final int height = size.getHeight();
+        final int bytesPerPixel = pixelformat.bytesPerPixel();
+        final ImageInfo imi = new ImageInfo(width, height, 8 /* bitdepth */,
+                                            (4 == bytesPerPixel) ? true : false /* alpha */,
+                                            (1 == bytesPerPixel) ? true : false /* grayscale */,
+                                            false /* indexed */);
+
+        // open image for writing to a output stream
+        try {
+            final PngWriter png = new PngWriter(outstream, imi);
+            // add some optional metadata (chunks)
+            png.getMetadata().setDpi(dpi[0], dpi[1]);
+            png.getMetadata().setTimeNow(0); // 0 seconds fron now = now
+            png.getMetadata().setText(PngChunkTextVar.KEY_Title, "JogAmp PNGPixelRect");
+            // png.getMetadata().setText("my key", "my text");
+            final boolean hasAlpha = 4 == bytesPerPixel;
+
+            final ImageLine l1 = new ImageLine(imi);
+            for (int row = 0; row < height; row++) {
+                int dataOff = isGLOriented ? ( height - 1 - row ) * strideInBytes : row * strideInBytes;
+                int lineOff = 0;
+                if(1 == bytesPerPixel) {
+                    for (int j = width - 1; j >= 0; j--) {
+                        l1.scanline[lineOff++] = pixels.get(dataOff++); // // Luminance, 1 bytesPerPixel
+                    }
+                } else {
+                    for (int j = width - 1; j >= 0; j--) {
+                        dataOff = setPixelRGBA8(l1, lineOff, pixels, dataOff, bytesPerPixel, hasAlpha);
+                        lineOff += bytesPerPixel;
+                    }
+                }
+                png.writeRow(l1, row);
+            }
+            png.end();
+        } finally {
+            if( closeOutstream ) {
+                IOUtil.close(outstream, false);
+            }
+        }
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java
index 67ab5176d..0cde24db4 100644
--- a/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java
@@ -41,10 +41,12 @@
 package com.jogamp.opengl.util.texture;
 
 import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.net.URL;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
@@ -52,9 +54,10 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
+import javax.media.nativewindow.util.Dimension;
+import javax.media.nativewindow.util.PixelFormat;
 import javax.media.opengl.GL;
 import javax.media.opengl.GL2;
-import javax.media.opengl.GL2ES2;
 import javax.media.opengl.GL2GL3;
 import javax.media.opengl.GLContext;
 import javax.media.opengl.GLException;
@@ -63,11 +66,11 @@ import javax.media.opengl.GLProfile;
 import jogamp.opengl.Debug;
 
 import com.jogamp.common.util.IOUtil;
+import com.jogamp.opengl.util.PNGPixelRect;
 import com.jogamp.opengl.util.GLPixelBuffer.GLPixelAttributes;
 import com.jogamp.opengl.util.texture.spi.DDSImage;
 import com.jogamp.opengl.util.texture.spi.JPEGImage;
 import com.jogamp.opengl.util.texture.spi.NetPbmTextureWriter;
-import com.jogamp.opengl.util.texture.spi.PNGImage;
 import com.jogamp.opengl.util.texture.spi.SGIImage;
 import com.jogamp.opengl.util.texture.spi.TGAImage;
 import com.jogamp.opengl.util.texture.spi.TextureProvider;
@@ -1166,27 +1169,29 @@ public class TextureIO {
                                           boolean mipmap,
                                           String fileSuffix) throws IOException {
             if (PNG.equals(fileSuffix)) {
-                PNGImage image = PNGImage.read(/*glp, */ stream);
-                if (pixelFormat == 0) {
-                    pixelFormat = image.getGLFormat();
-                }
-                if (internalFormat == 0) {
+                final PNGPixelRect image = PNGPixelRect.read(stream, null, true /* directBuffer */, 0 /* destMinStrideInBytes */, true /* destIsGLOriented */);
+                final GLPixelAttributes glpa = GLPixelAttributes.convert(image.getPixelformat(), glp);
+                if ( 0 == pixelFormat ) {
+                    pixelFormat = glpa.format;
+                }  // else FIXME: Actually not supported w/ preset pixelFormat!
+                if ( 0 == internalFormat ) {
+                    final boolean hasAlpha = 4 == glpa.bytesPerPixel;
                     if(glp.isGL2ES3()) {
-                        internalFormat = (image.getBytesPerPixel()==4)?GL.GL_RGBA8:GL.GL_RGB8;
+                        internalFormat = hasAlpha ? GL.GL_RGBA8 : GL.GL_RGB8;
                     } else {
-                        internalFormat = (image.getBytesPerPixel()==4)?GL.GL_RGBA:GL.GL_RGB;
+                        internalFormat = hasAlpha ? GL.GL_RGBA : GL.GL_RGB;
                     }
                 }
                 return new TextureData(glp, internalFormat,
-                                       image.getWidth(),
-                                       image.getHeight(),
+                                       image.getSize().getWidth(),
+                                       image.getSize().getHeight(),
                                        0,
                                        pixelFormat,
-                                       image.getGLType(),
+                                       glpa.type,
                                        mipmap,
                                        false,
                                        false,
-                                       image.getData(),
+                                       image.getPixels(),
                                        null);
             }
 
@@ -1392,29 +1397,7 @@ public class TextureIO {
                 final int pixelFormat = pixelAttribs.format;
                 final int pixelType   = pixelAttribs.type;
                 final int bytesPerPixel = pixelAttribs.bytesPerPixel;
-                final boolean reversedChannels;
-                switch(pixelFormat) {
-                    case GL.GL_ALPHA:
-                    case GL.GL_LUMINANCE:
-                    case GL2ES2.GL_RED:
-                        reversedChannels=false;
-                        break;
-                    case GL.GL_RGB:
-                        reversedChannels=false;
-                        break;
-                    case GL.GL_RGBA:
-                        reversedChannels=false;
-                        break;
-                    case GL2.GL_BGR:
-                        reversedChannels=true;
-                        break;
-                    case GL.GL_BGRA:
-                        reversedChannels=true;
-                        break;
-                    default:
-                        reversedChannels=false;
-                        break;
-                }
+                final PixelFormat pixFmt = pixelAttribs.getPixelFormat();
                 if ( ( 1 == bytesPerPixel || 3 == bytesPerPixel || 4 == bytesPerPixel) &&
                      ( pixelType == GL.GL_BYTE || pixelType == GL.GL_UNSIGNED_BYTE)) {
                     ByteBuffer buf = (ByteBuffer) data.getBuffer();
@@ -1423,9 +1406,11 @@ public class TextureIO {
                     }
                     buf.rewind();
 
-                    PNGImage image = PNGImage.createFromData(data.getWidth(), data.getHeight(), -1f, -1f,
-                                                             bytesPerPixel, reversedChannels, !data.getMustFlipVertically(), buf);
-                    image.write(file, true);
+                    final PNGPixelRect image = new PNGPixelRect(pixFmt, new Dimension(data.getWidth(), data.getHeight()),
+                                                                0 /* stride */, true /* isGLOriented */, buf /* pixels */,
+                                                                -1f, -1f);
+                    final OutputStream outs = new BufferedOutputStream(IOUtil.getFileOutputStream(file, true /* allowOverwrite */));
+                    image.write(outs, true /* close */);
                     return true;
                 }
                 throw new IOException("PNG writer doesn't support this pixel format 0x"+Integer.toHexString(pixelFormat)+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/PNGImage.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/PNGImage.java
deleted file mode 100644
index 71cbbf97e..000000000
--- a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/PNGImage.java
+++ /dev/null
@@ -1,319 +0,0 @@
-/**
- * Copyright 2012 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 com.jogamp.opengl.util.texture.spi;
-
-import java.io.BufferedInputStream;
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.nio.ByteBuffer;
-
-import javax.media.opengl.GL;
-
-import jogamp.opengl.Debug;
-import jogamp.opengl.util.pngj.ImageInfo;
-import jogamp.opengl.util.pngj.ImageLine;
-import jogamp.opengl.util.pngj.ImageLineHelper;
-import jogamp.opengl.util.pngj.PngReader;
-import jogamp.opengl.util.pngj.PngWriter;
-import jogamp.opengl.util.pngj.chunks.PngChunkPLTE;
-import jogamp.opengl.util.pngj.chunks.PngChunkTRNS;
-import jogamp.opengl.util.pngj.chunks.PngChunkTextVar;
-
-import com.jogamp.common.nio.Buffers;
-import com.jogamp.common.util.IOUtil;
-
-public class PNGImage {
-    private static final boolean DEBUG = Debug.debug("PNGImage");
-
-    /**
-     * Creates a PNGImage from data supplied by the end user. Shares
-     * data with the passed ByteBuffer. Assumes the data is already in
-     * the correct byte order for writing to disk, i.e., LUMINANCE, RGB or RGBA.
-     * Orientation is <i>bottom-to-top</i> (OpenGL coord. default)
-     * or <i>top-to-bottom</i> depending on <code>isGLOriented</code>.
-     *
-     * @param width
-     * @param height
-     * @param dpiX
-     * @param dpiY
-     * @param bytesPerPixel
-     * @param reversedChannels
-     * @param isGLOriented see {@link #isGLOriented()}.
-     * @param data
-     * @return
-     */
-    public static PNGImage createFromData(int width, int height, double dpiX, double dpiY,
-                                          int bytesPerPixel, boolean reversedChannels, boolean isGLOriented, ByteBuffer data) {
-        return new PNGImage(width, height, dpiX, dpiY, bytesPerPixel, reversedChannels, isGLOriented, data);
-    }
-
-    /**
-     * Reads a PNG image from the specified InputStream.
-     * <p>
-     * Implicitly flip image to GL orientation, see {@link #isGLOriented()}.
-     * </p>
-     */
-    public static PNGImage read(InputStream in) throws IOException {
-        return new PNGImage(in);
-    }
-
-    /** Reverse read and store, implicitly flip image to GL orientation, see {@link #isGLOriented()}. */
-    private static final int getPixelRGBA8(ByteBuffer d, int dOff, int[] scanline, int lineOff, boolean hasAlpha) {
-        final int b = hasAlpha ? 4-1 : 3-1;
-        if( d.limit() <= dOff || dOff - b < 0 ) {
-            throw new IndexOutOfBoundsException("Buffer has unsufficient bytes left, needs ["+(dOff-b)+".."+dOff+"]: "+d);
-        }
-    	if(hasAlpha) {
-            d.put(dOff--, (byte)scanline[lineOff + 3]); // A
-        }
-        d.put(dOff--, (byte)scanline[lineOff + 2]); // B
-        d.put(dOff--, (byte)scanline[lineOff + 1]); // G
-        d.put(dOff--, (byte)scanline[lineOff    ]); // R
-        return dOff;
-    }
-
-    /** Reverse write and store, implicitly flip image from current orientation, see {@link #isGLOriented()}. Handle reversed channels (BGR[A]). */
-    private int setPixelRGBA8(ImageLine line, int lineOff, ByteBuffer d, int dOff, boolean hasAlpha) {
-        final int b = hasAlpha ? 4-1 : 3-1;
-        if( d.limit() <= dOff + b ) {
-            throw new IndexOutOfBoundsException("Buffer has unsufficient bytes left, needs ["+dOff+".."+(dOff+b)+"]: "+d);
-        }
-        if( reversedChannels ) {
-            if(hasAlpha) {
-                line.scanline[lineOff + 3] = d.get(dOff++); // A
-            }
-            line.scanline[lineOff + 2] = d.get(dOff++); // R
-            line.scanline[lineOff + 1] = d.get(dOff++); // G
-            line.scanline[lineOff    ] = d.get(dOff++); // B
-        } else {
-            line.scanline[lineOff    ] = d.get(dOff++); // R
-            line.scanline[lineOff + 1] = d.get(dOff++); // G
-            line.scanline[lineOff + 2] = d.get(dOff++); // B
-            if(hasAlpha) {
-                line.scanline[lineOff + 3] = d.get(dOff++); // A
-            }
-        }
-        return isGLOriented ? dOff - bytesPerPixel - bytesPerPixel : dOff;
-    }
-
-    private PNGImage(int width, int height, double dpiX, double dpiY, int bytesPerPixel, boolean reversedChannels, boolean isGLOriented, ByteBuffer data) {
-        pixelWidth=width;
-        pixelHeight=height;
-        dpi = new double[] { dpiX, dpiY };
-        if(4 == bytesPerPixel) {
-            glFormat = GL.GL_RGBA;
-        } else if (3 == bytesPerPixel) {
-            glFormat = GL.GL_RGB;
-        } else {
-            throw new InternalError("XXX: bytesPerPixel "+bytesPerPixel);
-        }
-        this.bytesPerPixel = bytesPerPixel;
-        this.reversedChannels = reversedChannels;
-        this.isGLOriented = isGLOriented;
-        this.data = data;
-    }
-
-    private PNGImage(InputStream in) {
-        final PngReader pngr = new PngReader(new BufferedInputStream(in), null);
-        final ImageInfo imgInfo = pngr.imgInfo;
-        final PngChunkPLTE plte = pngr.getMetadata().getPLTE();
-        final PngChunkTRNS trns = pngr.getMetadata().getTRNS();
-        final boolean indexed = imgInfo.indexed;
-        final boolean hasAlpha = indexed ? ( trns != null ) : imgInfo.alpha ;
-
-        final int channels = indexed ? ( hasAlpha ? 4 : 3 ) : imgInfo.channels ;
-        if ( ! ( 1 == channels || 3 == channels || 4 == channels ) ) {
-            throw new RuntimeException("PNGImage can only handle Lum/RGB/RGBA [1/3/4 channels] images for now. Channels "+channels + " Paletted: " + indexed);
-        }
-
-        bytesPerPixel = indexed ? channels : imgInfo.bytesPixel ;
-        if ( ! ( 1 == bytesPerPixel || 3 == bytesPerPixel || 4 == bytesPerPixel ) ) {
-            throw new RuntimeException("PNGImage can only handle Lum/RGB/RGBA [1/3/4 bpp] images for now. BytesPerPixel "+bytesPerPixel);
-        }
-        if( channels != bytesPerPixel ) {
-            throw new RuntimeException("PNGImage currently only handles Channels [1/3/4] == BytePerPixel [1/3/4], channels: "+channels+", bytesPerPixel "+bytesPerPixel);
-        }
-        pixelWidth = imgInfo.cols;
-        pixelHeight = imgInfo.rows;
-        dpi = new double[2];
-        {
-            final double[] dpi2 = pngr.getMetadata().getDpi();
-            dpi[0]=dpi2[0];
-            dpi[1]=dpi2[1];
-        }
-        if ( indexed ) {
-        	if ( hasAlpha ) {
-        		glFormat = GL.GL_RGBA;
-        	} else {
-        		glFormat = GL.GL_RGB;
-        	}
-        } else {
-        	switch( channels ) {
-                case 1: glFormat = GL.GL_LUMINANCE; break;
-                case 3: glFormat = GL.GL_RGB; break;
-                case 4: glFormat = GL.GL_RGBA; break;
-                default: throw new InternalError("XXX: channels: "+channels+", bytesPerPixel "+bytesPerPixel);
-            }
-        }
-        if(DEBUG) {
-            System.err.println("PNGImage: "+imgInfo);
-            System.err.println("PNGImage: indexed "+indexed+", alpha "+hasAlpha+", channels "+channels+"/"+imgInfo.channels+
-                               ", bytesPerPixel "+bytesPerPixel+"/"+imgInfo.bytesPixel+
-                               ", pixels "+pixelWidth+"x"+pixelHeight+", dpi "+dpi[0]+"x"+dpi[1]+", glFormat 0x"+Integer.toHexString(glFormat));
-        }
-
-        data = Buffers.newDirectByteBuffer(bytesPerPixel * pixelWidth * pixelHeight);
-        reversedChannels = false; // RGB[A]
-        isGLOriented = true;
-        int dataOff = bytesPerPixel * pixelWidth * pixelHeight - 1; // start at end-of-buffer, reverse store
-
-        int[] rgbaScanline = indexed ? new int[imgInfo.cols * channels] : null;
-
-        for (int row = 0; row < pixelHeight; row++) {
-            final ImageLine l1 = pngr.readRow(row);
-            int lineOff = ( pixelWidth - 1 ) * bytesPerPixel ; // start w/ last pixel in line, reverse read (PNG top-left -> OpenGL bottom-left origin)
-            if( indexed ) {
-                for (int j = pixelWidth - 1; j >= 0; j--) {
-                    rgbaScanline = ImageLineHelper.palette2rgb(l1, plte, trns, rgbaScanline); // reuse rgbaScanline and update if resized
-                    dataOff = getPixelRGBA8(data, dataOff, rgbaScanline, lineOff, hasAlpha);
-                    lineOff -= bytesPerPixel;
-                }
-            } else if( 1 == channels ) {
-                for (int j = pixelWidth - 1; j >= 0; j--) {
-                    data.put(dataOff--, (byte)l1.scanline[lineOff--]); // Luminance, 1 bytesPerPixel
-                }
-            } else {
-                for (int j = pixelWidth - 1; j >= 0; j--) {
-            		dataOff = getPixelRGBA8(data, dataOff, l1.scanline, lineOff, hasAlpha);
-                    lineOff -= bytesPerPixel;
-                }
-            }
-        }
-        pngr.end();
-    }
-    private final int pixelWidth, pixelHeight, glFormat, bytesPerPixel;
-    private final boolean reversedChannels;
-    private final boolean isGLOriented;
-    private final double[] dpi;
-    private final ByteBuffer data;
-
-    /** Returns the width of the image. */
-    public int getWidth()    { return pixelWidth; }
-
-    /** Returns the height of the image. */
-    public int getHeight()   { return pixelHeight; }
-
-    /** Returns true if data has the channels reversed to BGR or BGRA, otherwise RGB or RGBA is expected. */
-    public boolean getHasReversedChannels() { return reversedChannels; }
-
-    /**
-     * Returns <code>true</code> if the drawable is rendered in
-     * OpenGL's coordinate system, <i>origin at bottom left</i>.
-     * Otherwise returns <code>false</code>, i.e. <i>origin at top left</i>.
-     * <p>
-     * Default impl. is <code>true</code>, i.e. OpenGL coordinate system.
-     * </p>
-     */
-    public boolean isGLOriented() { return isGLOriented; }
-
-    /** Returns the dpi of the image. */
-    public double[] getDpi() { return dpi; }
-
-    /** Returns the OpenGL format for this texture; e.g. GL.GL_LUMINANCE, GL.GL_RGB or GL.GL_RGBA. */
-    public int getGLFormat() { return glFormat; }
-
-    /** Returns the OpenGL data type: GL.GL_UNSIGNED_BYTE. */
-    public int getGLType() { return GL.GL_UNSIGNED_BYTE; }
-
-    /** Returns the bytes per pixel */
-    public int getBytesPerPixel() { return bytesPerPixel; }
-
-    /** Returns the raw data for this texture in the correct
-        (bottom-to-top) order for calls to glTexImage2D. */
-    public ByteBuffer getData()  { return data; }
-
-    public void write(File out, boolean allowOverwrite) throws IOException {
-        final ImageInfo imi = new ImageInfo(pixelWidth, pixelHeight, 8, (4 == bytesPerPixel) ? true : false); // 8 bits per channel, no alpha
-        // open image for writing to a output stream
-        final OutputStream outs = new BufferedOutputStream(IOUtil.getFileOutputStream(out, allowOverwrite));
-        try {
-            final PngWriter png = new PngWriter(outs, imi);
-            // add some optional metadata (chunks)
-            png.getMetadata().setDpi(dpi[0], dpi[1]);
-            png.getMetadata().setTimeNow(0); // 0 seconds fron now = now
-            png.getMetadata().setText(PngChunkTextVar.KEY_Title, "JogAmp PNGImage");
-            // png.getMetadata().setText("my key", "my text");
-            final boolean hasAlpha = 4 == bytesPerPixel;
-            final ImageLine l1 = new ImageLine(imi);
-            if( isGLOriented ) {
-                // start at last pixel at end-of-buffer, reverse read (OpenGL bottom-left -> PNG top-left origin)
-                int dataOff = ( pixelWidth * bytesPerPixel * ( pixelHeight - 1 ) ) + // full lines - 1 line
-                              ( ( pixelWidth - 1 ) * bytesPerPixel );                // one line - 1 pixel
-                for (int row = 0; row < pixelHeight; row++) {
-                    int lineOff = ( pixelWidth - 1 ) * bytesPerPixel ; // start w/ last pixel in line, reverse store (OpenGL bottom-left -> PNG top-left origin)
-                    if(1 == bytesPerPixel) {
-                        for (int j = pixelWidth - 1; j >= 0; j--) {
-                            l1.scanline[lineOff--] = data.get(dataOff--); // // Luminance, 1 bytesPerPixel
-                        }
-                    } else {
-                        for (int j = pixelWidth - 1; j >= 0; j--) {
-                            dataOff = setPixelRGBA8(l1, lineOff, data, dataOff, hasAlpha);
-                            lineOff -= bytesPerPixel;
-                        }
-                    }
-                    png.writeRow(l1, row);
-                }
-            } else {
-                int dataOff = 0; // start at first pixel at start-of-buffer, normal read (same origin: top-left)
-                for (int row = 0; row < pixelHeight; row++) {
-                    int lineOff = 0; // start w/ first pixel in line, normal store (same origin: top-left)
-                    if(1 == bytesPerPixel) {
-                        for (int j = pixelWidth - 1; j >= 0; j--) {
-                            l1.scanline[lineOff++] = data.get(dataOff++); // // Luminance, 1 bytesPerPixel
-                        }
-                    } else {
-                        for (int j = pixelWidth - 1; j >= 0; j--) {
-                            dataOff = setPixelRGBA8(l1, lineOff, data, dataOff, hasAlpha);
-                            lineOff += bytesPerPixel;
-                        }
-                    }
-                    png.writeRow(l1, row);
-                }
-            }
-            png.end();
-        } finally {
-            IOUtil.close(outs, false);
-        }
-    }
-
-    @Override
-    public String toString() { return "PNGImage["+pixelWidth+"x"+pixelHeight+", dpi "+dpi[0]+" x "+dpi[1]+", bytesPerPixel "+bytesPerPixel+", reversedChannels "+reversedChannels+", "+data+"]"; }
-}