pfi.c

Go to the documentation of this file.

/*
 * Implementation of the PFI library, a portable format to store 
 * images with a double representation for every pixel of the same 
 * color...
 *
 * $Date$
 * $Revision$
 *
 */

#include "pfi.h"
#include <stdio.h>
#include <math.h>
#include <float.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdarg.h>
#include <errno.h>

#define SIZE_CHECK(type,size,name) \
  typedef type name[(sizeof (type) == size)*2-1]

SIZE_CHECK (pfiu32, 4, bar);
SIZE_CHECK (pfiu16, 2, foobar);

/* Example:
 * +-------------------------------------------------------------
 * | PFI
 * | # file123.pfi
 * | # number of rows:
 * | 512
 * | # number of columns:
 * | 512
 * | # number of colors and colormodel:
 * | 3 1
 * | # binary data starts...
 * | ...
 * +-------------------------------------------------------------
 */
#ifdef TEST
int main (void);
#endif

static void double2pfi (double val, /*@exposed@*//*@out@*/pfiu32 *results);
static int pfi2double (pfiu32 *coded, /*@exposed@*//*@out@*/double *res);
static int numexpect (char *bufp, int expect);
static void skipwhite (/*@exposed@*/char **pos);

#define PIXEL_PFIS 7

#define DPRINTF(x)
#if !defined (NDEBUG) && !defined (DPRINTF)
static int 
debug_printf (const char *tmpl, ...)
{
  va_list ap;
  int result;

  va_start (ap, tmpl);
  result = vfprintf (stderr, tmpl, ap);
  va_end (ap);
  return result;
}

#define STRR(X) #X
#define STR(X) STRR(X)
#define DPRINTF(X) \
  (debug_printf("DEBUG %s [%s]: ", __FILE__, STR(__LINE__)), debug_printf X)

#else /* NDEBUG */

#ifndef DPRINTF
#define DPRINTF(x)
#endif

#endif /* NDEBUG */

#ifdef TEST
int 
main (void)
{
  double d1 = sqrt (2), d2;
  pfiu32 results[PIXEL_PFIS];
  double ar[9];
  FILE *stream = NULL;
  double *res;
  int rows, cols, colors, colormodel, i, size;
  
  ar[0] = sqrt (2); 
  ar[1] = sqrt (3);
  ar[2] = sqrt (5);
  ar[3] = sqrt (6);
  ar[4] = sqrt (7);
  ar[5] = sqrt (8);
  ar[6] = sqrt (10);
  ar[7] = sqrt (11);
  ar[8] = sqrt (12);

  printf ("From ze test its beginnink...\n");

  /*
   * Testing the internal functions...
   */
  assert (numexpect (" 12 12 ", 2) == 2);
  assert (numexpect ("12", 2) == -1);
  assert (numexpect (" 12 12 12", 2) == -1);
  assert (numexpect (" 1a2 12 ", 2) == -1);
  assert (numexpect ("12 a12 ", 1) == -1);
  
  DPRINTF (("main: d1: %1.52f\n", d1));
  double2pfi (d1, results);
  (void)pfi2double (results, &d2);
  DPRINTF (("main: d1: %1.60f\n", d1));
  DPRINTF (("main: d2: %1.60f\n", d2));
  assert (fabs (d2 - d1) < 2*PFI_EPSILON);
  d1 *= -1.0;
  double2pfi (d1, results);
  (void)pfi2double (results, &d2);
  DPRINTF (("main: d1: %1.60f\n", d1));
  DPRINTF (("main: d2: %1.60f\n", d2));
  assert (fabs (d2 - d1) < PFI_EPSILON);
  d1 = 0.1230;
  double2pfi (d1, results);
  (void)pfi2double (results, &d2);
  assert (fabs (d2 - d1) < PFI_EPSILON);
  d1 = 10.1230;
  double2pfi (d1, results);
  (void)pfi2double (results, &d2);
  DPRINTF (("main: d1: %1.60f\n", d1));
  DPRINTF (("main: d2: %1.60f\n", d2));
  assert (fabs (d2 - d1) < PFI_EPSILON);

  /*
   * Testing the file functions...
   */
  if (pfi_write_name ("test.pfi", ar, 3, 3, 1, 0) < 0)
    {
      perror ("writing data to file");
      return 1;
    }
  
  printf ("File just created...\n");
  if (pfi_properties_name ("test.pfi", &rows, &cols, 
                           &colors, &colormodel) < 0)
    {
      perror ("rading image properties");
      return 1;
    }
  res = malloc (rows * cols * colors * sizeof (*res));
  if (pfi_read_name ("test.pfi", rows, cols, colors, res) < 0)
    {
      perror ("reading data from file");
      return 1;
    }

  assert (rows == 3);
  assert (cols == 3);
  assert (colors == 1);
  assert (colormodel == 0);
  
  size = rows*cols*colors;
  for (i = 0; i < size; i++)
    {
      DPRINTF (("res[%d]: %f == ar[%d]: %f?\n", i, res[i], i, ar[i]));
      assert (fabs (res[i] - ar[i]) < PFI_EPSILON);
    }
  free (res);
  printf ("...kewl\n");
  
  printf ("File with DOS-style line ends...\n");
  if (pfi_properties_name ("crlf.pfi", &rows, &cols, 
                           &colors, &colormodel) < 0)
    {
      perror ("rading image properties");
      return 1;
    }
  res = malloc (rows * cols * colors * sizeof (*res));
  if (pfi_read_name ("crlf.pfi", rows, cols, colors, res) < 0)
    {
      perror ("reading data from file");
      return 1;
    }
  assert (rows == 3);
  assert (cols == 3);
  assert (colors == 1);
  assert (colormodel == 0);
  
  size = rows*cols*colors;
  for (i = 0; i < size; i++)
    {
      DPRINTF (("res[%d]: %f == ar[%d]: %f?\n", i, res[i], i, ar[i]));
      assert (fabs (res[i] - ar[i]) < PFI_EPSILON);
    }
  free (res);
  printf ("...kewl\n");
  
  printf ("File with rgb colors...\n");
  if (pfi_properties_name ("colors.pfi", &rows, &cols, 
                           &colors, &colormodel) < 0)
    {
      perror ("rading image properties");
      return 1;
    }
  res = malloc (rows * cols * colors * sizeof (*res));
  if (pfi_read_name ("colors.pfi", rows, cols, colors, res) < 0)
    {
      perror ("reading data from file");
      return 1;
    }
  assert (rows == 2);
  assert (cols == 2);
  assert (colors == 3);
  assert (colormodel == 1);
  free (res);
  printf ("...kewl\n");

  printf ("File with excessive comments...\n");
  if (pfi_properties_name ("comments.pfi", &rows, &cols, 
                           &colors, &colormodel) < 0)
    {
      perror ("rading image properties");
      return 1;
    }
  res = malloc (rows * cols * colors * sizeof (*res));
  if (pfi_read_name ("comments.pfi", rows, cols, colors, res) < 0)
    {
      perror ("reading data from file");
      return 1;
    }
  assert (rows == 3);
  assert (cols == 3);
  assert (colors == 1);
  assert (colormodel == 0);
  
  size = rows*cols*colors;
  for (i = 0; i < size; i++)
    {
      printf ("res[%d]: %f == ar[%d]: %f?\n", i, res[i], i, ar[i]);
      assert (fabs (res[i] - ar[i]) < PFI_EPSILON);
    }
  free (res);
  printf ("...kewl\n");

#if !defined _MSC_VER && !defined __WATCOMC__
  /* test of error checking disabled since pfi_read is not in the 
   * DLL exports */
  /*
   * Error checking for the input file...
   */
  printf ("Error checking...\n");
  if ((stream = fopen ("invalid1.pfi", "rb")) == NULL)
    {
      perror ("opening file");
      return 1;
    }
  
  if ((res = pfi_read (stream, &rows, &cols, &colors, &colormodel)) == NULL)
    {
      perror ("Expected error found");
    }
  else
    {
      assert (0);
    }
  
  fclose (stream);
  if ((stream = fopen ("invalid2.pfi", "rb")) == NULL)
    {
      perror ("opening file");
      return 1;
    }
  if ((res = pfi_read (stream, &rows, &cols, &colors, &colormodel)) == NULL)
    {
      perror ("Expected error found");
    }
  else
    {
      assert (0);
    }

  fclose (stream);
  if ((stream = fopen ("invalid3.pfi", "rb")) == NULL)
    {
      perror ("opening file");
      return 1;
    }
  if ((res = pfi_read (stream, &rows, &cols, &colors, &colormodel)) == NULL)
    {
      perror ("Expected error found");
    }
  else
    {
      assert (0);
    }

  fclose (stream);
  if ((stream = fopen ("invalid4.pfi", "rb")) == NULL)
    {
      perror ("opening file");
      return 1;
    }
  if ((res = pfi_read (stream, &rows, &cols, &colors, &colormodel)) == NULL)
    {
      perror ("Expected error found");
    }
  else
    {
      assert (0);
    }

  fclose (stream);
  if ((stream = fopen ("invalid5.pfi", "rb")) == NULL)
    {
      perror ("opening file");
      return 1;
    }
  if ((res = pfi_read (stream, &rows, &cols, &colors, &colormodel)) == NULL)
    {
      perror ("Expected error found");
    }
  else
    {
      assert (0);
    }
  fclose (stream);
#endif
  printf ("...kewl\n");
  printf ("From ze test its end...\n");
  return 0;
}

#else /* TEST */

static int skipcomments (FILE *stream);
static int pfi_read_internal (FILE *, int, int, int, /*@out@*/double *);

int 
pfi_getv (FILE *stream, /*@exposed@*//*@out@*/double *valp)
{
  pfiu32 results[PIXEL_PFIS];
  pfiu16 *tmp;
  
  int i;
  
  if (fread (results, sizeof (*results), PIXEL_PFIS, stream) != PIXEL_PFIS)
    {
      DPRINTF (("pfi_getv: fread failed."));
      /*@-mustdefine@*/
      return -1;
      /*@=mustdefine@*/
    }
  DPRINTF (("pfi_getv: 1st original byte is: 0x%02x\n", ((char*)results)[0]));
  DPRINTF (("pfi_getv: 2nd original byte is: 0x%02x\n", ((char*)results)[1]));
  DPRINTF (("pfi_getv: 3st original byte is: 0x%02x\n", ((char*)results)[2]));
  DPRINTF (("pfi_getv: 4nd original byte is: 0x%02x\n", ((char*)results)[3]));
  for (i = 0; i < 2; i++)
    {
      tmp = &((pfiu16*)results)[i];
      *tmp = pfi_ftoh16 (*tmp);
    }
  for (i = 1; i < PIXEL_PFIS; i++)
    {
      results[i] = pfi_ftoh32 (results[i]);
    }
  DPRINTF (("pfi_getv: 1st swapped byte is: 0x%02x\n", ((char*)results)[0]));
  DPRINTF (("pfi_getv: 2nd swapped byte is: 0x%02x\n", ((char*)results)[1]));
  DPRINTF (("pfi_getv: 3st swapped byte is: 0x%02x\n", ((char*)results)[2]));
  DPRINTF (("pfi_getv: 4nd swapped byte is: 0x%02x\n", ((char*)results)[3]));

  return pfi2double (results, valp);
}

int 
pfi_putv (FILE *stream, double val)
{
  pfiu32 values[PIXEL_PFIS];
  pfiu16 *tmp;
  int i;
  
  double2pfi (val, values);

  DPRINTF (("pfi_putv: 1st original byte is: 0x%02x\n", ((char*)values)[0]));
  DPRINTF (("pfi_putv: 2nd original byte is: 0x%02x\n", ((char*)values)[1]));
  DPRINTF (("pfi_putv: 3st original byte is: 0x%02x\n", ((char*)values)[2]));
  DPRINTF (("pfi_putv: 4nd original byte is: 0x%02x\n", ((char*)values)[3]));
  for (i = 0; i < 2; i++)
    {
      tmp = &((pfiu16*)values)[i];
      *tmp = pfi_htof16 (*tmp);
    }
  for (i = 1; i < PIXEL_PFIS; i++)
    {
      values[i] = pfi_htof32 (values[i]);
    }
  DPRINTF (("pfi_putv: 1st swapped byte is: 0x%02x\n", ((char*)values)[0]));
  DPRINTF (("pfi_putv: 2nd swapped byte is: 0x%02x\n", ((char*)values)[1]));
  DPRINTF (("pfi_putv: 3st swapped byte is: 0x%02x\n", ((char*)values)[2]));
  DPRINTF (("pfi_putv: 4nd swapped byte is: 0x%02x\n", ((char*)values)[3]));
  
  if (fwrite (values, sizeof (*values), PIXEL_PFIS, stream) != PIXEL_PFIS)
    {
      return -1;
    }
  
  return 0;
}

int
pfi_properties (FILE *stream, int *rows, int *cols, 
                int *colors, int *colormodel)
{
  enum { s_pfi, s_rows, s_cols, s_colors, s_done, s_error };
  int state = s_pfi;
  int ch;
  char buf[256];
  char *crlf;
      
  /*@-infloops@*/
  while (state < s_done)
  /*@=infloops@*/
    {
      switch (state)
        {
        case s_pfi: 
          DPRINTF (("pfi_properties: s_pfi\n"));
          if (fgets (buf, (int) sizeof buf, stream) == NULL)
            {
              DPRINTF (("OOPS\n"));
              state = s_error;
              break;
            }
          while ((crlf = strchr (buf, '\n')) != NULL)
            {
              *crlf = '\0';
            }
          while ((crlf = strchr (buf, '\r')) != NULL)
            {
              *crlf = '\0';
            }
          
          if (strcmp (buf, "PFI") != 0)
            {
              state = s_error;
              break;
            }
          state = s_rows;
          break;

        case s_rows: 
          DPRINTF (("pfi_properties: s_rows\n"));
          ch = skipcomments (stream);
          (void)ungetc (ch, stream);
          if (fgets (buf, (int) sizeof buf, stream) == NULL)
            {
              state = s_error;
              break;
            }
          if (numexpect (buf, 1) != 1)
            {
              state = s_error;
              break;
            }
          (void)sscanf (buf, "%d", rows);
          if (*rows < 1)
            {
              state = s_error;
              break;
            }
          
          state = s_cols;
          break;

        case s_cols: 
          DPRINTF (("pfi_properties: s_cols\n"));
          ch = skipcomments (stream);
          (void)ungetc (ch, stream);
          if (fgets (buf, (int) sizeof buf, stream) == NULL)
            {
              state = s_error;
              break;
            }
          if (numexpect (buf, 1) != 1)
            {
              state = s_error;
              break;
            }
          (void)sscanf (buf, "%d", cols);
          if (*cols < 1)
            {
              state = s_error;
              break;
            }
          state = s_colors;
          break;

        case s_colors: 
          DPRINTF (("pfi_properties: s_colors\n"));
          ch = skipcomments (stream);
          (void)ungetc ((char)ch, stream);
          if (fgets (buf, (int) sizeof buf, stream) == NULL)
            {
              state = s_error;
              break;
            }
          if (numexpect (buf, 2) == 2)
            {
              (void)sscanf (buf, "%d%d", colors, colormodel);
            }
          else if (numexpect (buf, 1) == 1)
            {
              (void)sscanf (buf, "%d", colors);
              *colormodel = 0;
            }
          else
            {
              state = s_error;
              break;
            }
          if (*colors < 1 || (*colors < 3 && *colormodel > 0))
            {
              state = s_error;
              break;
            }

          state = s_done;
          break;

        default:
          state = s_error;
          break;
        }
    }

  if (state == s_error)
    {
#ifdef EINVAL
      errno = EINVAL;
#endif
      return -1;
    }
  
  return state == s_done? 0: -1;
}

double *
pfi_read (FILE *stream, int *rows, int *cols, int *colors, int *colormodel)
{
  double *res = NULL;
  
  DPRINTF (("pfi_read: s_properties\n"));
  if (pfi_properties (stream, rows, cols, colors, colormodel) < 0)
    {
      return NULL;
    }

  if ((res = malloc ((*rows)*(*cols)*(*colors)*sizeof (*res))) == NULL)
    {
      return NULL;
    }
  if (pfi_read_internal (stream, *rows, *cols, *colors, res) < 0)
    {
      free (res);
      return NULL;
    }
  return res;
}


int 
pfi_write (FILE *stream, double *buf, int rows, 
           int cols, int colors, int colormodel, char *fname)
{
  int pixel, color, size;
  
  /*
   * Write the header...
   */
  if (fprintf (stream, "PFI\n#%s\n%d\n%d\n%d %d\n", 
               fname, rows, cols, colors, colormodel) < 0)
    {
      return -1;
    }

  /*
   * And the rest...
   */
  size = rows * cols;
  for (pixel = 0; pixel < size; pixel++)
    {
      for (color = 0; color < colors; color++)
        {
          if (pfi_putv (stream, buf[colors*pixel+color]) < 0)
            {
              return -1;
            }
        }
    }

  return 0;
}
  
DLL_EXPORT int
pfi_read_name (char *name, int rows, int cols, int colors, double *result)
{
  FILE *handle = NULL;
  int rc = 0;

  if (name == NULL)
    {
      handle = stdin;
    }
  else
    {
      if ((handle = fopen (name, "rb")) == NULL)
        {
          return -1;
        }
    }

  rc = pfi_read_internal (handle, rows, cols, colors, result);

  if (handle != stdin)
    {
      (void)fclose (handle);
    }

  return rc;
}


DLL_EXPORT int 
pfi_write_name (char *name, double *buf, int rows, int cols, 
                int colors, int colormodel)
{
  FILE *handle = NULL;
  int rc = 0;

  if (name == NULL)
    {
      handle = stdin;
      rc = pfi_write (handle, buf, rows, cols, colors, colormodel, "stdin");
    }
  else
    {
      if ((handle = fopen (name, "wb")) == NULL)
        {
          return -1;
        }
      rc = pfi_write (handle, buf, rows, cols, colors, colormodel, name);
    }

  if (handle != stdin)
    {
      (void)fclose (handle);
    }

  return rc;
}

DLL_EXPORT int 
pfi_properties_name (char *name, int *rows, int *cols, 
                     int *colors, int *colormodel)
{
  int rc = 0;
  FILE *handle = NULL;

  if (name == NULL)
    {
      handle = stdin;
    }
  else
    {
      if ((handle = fopen (name, "rb")) == NULL)
        {
          return -1;
        }
    }

  rc = pfi_properties (handle, rows, cols, colors, colormodel);

  if (handle != stdin)
    {
      (void)fclose (handle);
    }

  return rc;
}

static int 
skipcomments (FILE *stream)
{
  int ch;
  /*
   * Skip comments...
   */
  do
    {
      ch = fgetc (stream);
    }
  while (isspace (ch));
      
  while ((ch == (int)'#')) 
    {
      while (ch != (int)'\n') 
        { 
          if ((ch = fgetc (stream)) == EOF)
            {
              return ch;
            }
        }
      while (ch <  (int)' ' ) 
        { 
          if ((ch = fgetc (stream)) == EOF)
            {
              return ch;
            }
        }
    }
  return ch;
}

static int
pfi_read_internal (FILE *stream, int rows, int cols, int colors, 
                   /*@out@*/double *res)
{
  enum { s_read, s_done, s_error };
  int state = s_read;
  int pixel, color, size;
  long fpos;
      
  /*@-infloops@*/
  while (state < s_done)
  /*@=infloops@*/
    {
      switch (state)
        {
        case s_read: 
          DPRINTF (("pfi_read: s_read\n"));

          size = rows * cols;
          state = s_done;
          fpos = -1l * (long)size * (long)colors 
            * (long)PIXEL_PFIS * (long) sizeof (pfiu32);
          DPRINTF (("fpos: %ld\n", fpos));
          (void)fseek(stream, fpos, SEEK_END);

          for (pixel = 0; pixel < size && state != s_error; pixel++)
            {
              for (color = 0; color < colors; color++)
                {
                  if (pfi_getv (stream, &res[colors*pixel+color]) < 0)
                    {
                      state = s_error;
                      DPRINTF (("pfi_read: s_read: upsa!\n"));
                      break;
                    }
                }
            }
          break;
          
        default:
          state = s_error;
          break;
        }
    }

  /*@-mustdefine@*/
  if (state == s_error)
    {
#ifdef EINVAL
      errno = EINVAL;
#endif
      return -1;
    }
  
  return state == s_done? 0: -1;
  /*@=mustdefine@*/
}

#endif /* TEST */

static void 
double2pfi (double val, /*@exposed@*//*@out@*/pfiu32 *results)
{
  char buf[64];
  char *start;
  int i;
  pfiu16 *highp = (pfiu16*)results;
  pfiu16 *expnp = (pfiu16*)results + 1;

  DPRINTF (("double2pfi ()\n"));
  DPRINTF (("double2pfi: %+.54e\n", val));
  (void)snprintf (buf, sizeof buf, "%+.54e", val);
  /*DPRINTF (("double2pfi: %s\n", buf));*/

  start = strchr (buf, 'e');
  /*@-nullderef@*/
  assert (start[0] != '\0');
  start[0] = '\0';
  /*@=nullderef@*/
  
  assert (start != NULL);
  assert (start [1] == '+' || start[1] == '-');
  start++;
  (void)sscanf (start+1, "%hu", expnp);
  if (*start == '-')
    {
      *expnp = ~(*expnp) + (pfiu16)1;
    }

  /*DPRINTF (("double2pfi: %d\n", (short)*expnp));*/
  
  start = strchr (buf, '.') + 1;
  /*DPRINTF (("double2pfi: %s\n", start));*/
  assert (start != NULL);
  assert (start[0] != '\0');
  start += 45;

  for (i = 6; i > 0; i--)
    {
      (void)sscanf (start, "%lu", &results[i]);
      *start = '\0';
      start -= 9;
    }

  DPRINTF (("double2pfi:    %09lu%09lu%09lu%09lu%09lu%09lu\n", 
            results[1], results[2], results[3], 
            results[4], results[5], results[6]));
  start = strchr (buf, '.');
  assert (start != NULL);
  assert (*start != '\0');
  *start = '\0';
  
  (void)sscanf (buf+1, "%hu", highp);
  if (*buf == '-')
    {
      *highp = ~(*highp) + (pfiu16)1;
    }
  DPRINTF (("double2pfi: %+d.%09lu%09lu%09lu%09lu%09lu%09lue%+d\n", 
           *highp, results[1], results[2], results[3], results[4], 
           results[5], results[6], *expnp));
}

static int 
pfi2double (pfiu32 *coded, /*@exposed@*//*@out@*/double *res)
{
  pfiu16 *highp = (pfiu16*)coded;
  pfiu16 *expnp = (pfiu16*)coded + 1;
  int high = 1, expn = 1;
  char buf[64];
  DPRINTF (("pfi2double ()\n"));
  if ((*highp & 0x8000) != 0)
    {
      *highp = ~(*highp) + (pfiu16)1;
      high *= -1;
    }

  high *= *highp;
  
  if ((*expnp & 0x8000) != 0)
    {
      *expnp = ~(*expnp) + (pfiu16)1;
      expn *= -1;
    }
  expn *= *expnp;

  /*
   * Data source corrupted?
   */
  if (*highp > 9 || expn > DBL_MAX_EXP || expn < DBL_MIN_EXP)
    {
      DPRINTF (("pfi2double: data source corrupted: %d %d %d\n",
          *highp > 9, expn > DBL_MAX_EXP, expn < DBL_MIN_EXP));
      /*@-mustdefine@*/
      return -1;
      /*@=mustdefine@*/
    }
  
  
  (void)snprintf (buf, sizeof buf, "%+d.%09lu%09lu%09lu%09lu%09lu%09lue%+d", 
                  high, coded[1], coded[2], coded[3], 
                  coded[4], coded[5], coded[6], expn);
  DPRINTF (("pfi2double: %+d.%09lu%09lu%09lu%09lu%09lu%09lue%+d\n", high,
           coded[1], coded[2], coded[3], coded[4], coded[5], coded[6], expn));
  DPRINTF (("pfi2double: %s\n", buf));
  (void)sscanf (buf, "%le", res);
  DPRINTF (("pfi2double: %+.54e\n", *res));
  return 0;
}


static int 
numexpect (char *bufp, int expect)
{
  int i;
  char *pos;
  
  for (pos = bufp, i = 0; i < expect; i++)
    {
      skipwhite (&pos);
      if (!isdigit ((unsigned char)*pos))
        {
          return -1;
        }
      for (; *pos != '\0' && isdigit ((unsigned char)*pos); pos++)
        {
        }
    }
  skipwhite (&pos);
  return (*pos == '\0')? expect: -1;
}

static void
skipwhite (/*@exposed@*/char **pos)
{
  for (; **pos != '\0' && isspace ((unsigned char)**pos); (*pos)++)
    {
    }
}