Buffers: Add normalized put methods, i.e. incl. value range conversion; New util. ValueConv for primitive type value conversion

4 files changed, 408 insertions, 3 deletions

diff --git a/make/scripts/runtest.sh b/make/scripts/runtest.sh
index 30d5d5b..aebe608 100755
--- a/make/scripts/runtest.sh
+++ b/make/scripts/runtest.sh
@@ -73,7 +73,7 @@ function onetest() {
 #onetest com.jogamp.common.util.TestIteratorIndexCORE 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.locks.TestRecursiveLock01 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.locks.TestRecursiveThreadGroupLock01 2>&1 | tee -a $LOG
-onetest com.jogamp.common.util.locks.TestSingletonServerSocket00 2>&1 | tee -a $LOG
+#onetest com.jogamp.common.util.locks.TestSingletonServerSocket00 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.locks.TestSingletonServerSocket01 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.locks.TestSingletonServerSocket02 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.TestArrayHashSet01 2>&1 | tee -a $LOG
@@ -91,6 +91,7 @@ onetest com.jogamp.common.util.locks.TestSingletonServerSocket00 2>&1 | tee -a $
 #onetest com.jogamp.common.util.TestIOUtil01 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.TestTempJarCache 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.util.TestJarUtil 2>&1 | tee -a $LOG
+onetest com.jogamp.common.util.TestValueConversion 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.net.AssetURLConnectionUnregisteredTest 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.net.AssetURLConnectionRegisteredTest 2>&1 | tee -a $LOG
 #onetest com.jogamp.common.net.URLCompositionTest 2>&1 | tee -a $LOG
diff --git a/src/java/com/jogamp/common/nio/Buffers.java b/src/java/com/jogamp/common/nio/Buffers.java
index 5b5f83b..07a73b1 100755
--- a/src/java/com/jogamp/common/nio/Buffers.java
+++ b/src/java/com/jogamp/common/nio/Buffers.java
@@ -41,6 +41,8 @@ package com.jogamp.common.nio;
 
 import java.nio.*;
 
+import com.jogamp.common.util.ValueConv;
+
 /**
  * Utility methods allowing easy {@link java.nio.Buffer} manipulations.
  * 
@@ -663,8 +665,9 @@ public class Buffers {
 
 
     //----------------------------------------------------------------------
-    // Convenient put methods with generic target Buffer
-    //
+    // Convenient put methods with generic target Buffer w/o value range conversion, i.e. normalization
+    //    
+    
     @SuppressWarnings("unchecked")
     public static <B extends Buffer> B put(B dest, Buffer src) {
         if ((dest instanceof ByteBuffer) && (src instanceof ByteBuffer)) {
@@ -762,6 +765,109 @@ public class Buffers {
         }
     }
 
+    //----------------------------------------------------------------------
+    // Convenient put methods with generic target Buffer and value range conversion, i.e. normalization
+    //
+
+    /** 
+     * Store byte source value in given buffer after normalizing it to the destination value range
+     * considering signed and unsigned source and destination representation.
+     * 
+     * @param dest One of {@link ByteBuffer}, {@link ShortBuffer}, {@link IntBuffer}, {@link FloatBuffer}
+     * @param dSigned  true if destination buffer holds signed values, false if destination buffer holds unsigned values
+     * @param v source byte value to be put in dest buffer
+     * @param sSigned  true if source represents a signed value, false if source represents an unsigned value
+     */ 
+    @SuppressWarnings("unchecked")
+    public static <B extends Buffer> B putNb(B dest, boolean dSigned, byte v, boolean sSigned) {
+        if (dest instanceof ByteBuffer) {
+            return (B) ((ByteBuffer) dest).put( v );
+        } else if (dest instanceof ShortBuffer) {
+            return (B) ((ShortBuffer) dest).put( ValueConv.byte_to_short(v, sSigned, dSigned) );
+        } else if (dest instanceof IntBuffer) {
+            return (B) ((IntBuffer) dest).put( ValueConv.byte_to_int(v, sSigned, dSigned) );
+        } else if (dest instanceof FloatBuffer) {            
+            return (B) ((FloatBuffer) dest).put( ValueConv.byte_to_float(v, sSigned) );
+        } else {
+            throw new IllegalArgumentException("Byte doesn't match Buffer Class: " + dest);
+        }
+    }
+
+    /** 
+     * Store short source value in given buffer after normalizing it to the destination value range
+     * considering signed and unsigned source and destination representation.
+     * 
+     * @param dest One of {@link ByteBuffer}, {@link ShortBuffer}, {@link IntBuffer}, {@link FloatBuffer}
+     * @param dSigned  true if destination buffer holds signed values, false if destination buffer holds unsigned values
+     * @param v source short value to be put in dest buffer
+     * @param sSigned  true if source represents a signed value, false if source represents an unsigned value
+     */ 
+    @SuppressWarnings("unchecked")
+    public static <B extends Buffer> B putNs(B dest, boolean dSigned, short v, boolean sSigned) {
+        if (dest instanceof ByteBuffer) {
+            return (B) ((ByteBuffer) dest).put( ValueConv.short_to_byte(v, sSigned, dSigned) );
+        } else if (dest instanceof ShortBuffer) {
+            return (B) ((ShortBuffer) dest).put( v );
+        } else if (dest instanceof IntBuffer) {
+            return (B) ((IntBuffer) dest).put( ValueConv.short_to_int(v, sSigned, dSigned) );
+        } else if (dest instanceof FloatBuffer) {            
+            return (B) ((FloatBuffer) dest).put( ValueConv.short_to_float(v, sSigned) );
+        } else {
+            throw new IllegalArgumentException("Byte doesn't match Buffer Class: " + dest);
+        }
+    }
+    
+    /** 
+     * Store short source value in given buffer after normalizing it to the destination value range
+     * considering signed and unsigned source and destination representation.
+     * 
+     * @param dest One of {@link ByteBuffer}, {@link ShortBuffer}, {@link IntBuffer}, {@link FloatBuffer}
+     * @param dSigned  true if destination buffer holds signed values, false if destination buffer holds unsigned values
+     * @param v source short value to be put in dest buffer
+     * @param sSigned  true if source represents a signed value, false if source represents an unsigned value
+     */ 
+    @SuppressWarnings("unchecked")
+    public static <B extends Buffer> B putNi(B dest, boolean dSigned, int v, boolean sSigned) {
+        if (dest instanceof ByteBuffer) {
+            return (B) ((ByteBuffer) dest).put( ValueConv.int_to_byte(v, sSigned, dSigned) );
+        } else if (dest instanceof ShortBuffer) {
+            return (B) ((ShortBuffer) dest).put( ValueConv.int_to_short(v, sSigned, dSigned) );
+        } else if (dest instanceof IntBuffer) {
+            return (B) ((IntBuffer) dest).put( v );
+        } else if (dest instanceof FloatBuffer) {            
+            return (B) ((FloatBuffer) dest).put( ValueConv.int_to_float(v, sSigned) );
+        } else {
+            throw new IllegalArgumentException("Byte doesn't match Buffer Class: " + dest);
+        }
+    }
+        
+    /** 
+     * Store float source value in given buffer after normalizing it to the destination value range
+     * considering signed and unsigned destination representation.
+     * 
+     * @param dest One of {@link ByteBuffer}, {@link ShortBuffer}, {@link IntBuffer}, {@link FloatBuffer}
+     * @param dSigned  true if destination buffer holds signed values, false if destination buffer holds unsigned values
+     * @param v source float value to be put in dest buffer
+     */ 
+    @SuppressWarnings("unchecked")
+    public static <B extends Buffer> B putNf(B dest, boolean dSigned, float v) {
+        if (dest instanceof ByteBuffer) {
+            return (B) ((ByteBuffer) dest).put( ValueConv.float_to_byte(v, dSigned) );
+        } else if (dest instanceof ShortBuffer) {
+            return (B) ((ShortBuffer) dest).put( ValueConv.float_to_short(v, dSigned) );
+        } else if (dest instanceof IntBuffer) {
+            return (B) ((IntBuffer) dest).put( ValueConv.float_to_int(v, dSigned) );
+        } else if (dest instanceof FloatBuffer) {            
+            return (B) ((FloatBuffer) dest).put( v );
+        } else {
+            throw new IllegalArgumentException("Byte doesn't match Buffer Class: " + dest);
+        }
+    }
+    
+    //----------------------------------------------------------------------
+    // Range check methods 
+    //
+    
     public static void rangeCheck(byte[] array, int offset, int minElementsRemaining) {
         if (array == null) {
             return;
diff --git a/src/java/com/jogamp/common/util/ValueConv.java b/src/java/com/jogamp/common/util/ValueConv.java
new file mode 100644
index 0000000..fa49341
--- /dev/null
+++ b/src/java/com/jogamp/common/util/ValueConv.java
@@ -0,0 +1,161 @@
+package com.jogamp.common.util;
+
+/**
+ * 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.
+ */
+
+/**
+ * Utility class providing simple signed and unsigned primitive value conversions
+ * for byte, short, int, float and double.
+ * <p>
+ * Non float to non float conversions are handled via float or double,
+ * depending on the value range.
+ * </p>
+ */
+public class ValueConv {
+    public static final byte float_to_byte(float v, boolean dSigned) {
+        // lossy
+        if( dSigned ) {
+            return (byte) ( v * ( v > 0 ? 127.0f : 128.0f ) );
+        } else {
+            return (byte) ( v * 255.0f );
+        }
+    }
+    public static final short float_to_short(float v, boolean dSigned) {
+        if( dSigned ) {
+            return (short) ( v * ( v > 0 ? 32767.0f : 32768.0f ) );
+        } else {
+            return (short) ( v * 65535.0f );
+        }
+    }    
+    public static final int float_to_int(float v, boolean dSigned) {
+        // float significand          0x007fffff
+        // double significand 0x000fffffffffffffL
+        //                  int min = 0x80000000 = -2147483648
+        //                  int max = 0x7fffffff = +2147483647
+        if( dSigned ) {
+            return (int) ( v * ( v > 0 ? 2147483647.0 : 2147483648.0 ) );
+        } else {
+            return (int) (long) ( v * 4294967295.0 );
+        }
+    }
+    
+    public static final byte double_to_byte(double v, boolean dSigned) {
+        // lossy
+        if( dSigned ) {
+            return (byte) ( v * ( v > 0 ? 127.0 : 128.0 ) );
+        } else {
+            return (byte) ( v * 255.0 );
+        }
+    }
+    public static final short double_to_short(double v, boolean dSigned) {
+        // lossy
+        if( dSigned ) {
+            return (short) ( v * ( v > 0 ? 32767.0 : 32768.0 ) );
+        } else {
+            return (short) ( v * 65535.0 );
+        }
+    }
+    public static final int double_to_int(double v, boolean dSigned) {
+        // lossy
+        if( dSigned ) {
+            return (int) ( v * ( v > 0 ? 2147483647.0 : 2147483648.0 ) );
+        } else {
+            return (int) (long) ( v * 4294967295.0 );
+        }
+    }
+    
+    public static final float byte_to_float(byte v, boolean sSigned) {
+        if( sSigned ) {
+            return (v & 0xff) / ( v > 0 ? 127.0f : -128.0f ) ;
+        } else {
+            return (v & 0xff) / 255.0f ;
+        }        
+    }
+    public static final double byte_to_double(byte v, boolean sSigned) {
+        if( sSigned ) {
+            return (v & 0xff) / ( v > 0 ? 127.0 : -128.0 ) ;
+        } else {
+            return (v & 0xff) / 255.0 ;
+        }        
+    }    
+    public static final float short_to_float(short v, boolean sSigned) {
+        if( sSigned ) {
+            return (v & 0xffff) / ( v > 0 ? 32767.0f : -32768.0f ) ;
+        } else {
+            return (v & 0xffff) / 65535.0f ;
+        }        
+    }
+    public static final double short_to_double(short v, boolean sSigned) {
+        // lossy
+        if( sSigned ) {
+            return (v & 0xffff) / ( v > 0 ? 32767.0 : -32768.0 ) ;
+        } else {
+            return (v & 0xffff) / 65535.0 ;
+        }        
+    }    
+    public static final float int_to_float(int v, boolean sSigned) {
+        // lossy
+        // float significand          0x007fffff
+        // double significand 0x000fffffffffffffL
+        //                  int min = 0x80000000 = -2147483648
+        //                  int max = 0x7fffffff = +2147483647
+        if( sSigned ) {
+            return (float) ( v / ( v > 0 ? 2147483647.0 : 2147483648.0 ) );
+        } else {
+            return (float) ( ((long)v & 0xffffffffL) / 4294967295.0 );
+        }        
+    }
+    public static final double int_to_double(int v, boolean sSigned) {
+        if( sSigned ) {
+            return v / ( v > 0 ? 2147483647.0 : 2147483648.0 ) ;
+        } else {
+            return ((long)v & 0xffffffffL) / 4294967295.0 ;
+        }        
+    }
+    
+    public static final short byte_to_short(byte v, boolean sSigned, boolean dSigned) {
+        return float_to_short(byte_to_float(v, sSigned), dSigned);
+    }
+    public static final int byte_to_int(byte v, boolean sSigned, boolean dSigned) {
+        return float_to_int(byte_to_float(v, sSigned), dSigned);
+    }
+    
+    public static final byte short_to_byte(short v, boolean sSigned, boolean dSigned) {
+        return float_to_byte(short_to_float(v, sSigned), dSigned);
+    }
+    public static final int short_to_int(short v, boolean sSigned, boolean dSigned) {
+        return float_to_int(short_to_float(v, sSigned), dSigned);
+    }
+    
+    public static final byte int_to_byte(int v, boolean sSigned, boolean dSigned) {
+        return float_to_byte(int_to_float(v, sSigned), dSigned);
+    }
+    public static final short int_to_short(int v, boolean sSigned, boolean dSigned) {
+        return float_to_short(int_to_float(v, sSigned), dSigned);
+    }
+}
diff --git a/src/junit/com/jogamp/common/util/TestValueConversion.java b/src/junit/com/jogamp/common/util/TestValueConversion.java
new file mode 100644
index 0000000..2a437b8
--- /dev/null
+++ b/src/junit/com/jogamp/common/util/TestValueConversion.java
@@ -0,0 +1,137 @@
+/**
+ * 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.common.util;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+
+import static com.jogamp.common.util.ValueConv.*;
+
+/**
+ * Testing ValueConv's value conversion of primitive types
+ */
+public class TestValueConversion {
+        
+    @Test
+    public void testBaseFloat() {
+        Assert.assertEquals(Byte.MAX_VALUE, float_to_byte( 1.0f, true));
+        Assert.assertEquals(Byte.MIN_VALUE, float_to_byte(-1.0f, true));
+        Assert.assertEquals( 1.0f, byte_to_float( Byte.MAX_VALUE, true));
+        Assert.assertEquals(-1.0f, byte_to_float( Byte.MIN_VALUE, true));
+        
+        Assert.assertEquals(Short.MAX_VALUE, float_to_short( 1.0f, true));
+        Assert.assertEquals(Short.MIN_VALUE, float_to_short(-1.0f, true));
+        Assert.assertEquals( 1.0f, short_to_float( Short.MAX_VALUE, true));
+        Assert.assertEquals(-1.0f, short_to_float( Short.MIN_VALUE, true));
+        
+        Assert.assertEquals(Integer.MAX_VALUE, float_to_int( 1.0f, true));
+        Assert.assertEquals(Integer.MIN_VALUE, float_to_int(-1.0f, true));
+        Assert.assertEquals( 1.0f, int_to_float( Integer.MAX_VALUE, true));
+        Assert.assertEquals(-1.0f, int_to_float( Integer.MIN_VALUE, true));
+                
+        Assert.assertEquals((byte)0xff, float_to_byte( 1.0f, false));
+        Assert.assertEquals( 1.0f, byte_to_float( (byte)0xff, false));
+        
+        Assert.assertEquals((short)0xffff, float_to_short( 1.0f, false));
+        Assert.assertEquals( 1.0f, short_to_float( (short)0xffff, false));
+        
+        Assert.assertEquals(0xffffffff, float_to_int( 1.0f, false));
+        Assert.assertEquals( 1.0f, int_to_float( 0xffffffff, false));
+    }
+        
+    @Test
+    public void testBaseDouble() {
+        Assert.assertEquals(Byte.MAX_VALUE, double_to_byte( 1.0, true));
+        Assert.assertEquals(Byte.MIN_VALUE, double_to_byte(-1.0, true));
+        Assert.assertEquals( 1.0, byte_to_double( Byte.MAX_VALUE, true));
+        Assert.assertEquals(-1.0, byte_to_double( Byte.MIN_VALUE, true));
+        
+        Assert.assertEquals(Short.MAX_VALUE, double_to_short( 1.0, true));
+        Assert.assertEquals(Short.MIN_VALUE, double_to_short(-1.0, true));
+        Assert.assertEquals( 1.0, short_to_double( Short.MAX_VALUE, true));
+        Assert.assertEquals(-1.0, short_to_double( Short.MIN_VALUE, true));
+        
+        Assert.assertEquals(Integer.MAX_VALUE, double_to_int( 1.0, true));
+        Assert.assertEquals(Integer.MIN_VALUE, double_to_int(-1.0, true));
+        Assert.assertEquals( 1.0, int_to_double( Integer.MAX_VALUE, true));
+        Assert.assertEquals(-1.0, int_to_double( Integer.MIN_VALUE, true));
+                
+        Assert.assertEquals((byte)0xff, double_to_byte( 1.0, false));
+        Assert.assertEquals( 1.0, byte_to_double( (byte)0xff, false));
+        
+        Assert.assertEquals((short)0xffff, double_to_short( 1.0, false));
+        Assert.assertEquals( 1.0, short_to_double( (short)0xffff, false));
+        
+        Assert.assertEquals(0xffffffff, double_to_int( 1.0, false));
+        Assert.assertEquals( 1.0, int_to_double( 0xffffffff, false));
+    }
+    
+    @Test
+    public void testConversion() {                        
+        byte sb0 = 127;
+        byte sb1 = -128;
+        
+        float sf0 = byte_to_float(sb0, true);
+        float sf1 = byte_to_float(sb1, true);
+        short ss0 = byte_to_short(sb0, true, true);
+        short ss1 = byte_to_short(sb1, true, true);
+        int si0 = byte_to_int(sb0, true, true);
+        int si1 = byte_to_int(sb1, true, true);
+        
+        Assert.assertEquals(1.0f, sf0);
+        Assert.assertEquals(-1.0f, sf1);
+        Assert.assertEquals(Short.MAX_VALUE, ss0);
+        Assert.assertEquals(Short.MIN_VALUE, ss1);
+        Assert.assertEquals(Integer.MAX_VALUE, si0);
+        Assert.assertEquals(Integer.MIN_VALUE, si1);
+        
+        Assert.assertEquals(sb0, short_to_byte(ss0, true, true));
+        Assert.assertEquals(sb1, short_to_byte(ss1, true, true));
+        Assert.assertEquals(sb0, int_to_byte(si0, true, true));
+        Assert.assertEquals(sb1, int_to_byte(si1, true, true));
+        
+        byte ub0 = (byte) 0xff;
+        float uf0 = byte_to_float(ub0, false);
+        short us0 = byte_to_short(ub0, false, false);
+        int ui0 = byte_to_int(ub0, false, false);
+                
+        Assert.assertEquals(1.0f, uf0);
+        Assert.assertEquals((short)0xffff, us0);
+        Assert.assertEquals(0xffffffff, ui0);
+        
+        Assert.assertEquals(ub0, short_to_byte(us0, false, false));
+        Assert.assertEquals(us0, int_to_short(ui0, false, false));
+    }
+    
+    public static void main(String args[]) {
+        org.junit.runner.JUnitCore.main(TestValueConversion.class.getName());
+    }
+
+}