common/clitkXdrImageIOWriter.cxx

   1 /*=========================================================================
   2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4   Authors belong to:
   5   - University of LYON              http://www.universite-lyon.fr/
   6   - Léon Bérard cancer center       http://www.centreleonberard.fr
   7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even
  10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11   PURPOSE.  See the copyright notices for more information.
  12
  13   It is distributed under dual licence
  14
  15   - BSD        See included LICENSE.txt file
  16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17 ===========================================================================**/
  18 /**
  19  * @file   clitkXdrImageIO.cxx
  20  * @author Simon Rit <simon.rit@gmail.com>
  21  * @date   Sun Jun  1 22:12:20 2008
  22  *
  23  * @brief
  24  *
  25  *
  26  */
  27
  28 #include "clitkXdrImageIO.h"
  29 #include "clitkCommon.h"
  30
  31 #include <sys/stat.h>
  32
  33 //From mbfield.h
  34 #if !defined(unix) && !defined(__APPLE__)
  35 //#define _read  readfix
  36 #endif
  37 #define AVSINT std::ptrdiff_t
  38 #define AVS_ERROR
  39 #define AVS_OK
  40
  41 //From portdefs.h
  42 #if defined(unix) || defined(__APPLE__)
  43 #define O_BINARY 0
  44 #define setmode(a,b) 0
  45 #endif
  46
  47 #ifndef __LARGE__
  48 #  if defined(__GNUC__) || defined(unix) || defined(__APPLE__)
  49
  50 typedef long long Q_INT64;
  51 typedef unsigned long long Q_UINT64;
  52 #    define Q_INT64_CONST(x) (x##ll)
  53 #    define Q_UINT64_CONST(x) (x##llu) /* gcc also allows ull */
  54 /* When using MINGW with MS(V)CRT DLL, use MS format modifier. */
  55 #    ifdef __MSVCRT__
  56 #      define Q_INT64_FORMAT "I64"
  57 #    else
  58 #      define Q_INT64_FORMAT "L"
  59 #    endif
  60 #  elif defined(__BORLANDC__) || defined(__WATCOMC__) || defined(_MSC_VER)
  61 typedef __int64 Q_INT64;
  62 typedef unsigned __int64 Q_UINT64;
  63 #    define Q_INT64_CONST(x) (x##i64)
  64 #    define Q_UINT64_CONST(x) (x##ui64) /* i64u is not allowed! */
  65 #    ifdef _MSC_VER
  66 #      define Q_INT64_FORMAT "I64"
  67 #    else
  68 #      define Q_INT64_FORMAT "L"
  69 #    endif
  70 #  else
  71 #    error No 64 bit integers known for this compiler, edit portdefs.h.
  72 #  endif
  73 #endif
  74
  75 bool clitk::XdrImageIO::CanWriteFile(const char* FileNameToWrite)
  76 {
  77   std::string filename(FileNameToWrite);
  78   std::string filenameext = GetExtension(filename);
  79   if (filenameext != std::string("xdr")) return false;
  80   return true;
  81 }
  82
  83 void clitk::XdrImageIO::Write(const void* buffer)
  84 {
  85   char *s = const_cast<char*>("");
  86   WriteImage( m_FileName.c_str(), s, s, 0, -1, 0, 2, 0, 0, 0, 0, buffer);
  87 }
  88
  89 // Based on a true story by the Nederlands Kanker Instituut (AVS_WXDR.CPP from the 20091216)
  90
  91 /************************************************************************/
  92 /*                             INCLUDE FILES                            */
  93 /************************************************************************/
  94
  95 #include <string.h>
  96 #include <stdio.h>
  97 #include <math.h>
  98 #include <stdlib.h>
  99 #include <limits.h>
 100 #ifndef _WIN32
 101 #  include <unistd.h>
 102 #endif
 103 #if !defined(unix) && !defined(__APPLE__)
 104 #include <io.h>
 105 #endif
 106 #include <fcntl.h>
 107 #include <errno.h>
 108
 109 #include <algorithm>
 110
 111 #ifdef WIN32
 112 // don't use min() and max() macros indirectly defined by windows.h,
 113 // but use portable std::min() and std:max() instead
 114 #ifndef NOMINMAX
 115 #define NOMINMAX
 116 #endif
 117 #include <windows.h>
 118 #endif
 119
 120 /************************************************************************/
 121 /*                    DEFINES, ENUMERATED TYPES AND CONSTANTS           */
 122 /************************************************************************/
 123
 124 #pragma pack (1)
 125
 126 // Fields with data size>8GB (having UINT_MAX short pixels) cannot be compressed using
 127 // NKI_MODE2 struct because iOrgSize has type "unsigned int". In that case use NKI_MODE2_64BITS.
 128 // The type of structure is indicated as follows:
 129 //
 130 // iOrgSize==0: NKI_MODE2_64BITS
 131 // otherwise  : NKI_MODE2
 132 //
 133 // Compression modes 1 and 3 (without CRCs) only use the first 2 members (iOrgSize and iMode).
 134
 135 typedef struct {
 136   unsigned int iOrgSize;          /* in pixels (i.e. shorts) */
 137   unsigned int iMode;             /* 1, 2, 3 or 4 */
 138   unsigned int iCompressedSize;   /* in bytes, excluding header */
 139   unsigned int iOrgCRC;           /* CRC of the data (no coords etc) */
 140   unsigned int iCompressedCRC;    /* CRC of the compressed data, excluding this header */
 141 } NKI_MODE2;
 142
 143 typedef struct {
 144   unsigned int iOrgSize;          /* in pixels (i.e. shorts) */
 145   unsigned int iMode;             /* 1, 2, 3 or 4 */
 146   unsigned int iCompressedSize;   /* in bytes, excluding header */
 147   unsigned int iOrgCRC;           /* CRC of the data (no coords etc) */
 148   unsigned int iCompressedCRC;    /* CRC of the compressed data, excluding this header */
 149   unsigned int iPad;              /* unused */
 150   Q_UINT64     i64OrgSize;        /* used for more than UINT_MAX pixels, indicated by iOrgSize==0 (0-vector not compressed) */
 151   Q_UINT64     i64CompressedSize; /* value in BYTES, used for more than UINT_MAX PIXELS, indicated by iCompressedSize==0 */
 152   Q_UINT64     i64Future1;
 153   Q_UINT64     i64Future2;
 154 } NKI_MODE2_64BITS;
 155
 156 #pragma pack ()
 157
 158 // Changed next to static function in stead of macro so it can
 159 // have a return value to check in the calling function.
 160 // It could be made inline as well, but there is no real time
 161 // punishment from the extra layer of function calls.
 162
 163 // note: some compilers do not like comments ending in a backslash.
 164 // so use macro functions to exclude.
 165
 166
 167 /************************************************************************/
 168 /*                             GLOBAL VARIABLES                         */
 169 /************************************************************************/
 170
 171 static const unsigned long CRC32_table[256] = {
 172   0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
 173   0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
 174   0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
 175   0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
 176   0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
 177   0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
 178   0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
 179   0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
 180   0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
 181   0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
 182   0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
 183   0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
 184   0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
 185   0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
 186   0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
 187   0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
 188   0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
 189   0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
 190   0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
 191   0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
 192   0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
 193   0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
 194   0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
 195   0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
 196   0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
 197   0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
 198   0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
 199   0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
 200   0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
 201   0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
 202   0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
 203   0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
 204   0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
 205   0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
 206   0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
 207   0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
 208   0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
 209   0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
 210   0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
 211   0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
 212   0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
 213   0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 214   0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
 215 };
 216
 217 /************************************************************************/
 218 /*                             MODULE FUNCTIONS                         */
 219 /************************************************************************/
 220
 221 #ifdef __WATCOMC__
 222 _WCRTLINK
 223 #endif
 224 int writefix(int file, const void *buf, unsigned int count)
 225 {
 226   int j, k, total=0;
 227
 228   for (unsigned i=0; i<count; i+=16384) {
 229     j = count - i;
 230     if (j>16384) j=16384;
 231
 232     k=write(file, (char *)buf+i, j);
 233     if (k < 0) return k;
 234
 235     total += k;
 236
 237     if (k != j) break;
 238   }
 239
 240   return total;
 241 }
 242
 243
 244 /*
 245   Version of write() that takes special action in case of
 246   standard output.  Based on commented out macro above.
 247   This function overloads the <cstdio> (or stdio.h for old style C++)
 248   write() function.
 249 */
 250
 251 // Like the original macro, we do /not/ want writefix from mbfield.c.
 252 #ifdef write
 253 #undef write
 254 #endif
 255 static int wxdr_write(int handle, const void * buf, unsigned len)
 256 {
 257   // if (handle == 1) // stdout
 258   if (handle == fileno(stdout)) {
 259 #ifdef WIN32
 260     // Behave as C standard library write(): return number of bytes
 261     // written or -1 and errno set on error.
 262     fflush(stdout);
 263     DWORD dwBytesWritten;
 264     if (!WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, len,
 265                    &dwBytesWritten, NULL)) {
 266       // There is no simple 1-to-1 mapping between GetLastError()
 267       // values that WriteFile() can return (quite a lot) and the two
 268       // errno values that write() can return.  So return EACCES in
 269       // almost all cases.
 270       switch (GetLastError()) {
 271       case ERROR_INVALID_HANDLE:
 272         errno = EBADF ;
 273         break;
 274       default:
 275         errno = EACCES;
 276         break;
 277       }
 278       return -1;
 279     } else
 280       return (int)dwBytesWritten; // May still be < len!
 281     // And... write() may write a maximum of UINT_MAX-1 bytes, whereas
 282     // WriteFile() may write UINT_MAX bytes at once.  But since
 283     // int(UINT_MAX) == -1 this will pose an actual problem in the
 284     // (far?) future.
 285 #else // !WIN32
 286     //const int oldmode = setmode(handle, O_BINARY);//commented out by joel
 287     const int iBytesWritten = write(handle, buf, len);
 288     const int saveerrno = errno; // setmode() may change errno.
 289     //if (oldmode != -1) setmode(handle, oldmode); //commented out by joel
 290     errno = saveerrno;
 291     return iBytesWritten;
 292 #endif // !WIN32
 293   } else
 294     return write(handle, buf, len);
 295 }
 296
 297 /*
 298   Checked write().
 299   Behaves like win32 WriteFile() and returns a Boolean to indicate
 300   success or failure, where failure almost invariably means disc full.
 301
 302   !!! SIDE EFFECT !!!
 303
 304   In case of failure, this function issues an AVS error message
 305   and closes the file (if handle != 1).  It is up to the calling
 306   function to return the AVS_ERROR state and before that do things
 307   like close other files, free memory etc.  This way, there is less
 308   chance of erroneously duplicated code, like in:
 309     written = write(f, temp, strlen(temp));
 310     if (written == -1 || written != strlen(temp))
 311     { AVSerror(...);
 312       if (f != fileno(stdout)) close(f);
 313       return AVS_ERROR;
 314     }
 315     written = write(f, buf, buflength)
 316     if (written == -1 || written != strlen(temp)) {
 317       // oops, wrong length copy'n'pasted
 318
 319   If more elaborate error handling is needed then the calling
 320   functuon should use the (overloaded) write() and act on its return
 321   value (and the value of errno) accordingly.
 322
 323   It does /not/ close stdout.
 324
 325   !!! SIDE EFFECT !!!
 326
 327   Note that checked_write() takes a size_t for len, whereas write() takes
 328   an unsigned int of 4 bytes. On a 64 bits OS a size_t will be an 8 byte integer,
 329   enabling more than UINT_MAX bytes to write at once.
 330 */
 331 static bool checked_write(int handle, const void * buf, size_t len, char **buffer)
 332 {
 333   if (buffer && !handle) {
 334     memcpy(*buffer, buf, len);
 335     (*buffer) += len;
 336     return true;
 337   }
 338   if (buffer && handle) {
 339     (*buffer) += len;
 340     return true;
 341   } else {
 342     for(int i=0; i<2; i++) {
 343       int byteswritten;
 344       size_t remaining;
 345       int chunksize;
 346
 347       //If write fails, test if not related to big buffer problem
 348       //Bug report http://support.microsoft.com/kb/899149 entitled
 349       //"You cannot call the fwrite function to write to a buffer
 350       // that is larger than 64 MB in Visual C++ 2005,
 351       // in Visual C++ .NET 2003, or in Visual C++ .NET 2002"
 352       // NB: same thing for write function in binary mode
 353       if (i==0) {
 354         remaining = len;
 355         // call wxdr_write (for handle!=fileno(stdout) a wrapper for write) several times
 356         // to interpret the signed 32-bit return value correctly
 357         while (remaining>0) {
 358           chunksize = (int)std::min(remaining, (size_t)INT_MAX);
 359           byteswritten = wxdr_write(handle, buf, chunksize);
 360           if (byteswritten == chunksize)
 361             remaining -= chunksize;
 362           else
 363             break; // try writefix in the next round
 364         }
 365         if (remaining == 0)
 366           return true;
 367       } else {
 368         remaining = len;
 369         // call writefix (in mbfield.c) several times to interpret the signed 32-bit
 370         // return value correctly. writefix uses chunks of 16384 bytes
 371         while (remaining>0) {
 372           chunksize = (int)std::min(remaining, (size_t)INT_MAX);
 373           byteswritten = writefix(handle, buf, chunksize);
 374           if (byteswritten == chunksize)
 375             remaining -= chunksize;
 376           else
 377             break; // even writefix failed: return error
 378         }
 379         if (remaining == 0)
 380           return true;
 381       }
 382     }
 383     // Note: file is open in binary mode, no need to compensate
 384     // for a value of byteswritten > len due to \n -> \r\n conversions.
 385     // (write() on a text stream is implementation dependent.)
 386     if (handle != fileno(stdout)) close(handle);
 387     AVSerror("Avs_wxdr: write failed, disk full?");
 388     return false;
 389   }
 390 }
 391
 392 /* coder for NKI private compressed pixel data
 393    arguments: dest    = (in) points to area where compressed destination data is written (byte)
 394               src     = (in) points to uncompressed source data (short)
 395               npixels = (in) number of pixels to compress
 396
 397    The return value is the number of bytes in the compressed data (maximal 3*npixels+10, typical 0.52*npixels)
 398
 399    if iMode == 1 then
 400    - The first 4 bytes contain the number of short-int pixels
 401    - The following 4 bytes contain iMode=1
 402    - The rest is the compressed image
 403
 404    if iMode == 2 then
 405    - The first 4 bytes contain the number of short-int pixels
 406    - The following 4 bytes contain iMode=2
 407    - The following 4 bytes contain the size of the compressed image (in bytes)
 408    - The following 4 bytes contain the CRC of the original image
 409    - The following 4 bytes contain the CRC of the compressed image
 410    - The rest is the compressed image
 411    - The compressed size will be even (padded by a zero if necessary).
 412
 413    if iMode == 3 then
 414    - The first 4 bytes contain the number of short-int pixels
 415    - The following 4 bytes contain iMode=3
 416    - The rest is the compressed image, including 4 bit differences
 417
 418    if iMode == 4 then
 419    - The first 4 bytes contain the number of short-int pixels
 420    - The following 4 bytes contain iMode=4
 421    - The following 4 bytes contain the size of the compressed image (in bytes)
 422    - The following 4 bytes contain the CRC of the original image
 423    - The following 4 bytes contain 0
 424    - The rest is the compressed image, including 4 bit differences
 425    - The compressed size will be even (padded by a zero if necessary).
 426
 427    iMode 1 and iMode 2 are identical, except for the CRC data that is included for iMode 2
 428    iMode 3 and iMode 4 are identical, except for the CRC data that is included for iMode 4
 429 */
 430
 431 // optimized settings for the 4 bit run compressor (mode 3 and 4)
 432
 433 #define MINZEROS 5              // shortest RLE (2 byte overhead, but breaks 4bit run)
 434 #define MIN4BIT  6              // shortest 4 bit run (6 bytes compressed to 5 bytes)
 435
 436 // This internal routine converts an 8 bit difference string into a 4 bit one
 437 static signed char *recompress4bit(int n, signed char *dest)
 438 {
 439   signed char *p, *q;
 440   int val;
 441
 442   n = n & 0xfe;
 443   dest -= n;
 444   p = dest;
 445   val = (((int)p[0])<<4) | (p[1]&15);
 446   p += 2;
 447   *dest++ = -0x40; // 192 (0xc0) does not fit between -128..127: maps to -64 (0x40) in 2's complement
 448   *dest++ = (signed char)n;
 449   q = dest++;
 450   n -= 2;
 451   while(n>0) {
 452     *dest++ = (signed char)((((int)p[0])<<4) | (p[1]&15));
 453     p += 2;
 454     n -= 2;
 455   }
 456   q[0] = (signed char)val;
 457
 458   return dest;
 459 }
 460
 461
 462 static size_t nki_private_compress(signed char  *dest, short int  *src, size_t npixels, int iMode)
 463 {
 464   unsigned long         iCRC;
 465   unsigned long         iCRC2;
 466   unsigned int          iHeaderSize=8;                      // value for iMode==1 and iMode==3
 467   register int          val;
 468   size_t                i,j;
 469   NKI_MODE2*            pHeader = (NKI_MODE2*)dest;
 470   NKI_MODE2_64BITS*     pHeader_64bits = (NKI_MODE2_64BITS*)dest;
 471   size_t                iBufferSize;
 472
 473   iBufferSize = (npixels / 2) * 3;                          // Buffer is sizeof(NKI_MODE2_64BITS) + 10 bytes larger
 474
 475   /* Up till now only Mode=1 .. 4 are supported */
 476   if ((iMode < 1) || (iMode > 4))
 477     return 0;
 478
 479   /* Create the header */
 480   pHeader->iMode = iMode;
 481
 482   if (sizeof(int*)>sizeof(int) && npixels>UINT_MAX) {       // On a 64 bits OS we want to store files>4GB
 483     pHeader_64bits->iOrgSize   = 0;                         // This indicates>4GB file (0-vector is not compressed)
 484     pHeader_64bits->i64OrgSize = npixels;
 485     iHeaderSize = sizeof(NKI_MODE2_64BITS);
 486     dest += sizeof(NKI_MODE2_64BITS);
 487   } else {
 488     pHeader->iOrgSize = (unsigned int)(npixels & UINT_MAX); // store 32 bit number as first member
 489
 490     if (iMode==2 || iMode==4)
 491       iHeaderSize = sizeof(NKI_MODE2);
 492     dest += iHeaderSize;
 493   }
 494
 495   /* Create the compressed image */
 496
 497   if (iMode == 1) {
 498     *(short int *)dest = *src;
 499     dest+=2;
 500
 501     npixels--;
 502
 503     do {
 504       val = src[1] - src[0];
 505       src++;
 506
 507       if (val == 0) {                          /* run length-encode zero differences */
 508         for (i=2;; i++) {
 509           if (i>=npixels || src[i-1]!=src[-1] || i==256) {
 510             if (i==2)
 511               *dest++=0;
 512             else {
 513               *dest++  =  -128; // hexadecimal 0x80
 514               *dest++  = (signed char)(i-1);
 515               npixels -= (i-2);
 516               src     += (i-2);
 517             }
 518             break;
 519           }
 520         }
 521       } else if (val >= -64 && val <= 63) {     /* small difference coded as one byte */
 522         *dest = (signed char)val;
 523         dest++;
 524       } else if (val >= -0x3F00 && val <= 0x3EFF) { /* large differences coded as two bytes */
 525         dest[0] = (signed char)((val>>8) ^ 0x40);
 526         dest[1] = (signed char)val;
 527         dest+=2;
 528       } else {                                  /* if very large differences code abs val as three bytes */
 529         *dest++ = 0x7F;
 530         *dest++ = (signed char)(src[0]>>8);
 531         *dest++ = (signed char)(src[0]);
 532       }
 533       /* Are we beyond the allocated memory? */
 534       if ((size_t)(dest - (signed char*)pHeader) > iBufferSize)
 535         return 0;
 536     } while (--npixels);
 537   }
 538
 539   else if (iMode == 2) {
 540     iCRC  = 0;
 541     iCRC2 = 0;
 542
 543     *(short int *)dest = val = *src;
 544     iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ (unsigned char) val    ] ^ ((iCRC2 >> 8));
 545     iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ (unsigned char)(val>>8)] ^ ((iCRC2 >> 8));
 546     iCRC  = CRC32_table[(unsigned char)iCRC  ^ (unsigned char) val    ] ^ ((iCRC  >> 8));
 547     iCRC  = CRC32_table[(unsigned char)iCRC  ^ (unsigned char)(val>>8)] ^ ((iCRC  >> 8));
 548     dest+=2;
 549     npixels--;
 550
 551     do {
 552       val = src[1] - src[0];
 553       src++;
 554       iCRC  = CRC32_table[(unsigned char)iCRC  ^ (unsigned char) src[0]    ] ^ ((iCRC  >> 8));
 555       iCRC  = CRC32_table[(unsigned char)iCRC  ^ (unsigned char)(src[0]>>8)] ^ ((iCRC  >> 8));
 556
 557       if (val == 0) {                          /* run length-encode zero differences */
 558         for (i=2;; i++) {
 559           if (i>=npixels || src[i-1]!=src[-1] || i==256) {
 560             if (i==2) {
 561               *dest++=0;
 562               iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ 0    ] ^ ((iCRC2 >> 8));
 563             } else {
 564               *dest++  =  -128; // hexadecimal 0x80
 565               iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ 0x80 ] ^ ((iCRC2 >> 8));
 566               *dest++  = (signed char)(i-1);
 567               iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ (i-1)] ^ ((iCRC2 >> 8));
 568               npixels -= (i-2);
 569
 570               for (j=0; j<i-2; j++) {
 571                 src++;
 572                 iCRC = CRC32_table[(unsigned char)iCRC  ^ (unsigned char) src[0]    ] ^ ((iCRC  >> 8));
 573                 iCRC = CRC32_table[(unsigned char)iCRC  ^ (unsigned char)(src[0]>>8)] ^ ((iCRC  >> 8));
 574               }
 575             }
 576             break;
 577           }
 578         }
 579       } else if (val >= -64 && val <= 63) {     /* small difference coded as one byte */
 580         *dest = (signed char)val;
 581         iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ (unsigned char)val     ] ^ ((iCRC2 >> 8));
 582         dest++;
 583       } else if (val >= -0x3F00 && val <= 0x3EFF) { /* large differences coded as two bytes */
 584         dest[0] = (signed char)((val>>8) ^ 0x40);
 585         iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ (unsigned char)dest[0] ] ^ ((iCRC2 >> 8));
 586         dest[1] = (signed char)val;
 587         iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ (unsigned char)val     ] ^ ((iCRC2 >> 8));
 588         dest+=2;
 589       } else {                                  /* if very large differences code abs val as three bytes */
 590         dest[0] = 0x7F;
 591         iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ 0x7f                   ] ^ ((iCRC2 >> 8));
 592         val     = src[0];
 593         dest[1] = (signed char)(val>>8);
 594         iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ (unsigned char)(val>>8)] ^ ((iCRC2 >> 8));
 595         dest[2] = (signed char)val;
 596         iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ (unsigned char)val     ] ^ ((iCRC2 >> 8));
 597         dest+=3;
 598       }
 599       /* Are we beyond the allocated memory? */
 600       if ((size_t)(dest - (signed char*)pHeader) > iBufferSize)
 601         return 0;
 602     } while (--npixels);
 603
 604     if ((dest - (signed char*)pHeader - iHeaderSize)<UINT_MAX) // store 32 bit number as third member
 605       pHeader->iCompressedSize =
 606         (unsigned int)(dest - (signed char*)pHeader - iHeaderSize);
 607     else                                                       // store 64 bit number in extended structure
 608       pHeader_64bits->i64CompressedSize = dest - (signed char*)pHeader -iHeaderSize;
 609
 610     /* Pad it to get an even length */
 611     if (pHeader->iCompressedSize & 1) {
 612       *dest++ = 0;
 613       iCRC2 = CRC32_table[(unsigned char)iCRC2 ^ 0] ^ ((iCRC2 >> 8));
 614       pHeader->iCompressedSize++;
 615     }
 616
 617     pHeader->iOrgCRC        = iCRC;
 618     pHeader->iCompressedCRC = iCRC2;
 619   }
 620
 621   /* Create the compressed image - compressor with added 4 bit run */
 622
 623   else if (iMode == 3) {
 624     int n4bit=0;
 625     *(short int *)dest = *src;
 626     dest+=2;
 627     npixels--;
 628
 629     do {
 630       val = src[1] - src[0];
 631       src++;
 632
 633       if (val == 0) {                           /* run length-encode zero differences */
 634         for (i=2;; i++) {
 635           if (i>=npixels || src[i-1]!=src[-1] || i==256) {
 636             if (i<=MINZEROS) {          /* too short run -> write zeros */
 637               for (j=0; j<i-1; j++) {
 638                 *dest++=0;
 639                 n4bit++;
 640
 641                 if(n4bit>=254) {                /* maximum length 4 bit run */
 642                   dest  = recompress4bit(n4bit, dest);
 643                   n4bit = 0;
 644                 }
 645               }
 646             } else {
 647               if (n4bit>=MIN4BIT)               /* end (and write) 4 bit run */
 648                 dest  = recompress4bit(n4bit, dest);
 649
 650               n4bit=0;
 651               *dest++  = -128; // hexadecimal 0x80
 652               *dest++  = (signed char)(i-1);
 653             }
 654
 655             npixels -= (i-2);
 656             src     += (i-2);
 657             break;
 658           }
 659         }
 660       } else if (val >= -63 && val <= 63) {     /* small difference coded as one byte */
 661         if (val >= -8 && val <= 7) {
 662           *dest++ = (signed char)val;
 663           n4bit++;
 664
 665           if(n4bit>=254) {              /* maximum length 4 bit run */
 666             dest  = recompress4bit(n4bit, dest);
 667             n4bit=0;
 668           }
 669         } else if(n4bit>=MIN4BIT) {             /* end and write 4 bit run */
 670           j = val;
 671           dest  = recompress4bit(n4bit, dest);
 672           n4bit=0;
 673           *dest++ = (signed char)j;
 674         } else {
 675           *dest++ = (signed char)val;                   /* end 4 bit run */
 676           n4bit  = 0;
 677         }
 678       } else if (val >= -0x3F00 && val <= 0x3EFF) { /* large differences coded as two bytes */
 679         j = val;
 680
 681         if(n4bit>=MIN4BIT)                      /* end (and write) 4 bit run */
 682           dest  = recompress4bit(n4bit, dest);
 683
 684         n4bit=0;
 685         dest[0] = (signed char)((j>>8) ^ 0x40);
 686         dest[1] = (signed char)j;
 687         dest+=2;
 688       } else {                                  /* if very large differences code abs val as three bytes */
 689         j = src[0];
 690
 691         if(n4bit>=MIN4BIT)                      /* end (and write) 4 bit run */
 692           dest  = recompress4bit(n4bit, dest);
 693
 694         n4bit=0;
 695         *dest++ = 0x7F;
 696         *dest++ = (signed char)(j>>8);
 697         *dest++ = (signed char)j;
 698       }
 699       /* Are we beyond the allocated memory? */
 700       if ((size_t)(dest - (signed char*)pHeader) > iBufferSize)
 701         return 0;
 702     } while (--npixels);
 703   }
 704
 705   /* Create the compressed image - compressor with added 4 bit run and CRC */
 706
 707   else if (iMode == 4) {
 708     int n4bit=0;
 709     iCRC  = 0;
 710
 711     *(short int *)dest = val = *src;
 712     iCRC  = CRC32_table[(unsigned char)iCRC  ^ (unsigned char) val    ] ^ ((iCRC  >> 8));
 713     iCRC  = CRC32_table[(unsigned char)iCRC  ^ (unsigned char)(val>>8)] ^ ((iCRC  >> 8));
 714     dest+=2;
 715     npixels--;
 716
 717     do {
 718       val = src[1] - src[0];
 719       src++;
 720       iCRC  = CRC32_table[(unsigned char)iCRC  ^ (unsigned char) src[0]    ] ^ ((iCRC  >> 8));
 721       iCRC  = CRC32_table[(unsigned char)iCRC  ^ (unsigned char)(src[0]>>8)] ^ ((iCRC  >> 8));
 722
 723       if (val == 0) {                           /* run length-encode zero differences */
 724         for (i=2;; i++) {
 725           if (i>=npixels || src[i-1]!=src[-1] || i==256) {
 726             if (i<=MINZEROS) {          /* too short run -> write zeros */
 727               for (j=0; j<i-1; j++) {
 728                 *dest++=0;
 729                 n4bit++;
 730
 731                 if(n4bit>=254) {                /* maximum length 4 bit run */
 732                   dest  = recompress4bit(n4bit, dest);
 733                   n4bit = 0;
 734                 }
 735               }
 736             } else {
 737               if (n4bit>=MIN4BIT)               /* end (and write) 4 bit run */
 738                 dest  = recompress4bit(n4bit, dest);
 739
 740               n4bit=0;
 741               *dest++  = -128; // hexadecimal 0x80
 742               *dest++  = (signed char)(i-1);
 743             }
 744
 745             npixels -= (i-2);
 746             for (j=0; j<i-2; j++) {
 747               src++;
 748               iCRC = CRC32_table[(unsigned char)iCRC  ^ (unsigned char) src[0]    ] ^ ((iCRC  >> 8));
 749               iCRC = CRC32_table[(unsigned char)iCRC  ^ (unsigned char)(src[0]>>8)] ^ ((iCRC  >> 8));
 750             }
 751             break;
 752           }
 753         }
 754       } else if (val >= -63 && val <= 63) {     /* small difference coded as one byte */
 755         if (val >= -8 && val <= 7) {
 756           *dest++ = (signed char)val;
 757           n4bit++;
 758
 759           if(n4bit>=254) {              /* maximum length 4 bit run */
 760             dest  = recompress4bit(n4bit, dest);
 761             n4bit=0;
 762           }
 763         } else if(n4bit>=MIN4BIT) {             /* end and write 4 bit run */
 764           j = val;
 765           dest  = recompress4bit(n4bit, dest);
 766           n4bit=0;
 767           *dest++ = (signed char)j;
 768         } else {
 769           *dest++ = (signed char)val;           /* end 4 bit run */
 770           n4bit  = 0;
 771         }
 772       } else if (val >= -0x3F00 && val <= 0x3EFF) { /* large differences coded as two bytes */
 773         j = val;
 774
 775         if(n4bit>=MIN4BIT)                      /* end (and write) 4 bit run */
 776           dest  = recompress4bit(n4bit, dest);
 777
 778         n4bit=0;
 779         dest[0] = (signed char)((j>>8) ^ 0x40);
 780         dest[1] = (signed char)j;
 781         dest+=2;
 782       } else {                                  /* if very large differences code abs val as three bytes */
 783         j = src[0];
 784
 785         if(n4bit>=MIN4BIT)                      /* end (and write) 4 bit run */
 786           dest  = recompress4bit(n4bit, dest);
 787
 788         n4bit=0;
 789         *dest++ = 0x7F;
 790         *dest++ = (signed char)(j>>8);
 791         *dest++ = (signed char)j;
 792       }
 793       /* Are we beyond the allocated memory? */
 794       if ((size_t)(dest - (signed char*)pHeader) > iBufferSize)
 795         return 0;
 796     } while (--npixels);
 797
 798     if ((dest - (signed char*)pHeader - iHeaderSize)<UINT_MAX) // store 32 bit number as third member
 799       pHeader->iCompressedSize =
 800         (unsigned int)(dest - (signed char*)pHeader - iHeaderSize);
 801     else {                                                     // store 64 bit number in extended structure
 802       pHeader_64bits->iCompressedSize = 0;
 803       pHeader_64bits->i64CompressedSize = dest - (signed char*)pHeader -iHeaderSize;
 804     }
 805
 806     /* Pad it to get an even length */
 807     if (pHeader->iCompressedSize & 1) {
 808       *dest++ = 0;
 809       pHeader->iCompressedSize++;
 810     }
 811
 812     pHeader->iOrgCRC        = iCRC;
 813     pHeader->iCompressedCRC = 0;
 814   }
 815
 816   return dest - (signed char*)pHeader;
 817 }
 818
 819
 820 void clitk::XdrImageIO::WriteImage(const char* file, char* headerinfo, char* headerfile, int raw,
 821                                    int offset, char bLittleEndian, int iNkiCompression,
 822                                    int wcoords, int append, int getsize, char *tobuffer, const void* data)
 823 {
 824   AVSINT   total=1;
 825   unsigned int      i;
 826   AVSINT   coords=0;
 827   int      f=0;
 828   char     temp[256];
 829   char     *c;
 830   char     cSwap;
 831   FILE     *fp;
 832   long     swap_test = 0x1000000;
 833   signed char*  pCompressed = NULL;
 834   size_t   FilePos=0;
 835   char     **buffer = NULL;
 836   int      len=0;
 837   char     *buf2;
 838   size_t   slen;
 839
 840   if (bLittleEndian)
 841     swap_test = 0x00000001;
 842
 843   if (getsize) {
 844     swap_test = 0xffffffff;     // never swap to save time
 845     buffer    = (char **) &len;
 846     f         = 1;
 847   }
 848
 849   if (tobuffer) {
 850     buf2   = (char *)tobuffer;
 851     buffer = &buf2;
 852     f      = 0;
 853   }
 854
 855   for (i=0; i<GetNumberOfDimensions(); i++) {
 856     total  *= GetDimensions(i);
 857     coords += GetDimensions(i);
 858   }
 859
 860   /* Try allocate the compressed fielddata - compression disabled if alloc fails */
 861   if ((iNkiCompression > 0) &&
 862       (GetComponentType() == itk::ImageIOBase::SHORT) &&
 863       (GetPixelType() == itk::ImageIOBase::SCALAR)) {
 864     pCompressed = (signed char *)malloc((total/2) * 3 + sizeof(NKI_MODE2_64BITS) + 10);
 865     if (pCompressed==NULL) {
 866       iNkiCompression = 0;
 867       AVSwarning("Avs_wxdr: not enough memory to compress data, saving uncompressed");
 868     }
 869   }
 870
 871   if (!(tobuffer || getsize)) {
 872     if (offset != -1) {
 873       f = open(file, O_RDWR, 0);
 874       if (f < 0) {
 875         AVSerror("Avs_wxdr: Opening " << file << "failed.\n" << strerror(errno));
 876         free(pCompressed);
 877         return AVS_ERROR;
 878       }
 879       lseek(f, offset, SEEK_SET);
 880     } else {
 881       if (strlen(file)==0)
 882         f = fileno(stdout);
 883       else {
 884         if (append)
 885           f = open(file, O_RDWR | O_APPEND, 0);
 886         else
 887           f = creat(file, S_IWRITE | S_IREAD);
 888       }
 889
 890       if (f < 0) {
 891         AVSerror("Avs_wxdr: Creating " << file << " failed.\n" << strerror(errno));
 892         free(pCompressed);
 893         return AVS_ERROR;
 894       }
 895     }
 896   }
 897
 898   if (!raw) {
 899     sprintf(temp, "# AVS wants to have the first line starting with its name\n");
 900     slen = strlen(temp);
 901
 902     if (!checked_write(f, temp, slen, buffer)) {
 903       free(pCompressed);
 904       return AVS_ERROR;
 905     }
 906     FilePos += slen;
 907
 908     slen = strlen(headerinfo);
 909     if (slen && !checked_write(f, headerinfo, slen, buffer)) {
 910       free(pCompressed);
 911       return AVS_ERROR;
 912     }
 913     FilePos += slen;
 914
 915     if (!checked_write(f, "\n", 1, buffer)) {
 916       free(pCompressed);
 917       return AVS_ERROR;
 918     }
 919     FilePos++;
 920
 921     if (strlen(headerfile)) {
 922       fp = fopen(headerfile, "rt");
 923       if (fp) {
 924         for (;;) {
 925           if (fgets(temp, 255, fp) == NULL) break;
 926           slen = strlen(temp);
 927           if (!checked_write(f, temp, slen, buffer)) {
 928             fclose(fp);
 929             free(pCompressed);
 930             return AVS_ERROR;
 931           }
 932           FilePos += slen;
 933         }
 934         fclose(fp);
 935         if (!checked_write(f, "\n", 1, buffer)) {
 936           free(pCompressed);
 937           return AVS_ERROR;
 938         }
 939         FilePos++;
 940       }
 941     }
 942
 943     sprintf(temp, "ndim=%d\n", GetNumberOfDimensions());
 944     slen = strlen(temp);
 945     if (!checked_write(f, temp, slen, buffer)) {
 946       free(pCompressed);
 947       return AVS_ERROR;
 948     }
 949     FilePos += slen;
 950   }
 951
 952   for (i=0; i<GetNumberOfDimensions(); i++) {
 953     if (!raw) {
 954       sprintf(temp, "dim%d=%d\n", i+1, GetDimensions(i));
 955       slen = strlen(temp);
 956       if (!checked_write(f, temp, slen, buffer)) {
 957         free(pCompressed);
 958         return AVS_ERROR;
 959       }
 960       FilePos += slen;
 961     }
 962   }
 963
 964   if (!raw) {
 965     sprintf(temp, "nspace=%d\n", GetNumberOfDimensions());
 966     slen = strlen(temp);
 967     if (!checked_write(f, temp, slen, buffer)) {
 968       free(pCompressed);
 969       return AVS_ERROR;
 970     }
 971     FilePos += slen;
 972
 973     sprintf(temp, "veclen=%d\n", GetNumberOfComponents());
 974     slen = strlen(temp);
 975     if (!checked_write(f, temp, slen, buffer)) {
 976       free(pCompressed);
 977       return AVS_ERROR;
 978     }
 979     FilePos += slen;
 980
 981     switch(GetComponentType()) {
 982     case itk::ImageIOBase::CHAR   :
 983       strcpy(temp, "data=byte\n");
 984       break;
 985     case itk::ImageIOBase::SHORT  :
 986       strcpy(temp, "data=xdr_short\n");
 987       break;
 988     case itk::ImageIOBase::INT    :
 989       strcpy(temp, "data=xdr_integer\n");
 990       break;
 991     case itk::ImageIOBase::FLOAT  :
 992       strcpy(temp, "data=xdr_real\n");
 993       break;
 994     case itk::ImageIOBase::DOUBLE :
 995       strcpy(temp, "data=xdr_double\n");
 996       break;
 997     default               :
 998       if (f != fileno(stdout)) close(f);
 999       free(pCompressed);
1000       return AVS_ERROR;
1001     }
1002     slen = strlen(temp);
1003     if (!checked_write(f, temp, slen, buffer)) {
1004       free(pCompressed);
1005       return AVS_ERROR;
1006     }
1007     FilePos += slen;
1008   }
1009
1010
1011   //FilePos = tell(f);
1012 ONCE_AGAIN:
1013
1014
1015   //switch(input->uniform)
1016   //{ case UNIFORM     :
1017   strcpy(temp, "field=uniform\n");
1018   coords = GetNumberOfDimensions() * 2;
1019   //       break;
1020   //  case RECTILINEAR : strcpy(temp, "field=rectilinear\n");
1021   //       break;
1022   //  case IRREGULAR   : strcpy(temp, "field=irregular\n");
1023   //       coords = total * input->nspace;
1024   //       break;
1025   //  default          : if (f != fileno(stdout)) close(f);
1026   //                     free(pCompressed);
1027   //                           return;
1028   //}
1029
1030   if (!raw) {
1031     if (!checked_write(f, temp, strlen(temp), buffer)) {
1032       free(pCompressed);
1033       return AVS_ERROR;
1034     }
1035
1036     if ((iNkiCompression > 0) &&
1037         (GetComponentType() == itk::ImageIOBase::SHORT) &&
1038         (GetPixelType() == itk::ImageIOBase::SCALAR)) {
1039       sprintf(temp, "nki_compression=%d", iNkiCompression);
1040       if (!checked_write(f, temp, strlen(temp), buffer)) {
1041         free(pCompressed);
1042         return AVS_ERROR;
1043       }
1044     }
1045
1046     temp[0] = temp[1] = 12;
1047     if (!checked_write(f, temp, 2, buffer)) {
1048       free(pCompressed);
1049       return AVS_ERROR;
1050     }
1051   }
1052
1053   total *= GetPixelSize();
1054
1055   if ((!raw) && (iNkiCompression > 0) &&
1056       (GetComponentType() == itk::ImageIOBase::SHORT) &&
1057       (GetPixelType() == itk::ImageIOBase::SCALAR)) {
1058     size_t      iCompressedLength;
1059
1060     iCompressedLength = nki_private_compress(pCompressed,
1061                         (short int *)(data), total/2, iNkiCompression);
1062
1063     if (iCompressedLength > 0) {
1064       if (!checked_write(f, pCompressed, iCompressedLength, buffer)) {
1065         free(pCompressed);
1066         return AVS_ERROR;
1067       }
1068       free(pCompressed);
1069       goto WRITE_COORDS;
1070     }
1071
1072     /* Compressionratio was poor: let's write uncompressed */
1073     iNkiCompression = 0;
1074     total /= 2;
1075     free(pCompressed);
1076     pCompressed = NULL;
1077     lseek(f, (unsigned int)FilePos, SEEK_SET); // use _lseeki64 just in case header size > UINT_MAX bytes
1078     goto ONCE_AGAIN;
1079   }
1080
1081   /* swap data if required (xdr is low-endian) */
1082
1083   if (!(*(char *)(&swap_test))) {
1084     if (GetComponentSize()==2) {
1085       c = (char *)data;
1086       for (i=0; i<total; i+=2) {
1087         cSwap  = c[i];
1088         c[i]   = c[i+1];
1089         c[i+1] = cSwap;
1090       }
1091     } else if (GetComponentSize()==4) {
1092       c = (char *)data;
1093       for (i=0; i<total; i+=4) {
1094         cSwap = c[i];
1095         c[i]   = c[i+3];
1096         c[i+3] = cSwap;
1097         cSwap = c[i+1];
1098         c[i+1] = c[i+2];
1099         c[i+2] = cSwap;
1100       }
1101     } else if (GetComponentSize()==8) {
1102       c = (char *)data;
1103       for (i=0; i<total; i+=8) {
1104         cSwap = c[i];
1105         c[i]   = c[i+7];
1106         c[i+7] = cSwap;
1107         cSwap = c[i+1];
1108         c[i+1] = c[i+6];
1109         c[i+6] = cSwap;
1110         cSwap = c[i+2];
1111         c[i+2] = c[i+5];
1112         c[i+5] = cSwap;
1113         cSwap = c[i+3];
1114         c[i+3] = c[i+4];
1115         c[i+4] = cSwap;
1116       }
1117     }
1118   }
1119
1120   if (total) {
1121     if (!checked_write(f, data, total, buffer))
1122       return AVS_ERROR;
1123   }
1124
1125   /* swap data back if was swapped before writing */
1126
1127   if (!(*(char *)(&swap_test))) {
1128     if (GetComponentSize()==2) {
1129       c = (char *)data;
1130       for (i=0; i<total; i+=2) {
1131         cSwap = c[i];
1132         c[i]   = c[i+1];
1133         c[i+1] = cSwap;
1134       }
1135     } else if (GetComponentSize()==4) {
1136       c = (char *)data;
1137       for (i=0; i<total; i+=4) {
1138         cSwap = c[i];
1139         c[i]   = c[i+3];
1140         c[i+3] = cSwap;
1141         cSwap = c[i+1];
1142         c[i+1] = c[i+2];
1143         c[i+2] = cSwap;
1144       }
1145     } else if (GetComponentSize()==8) {
1146       c = (char *)data;
1147       for (i=0; i<total; i+=8) {
1148         cSwap = c[i];
1149         c[i]   = c[i+7];
1150         c[i+7] = cSwap;
1151         cSwap = c[i+1];
1152         c[i+1] = c[i+6];
1153         c[i+6] = cSwap;
1154         cSwap = c[i+2];
1155         c[i+2] = c[i+5];
1156         c[i+5] = cSwap;
1157         cSwap = c[i+3];
1158         c[i+3] = c[i+4];
1159         c[i+4] = cSwap;
1160       }
1161     }
1162   }
1163
1164 WRITE_COORDS:
1165   float *points;
1166   points = (float *)malloc(sizeof(float)*GetNumberOfDimensions()*2);
1167   for (i=0; i<GetNumberOfDimensions(); i++) {
1168     points[i*2  ] = 0.1 *  GetOrigin(i);
1169     points[i*2+1] = 0.1 * (GetOrigin(i) + GetSpacing(i)*(GetDimensions(i)-1));
1170   }
1171
1172   if (coords && !raw) {                         /* write AVS coordinates ? */
1173     coords *= sizeof(float);
1174     if (!(*(char *)(&swap_test))) {
1175       c = (char *)(points);              /* swap bytes */
1176       for (i=0; i<coords; i+=4) {
1177         cSwap = c[i];
1178         c[i]   = c[i+3];
1179         c[i+3] = cSwap;
1180         cSwap = c[i+1];
1181         c[i+1] = c[i+2];
1182         c[i+2] = cSwap;
1183       }
1184     }
1185
1186     if (!checked_write(f, points, coords, buffer))
1187       return AVS_ERROR;
1188
1189     if (!(*(char *)(&swap_test))) {
1190       c = (char *)(points);              /* swap bytes back */
1191       for (i=0; i<coords; i+=4) {
1192         cSwap = c[i];
1193         c[i]   = c[i+3];
1194         c[i+3] = cSwap;
1195         cSwap = c[i+1];
1196         c[i+1] = c[i+2];
1197         c[i+2] = cSwap;
1198       }
1199     }
1200   }
1201
1202   if (!(tobuffer || getsize))
1203     if (f != fileno(stdout)) close(f);
1204
1205   if (getsize) return;
1206   return AVS_OK;
1207 }