summaryrefslogtreecommitdiffstats
path: root/src/test/com
diff options
context:
space:
mode:
Diffstat (limited to 'src/test/com')
-rw-r--r--src/test/com/jogamp/opengl/test/junit/jogl/util/texture/TestPixelFormatUtil00NEWT.java364
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());
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-15 03:37:26 +0000