Split source files, merge public header files, eliminite use gpp, rewrite makefile

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 184 insertions, 0 deletions

diff --git a/libgamma_internal_translate_to_64.c b/libgamma_internal_translate_to_64.c
new file mode 100644
index 0000000..3733186
--- /dev/null
+++ b/libgamma_internal_translate_to_64.c
@@ -0,0 +1,184 @@
+/* See LICENSE file for copyright and license details. */
+#include "common.h"
+
+
+/**
+ * Just an arbitrary version
+ */
+#define ANY bits64
+
+/**
+ * Concatenation of all ramps
+ */
+#define ALL red
+
+
+/**
+ * Preform installation in an `for (i = 0; i < n; i++)`
+ * loop and do a `break` afterwords
+ */
+#define __translate(instruction)  for (i = 0; i < n; i++) instruction;  break
+
+
+/**
+ * Convert a [0, 1] `float` to a full range `uint64_t`
+ * and mark sure rounding errors does not cause the
+ * value be 0 instead of ~0 and vice versa
+ * 
+ * @param   value  To `float` to convert
+ * @return         The value as an `uint64_t`
+ */
+static uint64_t
+float_to_64(float value)
+{
+	/* TODO Which is faster? */
+  
+#if defined(HAVE_INT128) && __WORDSIZE == 64
+	/* `__int128` is a GNU C extension, which
+	   (because it is not ISO C) emits a warning
+	   under -pedantic */
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+
+	/* In GCC we can use `__int128`, this is
+	   a signed 128-bit integer. It fits all
+	   uint64_t values but also native values,
+	   which is a nice because it eleminates
+	   some overflow condition tests. It is
+	   also more readable. */
+
+	/* Convert to integer */
+	__int128 product = (__int128)(value * (float)UINT64_MAX);
+	/* Negative overflow */
+	if (product > UINT64_MAX)
+		return UINT64_MAX;
+	/* Positive overflow */
+	if (product < 0)
+		return 0;
+	/* Did not overflow */
+	return (uint64_t)product;
+
+# pragma GCC diagnostic pop
+#else
+
+	/* If we are not using GCC we cannot be
+	   sure that we have `__int128` so we have
+	   to use `uint64_t` and perform overflow
+	   checkes based on the input value */
+  
+	/* Convert to integer. */
+	uint64_t product = (uint64_t)(value * (float)UINT64_MAX);
+	/* Negative overflow,
+	   if the input is less than 0.5 but
+	   the output is greater then we got
+	   -1 when we should have gotten 0 */
+	if (value < 0.1f && product > 0xF000000000000000ULL)
+		return 0;
+	/* Positive overflow,
+	   if the input is greater than 0.5
+	   but the output is less then we got
+	   0 when we should have gotten ~0 */
+	else if (value > 0.9f && product < 0x1000000000000000ULL)
+		return (uint64_t)~0;
+	/* Did not overflow */
+	return product;
+
+#endif
+}
+
+
+/**
+ * Convert a [0, 1] `double` to a full range `uint64_t`
+ * and mark sure rounding errors does not cause the
+ * value be 0 instead of ~0 and vice versa
+ * 
+ * @param   value  To `double` to convert
+ * @return         The value as an `uint64_t`
+ */
+static uint64_t
+double_to_64(double value)
+{
+	/* TODO Which is faster? */
+
+#if defined(HAVE_INT128) && __WORDSIZE == 64
+	/* `__int128` is a GNU C extension, which
+	   (because it is not ISO C) emits a warning
+	   under -pedantic */
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wpedantic"
+
+	/* In GCC we can use `__int128`, this is
+	   a signed 128-bit integer. It fits all
+	   uint64_t values but also native values,
+	   which is a nice because it eleminates
+	   some overflow condition tests. It is
+	   also more readable. */
+
+	/* Convert to integer */
+	__int128 product = (__int128)(value * (double)UINT64_MAX);
+	/* Negative overflow */
+	if (product > UINT64_MAX)
+		return UINT64_MAX;
+	/* Positive overflow */
+	if (product < 0)
+		return 0;
+	/* Did not overflow */
+	return (uint64_t)product;
+
+# pragma GCC diagnostic pop
+#else
+
+	/* If we are not using GCC we cannot be
+	   sure that we have `__int128` so we have
+	   to use `uint64_t` and perform overflow
+	   checkes based on the input value. */
+
+	/* Convert to integer. */
+	uint64_t product = (uint64_t)(value * (double)UINT64_MAX);
+	/* Negative overflow,
+	   if the input is less than 0.5 but
+	   the output is greater then we got
+	   -1 when we should have gotten 0 */
+	if (value < (double)0.1f && product > 0xF000000000000000ULL)
+		product = 0;
+	/* Positive overflow,
+	   if the input is greater than 0.5
+	   but the output is less then we got
+	   0 when we should have gotten ~0 */
+	else if ((value > (double)0.9f) && (product < 0x1000000000000000ULL))
+		product = (uint64_t)~0;
+	/* Did not overflow */
+	return product;
+
+#endif
+}
+
+
+/**
+ * Convert any set of gamma ramps into a 64-bit integer array with all channels
+ * 
+ * @param  depth  The depth of the gamma ramp, `-1` for `float`, `-2` for `double`
+ * @param  n      The grand size of gamma ramps (sum of all channels' sizes)
+ * @param  out    Output array
+ * @param  in     Input gamma ramps
+ */
+void
+libgamma_internal_translate_to_64(signed depth, size_t n, uint64_t *restrict out, gamma_ramps_any_t in)
+{
+	size_t i;
+	switch (depth) {
+	/* Translate integer */
+	case  8:  __translate(out[i] = (uint64_t)(in.bits8. ALL[i]) * 0x0101010101010101ULL);
+	case 16:  __translate(out[i] = (uint64_t)(in.bits16.ALL[i]) * 0x0001000100010001ULL);
+	case 32:  __translate(out[i] = (uint64_t)(in.bits32.ALL[i]) * 0x0000000100000001ULL);
+	/* Identity translation */
+	case 64:  __translate(out[i] = in.bits64.ALL[i]);
+	/* Translate floating point */
+	case -1:  __translate(out[i] =  float_to_64(in.float_single.ALL[i]));
+	case -2:  __translate(out[i] = double_to_64(in.float_double.ALL[i]));
+	default:
+		/* This is not possible */
+		abort();
+		break;
+	}
+}