summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--make/scripts/runtest.sh3
-rwxr-xr-xsrc/java/com/jogamp/common/nio/Buffers.java93
-rw-r--r--src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java153
3 files changed, 241 insertions, 8 deletions
diff --git a/make/scripts/runtest.sh b/make/scripts/runtest.sh
index 4a1fea3..b494397 100644
--- a/make/scripts/runtest.sh
+++ b/make/scripts/runtest.sh
@@ -38,11 +38,12 @@ function onetest() {
echo
}
-onetest com.jogamp.common.GlueGenVersion 2>&1 | tee -a $LOG
+#onetest com.jogamp.common.GlueGenVersion 2>&1 | tee -a $LOG
#onetest com.jogamp.common.util.TestVersionInfo 2>&1 | tee -a $LOG
#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.TestArrayHashSet01 2>&1 | tee -a $LOG
+onetest com.jogamp.common.nio.TestBuffersFloatDoubleConversion 2>&1 | tee -a $LOG
#onetest com.jogamp.gluegen.PCPPTest 2>&1 | tee -a $LOG
#onetest com.jogamp.gluegen.test.TestPointerBufferEndian 2>&1 | tee -a $LOG
#onetest com.jogamp.gluegen.test.TestStructAccessorEndian 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 7e5f8eb..a1ea320 100755
--- a/src/java/com/jogamp/common/nio/Buffers.java
+++ b/src/java/com/jogamp/common/nio/Buffers.java
@@ -544,22 +544,101 @@ public class Buffers {
// Conversion routines
//
- public static float[] getFloatArray(double[] source) {
- int i=source.length;
- float[] dest = new float[i--];
- while(i>=0) { dest[i]=(float)source[i]; i--; }
+ /**
+ * @param source the source array
+ * @param soffset the offset
+ * @param dest the target array, if null, a new array is being created with size len.
+ * @param doffset the offset in the dest array
+ * @param len the payload of elements to be copied, if <code>len < 0</code> then <code>len = source.length - soffset</code>
+ * @return the passed or newly created target array
+ */
+ public static float[] getFloatArray(double[] source, int soffset, float[] dest, int doffset, int len) {
+ if(0>len) {
+ len = source.length - soffset;
+ }
+ if(len > source.length - soffset) {
+ throw new IllegalArgumentException("payload ("+len+") greater than remaining source bytes [len "+source.length+", offset "+soffset+"]");
+ }
+ if(null==dest) {
+ dest = new float[len];
+ doffset = 0;
+ }
+ if(len > dest.length - doffset) {
+ throw new IllegalArgumentException("payload ("+len+") greater than remaining dest bytes [len "+dest.length+", offset "+doffset+"]");
+ }
+ for(int i=0; i<len; i++) {
+ dest[doffset+i] = (float) source[soffset+i];
+ }
return dest;
}
- public final static FloatBuffer getFloatBuffer(DoubleBuffer source) {
- source.rewind();
- FloatBuffer dest = newDirectFloatBuffer(source.limit());
+ /**
+ * No rewind or repositioning is performed.
+ * @param source the source buffer, which elements from it's current position and it's limit are being copied
+ * @param dest the target buffer, if null, a new buffer is being created with size </code>source.remaining()</code>
+ * @return the passed or newly created target buffer
+ */
+ public static FloatBuffer getFloatBuffer(DoubleBuffer source, FloatBuffer dest) {
+ if(null == dest) {
+ dest = newDirectFloatBuffer(source.remaining());
+ }
+ if( dest.remaining() < source.remaining() ) {
+ throw new IllegalArgumentException("payload ("+source.remaining()+") is greater than remaining dest bytes: "+dest.remaining());
+ }
while (source.hasRemaining()) {
dest.put((float) source.get());
}
return dest;
}
+ /**
+ * @param source the source array
+ * @param soffset the offset
+ * @param dest the target array, if null, a new array is being created with size len.
+ * @param doffset the offset in the dest array
+ * @param len the payload of elements to be copied, if <code>len < 0</code> then <code>len = source.length - soffset</code>
+ * @return the passed or newly created target array
+ */
+ public static double[] getDoubleArray(float[] source, int soffset, double[] dest, int doffset, int len) {
+ if(0>len) {
+ len = source.length - soffset;
+ }
+ if(len > source.length - soffset) {
+ throw new IllegalArgumentException("payload ("+len+") greater than remaining source bytes [len "+source.length+", offset "+soffset+"]");
+ }
+ if(null==dest) {
+ dest = new double[len];
+ doffset = 0;
+ }
+ if(len > dest.length - doffset) {
+ throw new IllegalArgumentException("payload ("+len+") greater than remaining dest bytes [len "+dest.length+", offset "+doffset+"]");
+ }
+ for(int i=0; i<len; i++) {
+ dest[doffset+i] = (double) source[soffset+i];
+ }
+ return dest;
+ }
+
+ /**
+ * No rewind or repositioning is performed.
+ * @param source the source buffer, which elements from it's current position and it's limit are being copied
+ * @param dest the target buffer, if null, a new buffer is being created with size </code>source.remaining()</code>
+ * @return the passed or newly created target buffer
+ */
+ public static DoubleBuffer getDoubleBuffer(FloatBuffer source, DoubleBuffer dest) {
+ if(null == dest) {
+ dest = newDirectDoubleBuffer(source.remaining());
+ }
+ if( dest.remaining() < source.remaining() ) {
+ throw new IllegalArgumentException("payload ("+source.remaining()+") is greater than remaining dest bytes: "+dest.remaining());
+ }
+ while (source.hasRemaining()) {
+ dest.put((double) source.get());
+ }
+ return dest;
+ }
+
+
//----------------------------------------------------------------------
// Convenient put methods with generic target Buffer
//
diff --git a/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java b/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java
new file mode 100644
index 0000000..0555578
--- /dev/null
+++ b/src/junit/com/jogamp/common/nio/TestBuffersFloatDoubleConversion.java
@@ -0,0 +1,153 @@
+/**
+ * Copyright 2010 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.nio;
+
+import java.io.IOException;
+import org.junit.Assert;
+
+import org.junit.Test;
+
+public class TestBuffersFloatDoubleConversion {
+
+ public static boolean cmpFloatArray(float[] d1, int d1_offset, float[] d2, int d2_offset, int len) {
+ if( d1.length - d1_offset < len) {
+ throw new RuntimeException("d1 too small len "+len+" > "+d1.length+" - "+d1_offset);
+ }
+ if( d2.length - d2_offset < len) {
+ throw new RuntimeException("d2 too small len "+len+" > "+d2.length+" - "+d2_offset);
+ }
+ boolean ok = true;
+ for(int i=0; ok && i<len; i++) {
+ ok = d1[d1_offset+i] == d2[d2_offset+i] ;
+ }
+ return ok;
+ }
+
+ public static boolean cmpDoubleArray(double[] d1, int d1_offset, double[] d2, int d2_offset, int len) {
+ if( d1.length - d1_offset < len) {
+ throw new RuntimeException("d1 too small len "+len+" > "+d1.length+" - "+d1_offset);
+ }
+ if( d2.length - d2_offset < len) {
+ throw new RuntimeException("d2 too small len "+len+" > "+d2.length+" - "+d2_offset);
+ }
+ boolean ok = true;
+ for(int i=0; ok && i<len; i++) {
+ ok = d1[d1_offset+i] == d2[d2_offset+i] ;
+ }
+ return ok;
+ }
+
+ public static void incrFloatArray(float[] data, int offset, int len) {
+ if( data.length - offset < len) {
+ throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+ }
+ for(int i=0; i<len; i++) {
+ data[offset+i] += 1;
+ }
+ }
+
+ public static void incrDoubleArray(double[] data, int offset, int len) {
+ if( data.length - offset < len) {
+ throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+ }
+ for(int i=0; i<len; i++) {
+ data[offset+i] += 1;
+ }
+ }
+
+ public static void setFloatArray(float[] data, int offset, int len) {
+ if( data.length - offset < len) {
+ throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+ }
+ for(int i=0; i<len; i++) {
+ data[offset+i] = i;
+ }
+ }
+
+ public static void setDoubleArray(double[] data, int offset, int len) {
+ if( data.length - offset < len) {
+ throw new RuntimeException("data too small len "+len+" > "+data.length+" - "+offset);
+ }
+ for(int i=0; i<len; i++) {
+ data[offset+i] = i;
+ }
+ }
+
+ public static void doItDoubleArray01(double[] data, int offset, int len) {
+ float[] f_data = Buffers.getFloatArray(data, offset, null, 0, len);
+ incrFloatArray(f_data, 0, len);
+ Buffers.getDoubleArray(f_data, 0, data, offset, len);
+ }
+
+ @Test
+ public void testDoubleArray2FloatArrayAndBack01() {
+ final int offset = 50;
+ final int len = 20;
+
+ // reference 1
+ float[] fa_ref = new float[100];
+ setFloatArray(fa_ref, offset, len);
+ incrFloatArray(fa_ref, offset, len);
+
+ // reference 2
+ double[] da_ref = new double[100];
+ setDoubleArray(da_ref, offset, len);
+ incrDoubleArray(da_ref, offset, len);
+
+ // test 1: forth and back .. double -> float -> double
+ {
+ double[] da1 = new double[100];
+ setDoubleArray(da1, offset, len);
+ incrDoubleArray(da1, offset, len);
+
+ // conv_forth: double[offset..len] -> float[0..len]
+ float[] f_da1 = Buffers.getFloatArray(da1, offset, null, 0, len);
+ Assert.assertTrue(cmpFloatArray(fa_ref, offset, f_da1, 0, len));
+
+ // conv_back: float[0..len] -> double[offset..len]
+ Buffers.getDoubleArray(f_da1, 0, da1, offset, len);
+ Assert.assertTrue(cmpDoubleArray(da_ref, offset, da1, offset, len));
+ }
+
+ // test 2: forth, incr, back .. double -> float -> incr -> double
+ {
+ double[] da1 = new double[100];
+ setDoubleArray(da1, offset, len);
+
+ doItDoubleArray01(da1, offset, len);
+ Assert.assertTrue(cmpDoubleArray(da_ref, offset, da1, offset, len));
+ }
+ }
+
+ public static void main(String args[]) throws IOException {
+ String tstname = TestBuffersFloatDoubleConversion.class.getName();
+ org.junit.runner.JUnitCore.main(tstname);
+ }
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-01 21:24:02 +0000