1 files changed, 142 insertions, 154 deletions

diff --git a/converter/other/fiasco/lib/rpf.c b/converter/other/fiasco/lib/rpf.c
index 84c1f9b6..e6ff6e09 100644
--- a/converter/other/fiasco/lib/rpf.c
+++ b/converter/other/fiasco/lib/rpf.c
@@ -1,10 +1,10 @@
 /*
- *  rpf.c:		Conversion of float to reduced precision format values
+ *  rpf.c:      Conversion of float to reduced precision format values
  *
- *  Written by:		Stefan Frank
- *			Richard Krampfl
- *			Ullrich Hafner
- *		
+ *  Written by:     Stefan Frank
+ *          Richard Krampfl
+ *          Ullrich Hafner
+ *      
  *  This file is part of FIASCO («F»ractal «I»mage «A»nd «S»equence «CO»dec)
  *  Copyright (C) 1994-2000 Ullrich Hafner <hafner@bigfoot.de>
  */
@@ -18,6 +18,7 @@
 
 #include "pm_config.h"
 #include "config.h"
+#include "mallocvar.h"
 
 #include "types.h"
 #include "macros.h"
@@ -26,39 +27,37 @@
 #include "misc.h"
 #include "rpf.h"
 
-/* 
- * CAUTION: The IEEE float format must be used by your compiler,
- *          or all following code is void!
- */
+int const RPF_ZERO = -1;
 
-#if BYTE_ORDER == BIG_ENDIAN
-/*
- *  Big-Endian Architecture (e.g. SUN, Motorola)
- *  Memory representation of integer 0x00112233 is 00,11,22,33
- */
+/*****************************************************************************
 
-enum real_bytes {BYTE_0, BYTE_1, BYTE_2, BYTE_3};
+                   private code
+  
+*****************************************************************************/
 
-#else
-/*
- *  Little-Endian Architecture (e.g. Intel, VAX, Alpha)
- *  Memory representation of integer 0x00112233 is 33,22,11,00
- */
 
-enum real_bytes {BYTE_3, BYTE_2, BYTE_1, BYTE_0};
+typedef struct {
+    double fraction;
+    int    exponent;
+}  FracExp;
 
-#endif
 
-const int RPF_ZERO = -1;
 
-/*****************************************************************************
+static FracExp
+fracExpFromDouble(double const x) {
+
+    FracExp retval;
+
+    retval.fraction = frexp(x, &retval.exponent);
+
+    return retval;
+}
+
 
-			       private code
-  
-*****************************************************************************/
 
 int
-rtob (real_t f, const rpf_t *rpf)
+rtob (real_t        const f,
+      const rpf_t * const rpfP)
 /*
  *  Convert real number 'f' into fixed point format.
  *  The real number in [-'range'; +'range'] is scaled to [-1 ; +1].
@@ -66,111 +65,98 @@ rtob (real_t f, const rpf_t *rpf)
  *  packed into one integer.  
  *
  *  Return value:
- *	real value in reduced precision format
+ *  real value in reduced precision format
  */
 {  
-   unsigned int	mantissa;
-   int		exponent, sign;
-   union
-   {
-      float f;
-      unsigned char c[4];
-   } v;					/* conversion dummy */
-
-   f  /= rpf->range;			/* scale f to [-1,+1] */	
-   v.f = f;
-
-   /*
-    *  Extract mantissa (23 Bits), exponent (8 Bits) and sign (1 Bit)
-    */
-
-   mantissa = ((((v.c[BYTE_1] & 127) << 8 ) | v.c[BYTE_2]) << 8) | v.c[BYTE_3];
-   exponent = (((v.c[BYTE_0] & 127) << 1) | (v.c[BYTE_1] & 128 ? 1 : 0)) - 126;
-   sign     = v.c[BYTE_0] & 128 ? 1 : 0;
-		
-   /*
-    *  Generate reduced precision mantissa.
-    */
-   mantissa >>= 1;				/* shift 1 into from left */
-   mantissa  |= (1 << 22);
-   if (exponent > 0) 
-      mantissa <<= exponent;
-   else
-      mantissa >>= -exponent;  
+    /*
+     *  Extract mantissa (23 Bits), exponent (8 Bits) and sign (1 Bit)
+     */
+
+    double const normalized = f / rpfP->range;
+        /* 'f' scaled to [-1,+1] */    
+    FracExp const fracExp = fracExpFromDouble(normalized);
+    unsigned int const signedMantissa =
+        (unsigned int) (fracExp.fraction * (1<<23));
+
+    unsigned int mantissa;
+    unsigned int sign;  /* 0 for positive; 1 for negative */
+    
+    if (signedMantissa < 0) {
+        mantissa = -signedMantissa;
+        sign = 1;
+    } else {
+        mantissa = +signedMantissa;
+        sign = 0;
+    }
+
+    /*
+     *  Generate reduced precision mantissa.
+     */
+    if (fracExp.exponent > 0) 
+        mantissa <<= fracExp.exponent;
+    else
+        mantissa >>= -fracExp.exponent;  
+    
+    mantissa >>= (23 - rpfP->mantissa_bits - 1);
+
+    mantissa +=  1;          /* Round last bit. */
+    mantissa >>= 1;
    
-   mantissa >>= (23 - rpf->mantissa_bits - 1);
-
-   mantissa +=  1;			/* Round last bit. */
-   mantissa >>= 1;
-   
-   if (mantissa == 0)			/* close to zero */
-      return RPF_ZERO;
-   else if (mantissa >= (1U << rpf->mantissa_bits)) /* overflow */
-      return sign;
-   else
-      return ((mantissa & ((1U << rpf->mantissa_bits) - 1)) << 1) | sign;
+    if (mantissa == 0)           /* close to zero */
+        return RPF_ZERO;
+    else if (mantissa >= (1U << rpfP->mantissa_bits)) /* overflow */
+        return sign;
+    else
+        return ((mantissa & ((1U << rpfP->mantissa_bits) - 1)) << 1) | sign;
 }
 
+
+
 float
-btor (int binary, const rpf_t *rpf)
+btor (int           const binary,
+      const rpf_t * const rpfP)
 /*
  *  Convert value 'binary' in reduced precision format to a real value.
- *  For more information refer to function lin_rtob() above.
+ *  For more information refer to function rtob() above.
  *
  *  Return value:
- *	converted value
+ *  converted value
  */
 {
-   unsigned int	mantissa;
-   int		sign, exponent;
-   union
-   {
-      float f;
-      unsigned char c[4];
-   } value;
-
-   if (binary == RPF_ZERO)
-      return 0;
-
-   if (binary < 0 || binary >= 1 << (rpf->mantissa_bits + 1))
-      error ("Reduced precision format: value %d out of range.", binary);
-
-   /*
-    *  Restore IEEE float format:
-    *  mantissa (23 Bits), exponent (8 Bits) and sign (1 Bit)
-    */
+    unsigned int mantissa;
+    float sign;
+    float f;
+ 
+    if (binary == RPF_ZERO)
+        return 0;
+
+    if (binary < 0 || binary >= 1 << (rpfP->mantissa_bits + 1))
+        error ("Reduced precision format: value %d out of range.", binary);
+
+    /*
+     *  Restore IEEE float format:
+     *  mantissa (23 Bits), exponent (8 Bits) and sign (1 Bit)
+     */
    
-   sign       = binary & 1;
-   mantissa   = (binary & ((1 << (rpf->mantissa_bits + 1)) - 1)) >> 1; 
-   mantissa <<= (23 - rpf->mantissa_bits);
-   exponent   = 0;
-
-   if (mantissa == 0)
-   {
-      value.f = (sign ? -1.0 : 1.0);
-   }
-   else
-   {
-      while (!(mantissa & (1 << 22)))	/* normalize mantissa */
-      {
-	 exponent--;
-	 mantissa <<= 1;
-      }
-      mantissa <<= 1;
-
-      value.c[BYTE_0] = (sign << 7) | ((exponent + 126) >> 1);
-      value.c[BYTE_1] = (((exponent + 126) & 1) << 7)
-			| ((mantissa  >> 16) & 127);
-      value.c[BYTE_2] = (mantissa >> 8) & 255;
-      value.c[BYTE_3] = mantissa & 255;
-   }
+    sign       = (binary & 0x1) == 0 ? 1.0 : -1.0;
+    mantissa   = (binary & ((0x1 << (rpfP->mantissa_bits + 1)) - 1)) >> 1; 
+    mantissa <<= (23 - rpfP->mantissa_bits);
+
+    if (mantissa == 0) 
+        f = sign;
+    else
+        f =  sign * (float) mantissa / 8388608;
    
-   return value.f * rpf->range;		/* expand [ -1 ; +1 ] to
-					   [ -range ; +range ] */
+    return f * rpfP->range;       /* expand [ -1 ; +1 ] to
+                                     [ -range ; +range ] */
 }
 
+
+
+
 rpf_t *
-alloc_rpf (unsigned mantissa, fiasco_rpf_range_e range)
+alloc_rpf (unsigned           const mantissa,
+           fiasco_rpf_range_e const range)
 /*
  *  Reduced precision format constructor.
  *  Allocate memory for the rpf_t structure.
@@ -180,45 +166,47 @@ alloc_rpf (unsigned mantissa, fiasco_rpf_range_e range)
  *  returned. 
  *
  *  Return value
- *	pointer to the new rpf structure
+ *  pointer to the new rpf structure
  */
 {
-   rpf_t *rpf = Calloc (1, sizeof (rpf_t));
+    rpf_t * rpfP;
+
+    MALLOCVAR(rpfP);
    
-   if (mantissa < 2)
-   {
-      warning (_("Size of RPF mantissa has to be in the interval [2,8]. "
-		 "Using minimum value 2.\n"));
-      mantissa = 2;
-   }
-   else if (mantissa > 8)
-   {
-      warning (_("Size of RPF mantissa has to be in the interval [2,8]. "
-		 "Using maximum value 8.\n"));
-      mantissa = 2;
-   }
-
-   rpf->mantissa_bits = mantissa;
-   rpf->range_e       = range;
-   switch (range)
-   {
-      case FIASCO_RPF_RANGE_0_75:
-	 rpf->range = 0.75;
-	 break;
-      case FIASCO_RPF_RANGE_1_50:
-	 rpf->range = 1.50;
-	 break;
-      case FIASCO_RPF_RANGE_2_00:
-	 rpf->range = 2.00;
-	 break;
-      case FIASCO_RPF_RANGE_1_00:
-	 rpf->range = 1.00;
-	 break;
-      default:
-	 warning (_("Invalid RPF range specified. Using default value 1.0."));
-	 rpf->range   = 1.00;
-	 rpf->range_e = FIASCO_RPF_RANGE_1_00;
-	 break;
-   }
-   return rpf;
+    if (mantissa < 2) {
+        warning (_("Size of RPF mantissa has to be in the interval [2,8]. "
+                   "Using minimum value 2.\n"));
+        rpfP->mantissa_bits = 2;
+    } else if (mantissa > 8) {
+        warning (_("Size of RPF mantissa has to be in the interval [2,8]. "
+                   "Using maximum value 8.\n"));
+        rpfP->mantissa_bits = 2;
+    } else
+        rpfP->mantissa_bits = mantissa;
+
+    switch (range) {
+    case FIASCO_RPF_RANGE_0_75:
+        rpfP->range   = 0.75;
+        rpfP->range_e = range;
+        break;
+    case FIASCO_RPF_RANGE_1_50:
+        rpfP->range   = 1.50;
+        rpfP->range_e = range;
+        break;
+    case FIASCO_RPF_RANGE_2_00:
+        rpfP->range   = 2.00;
+        rpfP->range_e = range;
+        break;
+    case FIASCO_RPF_RANGE_1_00:
+        rpfP->range   = 1.00;
+        rpfP->range_e = range;
+        break;
+    default:
+        warning (_("Invalid RPF range specified. Using default value 1.0."));
+        rpfP->range   = 1.00;
+        rpfP->range_e = FIASCO_RPF_RANGE_1_00;
+        break;
+    }
+    return rpfP;
 }
+