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

To allowing 'arbitrary' PointerIcon data input, i.e. via raw pixels
we need to define an agnostic PixelFormat and required conversion utilities.

The latter is not hw accelereated (toolkit agnostic), but this shall be expected
and satisfying for small amount of 'pixels'.

1 files changed, 364 insertions, 0 deletions

diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/util/texture/TestPixelFormatUtil00NEWT.java b/src/test/com/jogamp/opengl/test/junit/jogl/util/texture/TestPixelFormatUtil00NEWT.java
new file mode 100644
index 000000000..bfcf9c2d7
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/util/texture/TestPixelFormatUtil00NEWT.java
@@ -0,0 +1,364 @@
+/**
+ * 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 com.jogamp.opengl.test.junit.jogl.util.texture;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import javax.media.nativewindow.util.Dimension;
+import javax.media.nativewindow.util.PixelFormat;
+import javax.media.nativewindow.util.PixelFormatUtil;
+import javax.media.nativewindow.util.PixelRectangle;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+import com.jogamp.opengl.test.junit.util.UITestCase;
+
+/**
+ * Testing PixelFormatUtil's Conversion using synthetic test data
+ * including strides, endian-order and all PixelFormat conversions.
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestPixelFormatUtil00NEWT extends UITestCase {
+    @Test
+    public void testConversion01_srcS000_BE_TL_destS000_TL() throws InterruptedException, IOException, MalformedURLException {
+        testPNG00Impl(0 /* srcMinStrideInBytes */, ByteOrder.BIG_ENDIAN, false /* srcIsGLOriented */,
+                      0 /* destMinStrideInBytes */, false /* destIsGLOriented */);
+    }
+    @Test
+    public void testConversion02_srcS000_LE_TL_destS000_TL() throws InterruptedException, IOException, MalformedURLException {
+        testPNG00Impl(0 /* srcMinStrideInBytes */, ByteOrder.LITTLE_ENDIAN, false /* srcIsGLOriented */,
+                      0 /* destMinStrideInBytes */, false /* destIsGLOriented */);
+    }
+    @Test
+    public void testConversion03_srcS000_BE_TL_destS259_TL() throws InterruptedException, IOException, MalformedURLException {
+        testPNG00Impl(0 /* srcMinStrideInBytes */, ByteOrder.BIG_ENDIAN, false /* srcIsGLOriented */,
+                      259 /* destMinStrideInBytes */, false /* destIsGLOriented */);
+    }
+    @Test
+    public void testConversion04_srcS259_BE_TL_destS259_TL() throws InterruptedException, IOException, MalformedURLException {
+        testPNG00Impl(259 /* srcMinStrideInBytes */, ByteOrder.BIG_ENDIAN, false /* srcIsGLOriented */,
+                      259 /* destMinStrideInBytes */, false /* destIsGLOriented */);
+    }
+    @Test
+    public void testConversion05_srcS301_BE_TL_destS259_TL() throws InterruptedException, IOException, MalformedURLException {
+        testPNG00Impl(301 /* srcMinStrideInBytes */, ByteOrder.BIG_ENDIAN, false /* srcIsGLOriented */,
+                      259 /* destMinStrideInBytes */, false /* destIsGLOriented */);
+    }
+
+    static final byte red___val = (byte)0x01;
+    static final byte green_val = (byte)0x02;
+    static final byte blue__val = (byte)0x03;
+    static final byte alpha_val = (byte)0x04;
+    static final byte undef_val = (byte)0xff;
+
+    static final void getComponents(final int srcComps, final PixelFormat fmt, final byte[] components) {
+        final byte b1, b2, b3, b4;
+        if( 1 == srcComps ) {
+            // LUM -> Fmt Conversion
+            switch(fmt) {
+                case LUMINANCE:
+                    b1 = red___val;
+                    b2 = undef_val;
+                    b3 = undef_val;
+                    b4 = undef_val;
+                    break;
+                case RGB888:
+                    b1 = red___val;
+                    b2 = red___val;
+                    b3 = red___val;
+                    b4 = undef_val;
+                    break;
+                case BGR888:
+                    b1 = red___val;
+                    b2 = red___val;
+                    b3 = red___val;
+                    b4 = undef_val;
+                    break;
+                case RGBA8888:
+                    b1 = red___val;
+                    b2 = red___val;
+                    b3 = red___val;
+                    b4 = undef_val;
+                    break;
+                case ABGR8888:
+                    b1 = undef_val;
+                    b2 = red___val;
+                    b3 = red___val;
+                    b4 = red___val;
+                    break;
+                case BGRA8888:
+                    b1 = red___val;
+                    b2 = red___val;
+                    b3 = red___val;
+                    b4 = undef_val;
+                    break;
+                case ARGB8888:
+                    b1 = undef_val;
+                    b2 = red___val;
+                    b3 = red___val;
+                    b4 = red___val;
+                    break;
+                default:
+                    throw new InternalError("Unhandled format "+fmt);
+            }
+        } else {
+            // 1:1 values
+            switch(fmt) {
+                case LUMINANCE:
+                    if( srcComps > 1 ) {
+                        b1 = ( red___val + green_val+ blue__val ) / 3;
+                        b2 = undef_val;
+                        b3 = undef_val;
+                        b4 = undef_val;
+                    } else {
+                        b1 = red___val;
+                        b2 = undef_val;
+                        b3 = undef_val;
+                        b4 = undef_val;
+                    }
+                    break;
+                case RGB888:
+                    b1 = red___val;
+                    b2 = green_val;
+                    b3 = blue__val;
+                    b4 = undef_val;
+                    break;
+                case BGR888:
+                    b1 = blue__val;
+                    b2 = green_val;
+                    b3 = red___val;
+                    b4 = undef_val;
+                    break;
+                case RGBA8888:
+                    b1 = red___val;
+                    b2 = green_val;
+                    b3 = blue__val;
+                    b4 = srcComps > 3 ? alpha_val : undef_val;
+                    break;
+                case ABGR8888:
+                    b1 = srcComps > 3 ? alpha_val : undef_val;
+                    b2 = blue__val;
+                    b3 = green_val;
+                    b4 = red___val;
+                    break;
+                case BGRA8888:
+                    b1 = blue__val;
+                    b2 = green_val;
+                    b3 = red___val;
+                    b4 = srcComps > 3 ? alpha_val : undef_val;
+                    break;
+                case ARGB8888:
+                    b1 = srcComps > 3 ? alpha_val : undef_val;
+                    b2 = red___val;
+                    b3 = green_val;
+                    b4 = blue__val;
+                    break;
+                default:
+                    throw new InternalError("Unhandled format "+fmt);
+            }
+        }
+        components[0] = b1;
+        components[1] = b2;
+        components[2] = b3;
+        components[3] = b4;
+    }
+    private void testPNG00Impl(final int srcMinStrideInBytes, final ByteOrder srcByteOrder, final boolean srcIsGLOriented,
+                               final int destMinStrideInBytes, final boolean destIsGLOriented)
+            throws InterruptedException, IOException, MalformedURLException
+    {
+        System.err.println("Test00: srcMinStrideInBytes "+srcMinStrideInBytes+", srcByteOrder "+srcByteOrder+", srcIsGLOriented "+srcIsGLOriented+
+                           ", destMinStrideInBytes "+destMinStrideInBytes+", destIsGLOriented "+destIsGLOriented);
+
+        final PixelFormat[] formats = PixelFormat.values();
+        final int width  = 64, height = 64;
+
+        for(int i=0; i<formats.length; i++) {
+            final PixelFormat srcFmt = formats[i];
+            final int srcBpp = srcFmt.bytesPerPixel();
+            final int srcStrideBytes = Math.max(srcMinStrideInBytes, width*srcBpp);
+            final ByteBuffer srcPixels = ByteBuffer.allocate(height*srcStrideBytes).order(srcByteOrder);
+            final byte[] srcComponents = new byte[4];
+            getComponents(srcFmt.componentCount, srcFmt, srcComponents);
+            for(int y=0; y<height; y++) {
+                int o = y*srcStrideBytes;
+                for(int x=0; x<width; x++) {
+                    switch(srcFmt) {
+                        case LUMINANCE:
+                            srcPixels.put(o++, srcComponents[0]);
+                            break;
+                        case RGB888:
+                        case BGR888:
+                            srcPixels.put(o++, srcComponents[0]);
+                            srcPixels.put(o++, srcComponents[1]);
+                            srcPixels.put(o++, srcComponents[2]);
+                            break;
+                        case RGBA8888:
+                        case ABGR8888:
+                        case BGRA8888:
+                        case ARGB8888:
+                            srcPixels.put(o++, srcComponents[0]);
+                            srcPixels.put(o++, srcComponents[1]);
+                            srcPixels.put(o++, srcComponents[2]);
+                            srcPixels.put(o++, srcComponents[3]);
+                            break;
+                        default:
+                            throw new InternalError("Unhandled format "+srcFmt);
+                    }
+                }
+            }
+            final PixelRectangle imageSrc = new PixelRectangle.GenericPixelRect(srcFmt, new Dimension(width, height), srcStrideBytes, srcIsGLOriented, srcPixels);
+            System.err.println("CONVERT["+i+"][*]: Image0 - Orig: "+imageSrc);
+            testComponents(imageSrc, 0, 0, srcComponents);
+            testComponents(imageSrc, width-1, height-1, srcComponents);
+
+            for(int j=0; j<formats.length; j++) {
+                final PixelFormat destFmt = formats[j];
+                System.err.println("CONVERT["+i+"]["+j+"]: "+srcFmt+" -> "+destFmt);
+
+                final int destStrideBytes = Math.max(destMinStrideInBytes, width*destFmt.bytesPerPixel());
+                final byte[] destComponents = new byte[4];
+                getComponents(srcFmt.componentCount, destFmt, destComponents);
+                final PixelRectangle imageConv1 = PixelFormatUtil.convert32(imageSrc, destFmt, destStrideBytes, destIsGLOriented, false /* nio */);
+                System.err.println("CONVERT["+i+"]["+j+"]: Conv1: "+imageConv1);
+                testComponents(imageConv1, 0, 0, destComponents);
+                testComponents(imageConv1, width-1, height-1, destComponents);
+                if( PixelFormat.LUMINANCE != srcFmt && PixelFormat.LUMINANCE == destFmt ) {
+                    // Cannot convert: RGB* -> LUM -> RGB*
+                    System.err.println("CONVERT["+i+"]["+j+"]: Conv2: Dropped due to RGB* -> LUM");
+                } else if( srcFmt.componentCount > destFmt.componentCount ) {
+                    // Cannot convert back if: src.componentCount > dest.componentCount
+                    System.err.println("CONVERT["+i+"]["+j+"]: Conv2: Dropped due to src.componentCount > dest.componentCount");
+                } else {
+                    final PixelRectangle imageConv2 = PixelFormatUtil.convert32(imageConv1, imageSrc.getPixelformat(), imageSrc.getStride(), imageSrc.isGLOriented(), false /* nio */);
+                    System.err.println("CONVERT["+i+"]["+j+"]: Conv2: "+imageConv2);
+                    testComponents(imageConv2, 0, 0, srcComponents);
+                    testComponents(imageConv2, width-1, height-1, srcComponents);
+                    if( imageSrc.getStride() == imageConv1.getStride() ) {
+                        Assert.assertEquals(imageSrc.getPixels(), imageConv2.getPixels());
+                    }
+                }
+            }
+        }
+    }
+    private void dumpComponents(PixelRectangle image, int x1, int y1, int w, int h) {
+        if( x1 + w >= image.getSize().getWidth() ) {
+            x1 = image.getSize().getWidth() - w;
+        }
+        if( y1 + h >= image.getSize().getHeight() ) {
+            y1 = image.getSize().getHeight() - h;
+        }
+        System.err.print("PixelsBytes "+x1+"/"+y1+" "+w+"x"+h+":");
+        final ByteBuffer bb = image.getPixels();
+        final int bpp = image.getPixelformat().bytesPerPixel();
+        for(int y = y1; y< y1+h; y++) {
+            System.err.printf("%n[%3d][%3d] ", x1, y);
+            int o = y * image.getStride()+x1*bpp;
+            for(int x = x1; x< x1+w; x++) {
+                switch(bpp) {
+                    case 1: {
+                        final byte a = bb.get(o++);
+                        System.err.printf(" 0x%02X", a);
+                        }
+                        break;
+                    case 2: {
+                        final byte a = bb.get(o++), b = bb.get(o++);
+                        System.err.printf(" 0x%02X%02X", b, a);
+                      }
+                      break;
+                    case 3: {
+                        final byte a = bb.get(o++), b = bb.get(o++), c = bb.get(o++);
+                        System.err.printf(" 0x%02X%02X%02X", c, b, a);
+                      }
+                      break;
+                    case 4: {
+                        final byte a = bb.get(o++), b = bb.get(o++), c = bb.get(o++), d = bb.get(o++);
+                        System.err.printf(" 0x%02X%02X%02X%02X", d, c, b, a);
+                      }
+                      break;
+                }
+            }
+        }
+        System.err.println();
+    }
+    private void testComponents(PixelRectangle image, int x, int y, byte[] components) {
+        dumpComponents(image, x, y, 3, 3);
+        final ByteBuffer bb = image.getPixels();
+        final int bpp = image.getPixelformat().bytesPerPixel();
+        int o = y * image.getStride()+x*bpp;
+        switch(bpp) {
+            case 1: {
+                final byte c1 = bb.get(o++);
+                final boolean equal = c1==components[0];
+                System.err.printf("Test [%3d][%3d] exp 0x%02X == has 0x%02X : %b%n",
+                        x, y, components[0], c1, equal );
+                Assert.assertEquals(components[0], c1);
+                }
+                break;
+            case 2: {
+                final byte c1 = bb.get(o++), c2 = bb.get(o++);
+                final boolean equal = c1==components[0] && c2==components[1];
+                System.err.printf("Test [%3d][%3d] exp 0x%02X%02X == has 0x%02X%02X : %b%n",
+                        x, components[1], components[0], c2, c1, equal );
+                Assert.assertEquals(components[0], c1);
+                Assert.assertEquals(components[1], c2);
+              }
+              break;
+            case 3: {
+                final byte c1 = bb.get(o++), c2 = bb.get(o++), c3 = bb.get(o++);
+                final boolean equal = c1==components[0] && c2==components[1] && c3==components[2];
+                System.err.printf("Test [%3d][%3d] exp 0x%02X%02X%02X == has 0x%02X%02X%02X : %b%n",
+                        x, y, components[2], components[1], components[0], c3, c2, c1, equal );
+                Assert.assertEquals(components[0], c1);
+                Assert.assertEquals(components[1], c2);
+                Assert.assertEquals(components[2], c3);
+              }
+              break;
+            case 4: {
+                final byte c1 = bb.get(o++), c2 = bb.get(o++), c3 = bb.get(o++), c4 = bb.get(o++);
+                final boolean equal = c1==components[0] && c2==components[1] && c3==components[2] && c4==components[3];
+                System.err.printf("Test [%3d][%3d] exp 0x%02X%02X%02X%02X == has 0x%02X%02X%02X%02X : %b%n",
+                        x, y, components[3], components[2], components[1], components[0], c4, c3, c2, c1, equal );
+                Assert.assertEquals(components[0], c1);
+                Assert.assertEquals(components[1], c2);
+                Assert.assertEquals(components[2], c3);
+                Assert.assertEquals(components[3], c4);
+              }
+              break;
+        }
+    }
+
+    public static void main(String args[]) {
+        org.junit.runner.JUnitCore.main(TestPixelFormatUtil00NEWT.class.getName());
+    }
+}