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 // comment by ds
  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 #ifdef _WIN32
 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 #ifdef _WIN32
 841   int oldFMode;
 842   _get_fmode(&oldFMode);
 843   _set_fmode(O_BINARY); /* default binary i/o */
 844 #endif
 845
 846   if (bLittleEndian)
 847     swap_test = 0x00000001;
 848
 849   if (getsize) {
 850     swap_test = 0xffffffff;     // never swap to save time
 851     buffer    = (char **) &len;
 852     f         = 1;
 853   }
 854
 855   if (tobuffer) {
 856     buf2   = (char *)tobuffer;
 857     buffer = &buf2;
 858     f      = 0;
 859   }
 860
 861   for (i=0; i<GetNumberOfDimensions(); i++) {
 862     total  *= GetDimensions(i);
 863     coords += GetDimensions(i);
 864   }
 865
 866   /* Try allocate the compressed fielddata - compression disabled if alloc fails */
 867   if ((iNkiCompression > 0) &&
 868       (GetComponentType() == itk::ImageIOBase::SHORT) &&
 869       (GetPixelType() == itk::ImageIOBase::SCALAR)) {
 870     pCompressed = (signed char *)malloc((total/2) * 3 + sizeof(NKI_MODE2_64BITS) + 10);
 871     if (pCompressed==NULL) {
 872       iNkiCompression = 0;
 873       AVSwarning("Avs_wxdr: not enough memory to compress data, saving uncompressed");
 874     }
 875   }
 876
 877   if (!(tobuffer || getsize)) {
 878     if (offset != -1) {
 879       f = open(file, O_RDWR, 0);
 880       if (f < 0) {
 881         AVSerror("Avs_wxdr: Opening " << file << "failed.\n" << strerror(errno));
 882         free(pCompressed);
 883         return AVS_ERROR;
 884       }
 885       lseek(f, offset, SEEK_SET);
 886     } else {
 887       if (strlen(file)==0)
 888         f = fileno(stdout);
 889       else {
 890         if (append)
 891           f = open(file, O_RDWR | O_APPEND, 0);
 892         else
 893           f = creat(file, S_IWRITE | S_IREAD);
 894       }
 895
 896       if (f < 0) {
 897         AVSerror("Avs_wxdr: Creating " << file << " failed.\n" << strerror(errno));
 898         free(pCompressed);
 899         return AVS_ERROR;
 900       }
 901     }
 902   }
 903
 904   if (!raw) {
 905     sprintf(temp, "# AVS wants to have the first line starting with its name\n");
 906     slen = strlen(temp);
 907
 908     if (!checked_write(f, temp, slen, buffer)) {
 909       free(pCompressed);
 910       return AVS_ERROR;
 911     }
 912     FilePos += slen;
 913
 914     slen = strlen(headerinfo);
 915     if (slen && !checked_write(f, headerinfo, slen, buffer)) {
 916       free(pCompressed);
 917       return AVS_ERROR;
 918     }
 919     FilePos += slen;
 920
 921     if (!checked_write(f, "\n", 1, buffer)) {
 922       free(pCompressed);
 923       return AVS_ERROR;
 924     }
 925     FilePos++;
 926
 927     if (strlen(headerfile)) {
 928       fp = fopen(headerfile, "rt");
 929       if (fp) {
 930         for (;;) {
 931           if (fgets(temp, 255, fp) == NULL) break;
 932           slen = strlen(temp);
 933           if (!checked_write(f, temp, slen, buffer)) {
 934             fclose(fp);
 935             free(pCompressed);
 936             return AVS_ERROR;
 937           }
 938           FilePos += slen;
 939         }
 940         fclose(fp);
 941         if (!checked_write(f, "\n", 1, buffer)) {
 942           free(pCompressed);
 943           return AVS_ERROR;
 944         }
 945         FilePos++;
 946       }
 947     }
 948
 949     sprintf(temp, "ndim=%d\n", GetNumberOfDimensions());
 950     slen = strlen(temp);
 951     if (!checked_write(f, temp, slen, buffer)) {
 952       free(pCompressed);
 953       return AVS_ERROR;
 954     }
 955     FilePos += slen;
 956   }
 957
 958   for (i=0; i<GetNumberOfDimensions(); i++) {
 959     if (!raw) {
 960       sprintf(temp, "dim%d=%lu\n", i+1, GetDimensions(i));
 961       slen = strlen(temp);
 962       if (!checked_write(f, temp, slen, buffer)) {
 963         free(pCompressed);
 964         return AVS_ERROR;
 965       }
 966       FilePos += slen;
 967     }
 968   }
 969
 970   if (!raw) {
 971     sprintf(temp, "nspace=%d\n", GetNumberOfDimensions());
 972     slen = strlen(temp);
 973     if (!checked_write(f, temp, slen, buffer)) {
 974       free(pCompressed);
 975       return AVS_ERROR;
 976     }
 977     FilePos += slen;
 978
 979     sprintf(temp, "veclen=%d\n", GetNumberOfComponents());
 980     slen = strlen(temp);
 981     if (!checked_write(f, temp, slen, buffer)) {
 982       free(pCompressed);
 983       return AVS_ERROR;
 984     }
 985     FilePos += slen;
 986
 987     switch(GetComponentType()) {
 988     case itk::ImageIOBase::CHAR   :
 989       strcpy(temp, "data=byte\n");
 990       break;
 991     case itk::ImageIOBase::SHORT  :
 992       strcpy(temp, "data=xdr_short\n");
 993       break;
 994     case itk::ImageIOBase::INT    :
 995       strcpy(temp, "data=xdr_integer\n");
 996       break;
 997     case itk::ImageIOBase::FLOAT  :
 998       strcpy(temp, "data=xdr_real\n");
 999       break;
1000     case itk::ImageIOBase::DOUBLE :
1001       strcpy(temp, "data=xdr_double\n");
1002       break;
1003     default               :
1004       if (f != fileno(stdout)) close(f);
1005       free(pCompressed);
1006       return AVS_ERROR;
1007     }
1008     slen = strlen(temp);
1009     if (!checked_write(f, temp, slen, buffer)) {
1010       free(pCompressed);
1011       return AVS_ERROR;
1012     }
1013     FilePos += slen;
1014   }
1015
1016
1017   //FilePos = tell(f);
1018 ONCE_AGAIN:
1019
1020
1021   //switch(input->uniform)
1022   //{ case UNIFORM     :
1023   strcpy(temp, "field=uniform\n");
1024   coords = GetNumberOfDimensions() * 2;
1025   //       break;
1026   //  case RECTILINEAR : strcpy(temp, "field=rectilinear\n");
1027   //       break;
1028   //  case IRREGULAR   : strcpy(temp, "field=irregular\n");
1029   //       coords = total * input->nspace;
1030   //       break;
1031   //  default          : if (f != fileno(stdout)) close(f);
1032   //                     free(pCompressed);
1033   //                           return;
1034   //}
1035
1036   if (!raw) {
1037     if (!checked_write(f, temp, strlen(temp), buffer)) {
1038       free(pCompressed);
1039       return AVS_ERROR;
1040     }
1041
1042     if ((iNkiCompression > 0) &&
1043         (GetComponentType() == itk::ImageIOBase::SHORT) &&
1044         (GetPixelType() == itk::ImageIOBase::SCALAR)) {
1045       sprintf(temp, "nki_compression=%d", iNkiCompression);
1046       if (!checked_write(f, temp, strlen(temp), buffer)) {
1047         free(pCompressed);
1048         return AVS_ERROR;
1049       }
1050     }
1051
1052     temp[0] = temp[1] = 12;
1053     if (!checked_write(f, temp, 2, buffer)) {
1054       free(pCompressed);
1055       return AVS_ERROR;
1056     }
1057   }
1058
1059   total *= GetPixelSize();
1060
1061   if ((!raw) && (iNkiCompression > 0) &&
1062       (GetComponentType() == itk::ImageIOBase::SHORT) &&
1063       (GetPixelType() == itk::ImageIOBase::SCALAR)) {
1064     size_t      iCompressedLength;
1065
1066     iCompressedLength = nki_private_compress(pCompressed,
1067                         (short int *)(data), total/2, iNkiCompression);
1068
1069     if (iCompressedLength > 0) {
1070       if (!checked_write(f, pCompressed, iCompressedLength, buffer)) {
1071         free(pCompressed);
1072         return AVS_ERROR;
1073       }
1074       free(pCompressed);
1075       goto WRITE_COORDS;
1076     }
1077
1078     /* Compressionratio was poor: let's write uncompressed */
1079     iNkiCompression = 0;
1080     total /= 2;
1081     free(pCompressed);
1082     pCompressed = NULL;
1083     lseek(f, (unsigned int)FilePos, SEEK_SET); // use _lseeki64 just in case header size > UINT_MAX bytes
1084     goto ONCE_AGAIN;
1085   }
1086
1087   /* swap data if required (xdr is low-endian) */
1088
1089   if (!(*(char *)(&swap_test))) {
1090     if (GetComponentSize()==2) {
1091       c = (char *)data;
1092       for (i=0; i<total; i+=2) {
1093         cSwap  = c[i];
1094         c[i]   = c[i+1];
1095         c[i+1] = cSwap;
1096       }
1097     } else if (GetComponentSize()==4) {
1098       c = (char *)data;
1099       for (i=0; i<total; i+=4) {
1100         cSwap = c[i];
1101         c[i]   = c[i+3];
1102         c[i+3] = cSwap;
1103         cSwap = c[i+1];
1104         c[i+1] = c[i+2];
1105         c[i+2] = cSwap;
1106       }
1107     } else if (GetComponentSize()==8) {
1108       c = (char *)data;
1109       for (i=0; i<total; i+=8) {
1110         cSwap = c[i];
1111         c[i]   = c[i+7];
1112         c[i+7] = cSwap;
1113         cSwap = c[i+1];
1114         c[i+1] = c[i+6];
1115         c[i+6] = cSwap;
1116         cSwap = c[i+2];
1117         c[i+2] = c[i+5];
1118         c[i+5] = cSwap;
1119         cSwap = c[i+3];
1120         c[i+3] = c[i+4];
1121         c[i+4] = cSwap;
1122       }
1123     }
1124   }
1125
1126   if (total) {
1127     if (!checked_write(f, data, total, buffer))
1128       return AVS_ERROR;
1129   }
1130
1131   /* swap data back if was swapped before writing */
1132
1133   if (!(*(char *)(&swap_test))) {
1134     if (GetComponentSize()==2) {
1135       c = (char *)data;
1136       for (i=0; i<total; i+=2) {
1137         cSwap = c[i];
1138         c[i]   = c[i+1];
1139         c[i+1] = cSwap;
1140       }
1141     } else if (GetComponentSize()==4) {
1142       c = (char *)data;
1143       for (i=0; i<total; i+=4) {
1144         cSwap = c[i];
1145         c[i]   = c[i+3];
1146         c[i+3] = cSwap;
1147         cSwap = c[i+1];
1148         c[i+1] = c[i+2];
1149         c[i+2] = cSwap;
1150       }
1151     } else if (GetComponentSize()==8) {
1152       c = (char *)data;
1153       for (i=0; i<total; i+=8) {
1154         cSwap = c[i];
1155         c[i]   = c[i+7];
1156         c[i+7] = cSwap;
1157         cSwap = c[i+1];
1158         c[i+1] = c[i+6];
1159         c[i+6] = cSwap;
1160         cSwap = c[i+2];
1161         c[i+2] = c[i+5];
1162         c[i+5] = cSwap;
1163         cSwap = c[i+3];
1164         c[i+3] = c[i+4];
1165         c[i+4] = cSwap;
1166       }
1167     }
1168   }
1169
1170 WRITE_COORDS:
1171   float *points;
1172   points = (float *)malloc(sizeof(float)*GetNumberOfDimensions()*2);
1173   for (i=0; i<GetNumberOfDimensions(); i++) {
1174     points[i*2  ] = 0.1 *  GetOrigin(i);
1175     points[i*2+1] = 0.1 * (GetOrigin(i) + GetSpacing(i)*(GetDimensions(i)-1));
1176   }
1177
1178   if (coords && !raw) {                         /* write AVS coordinates ? */
1179     coords *= sizeof(float);
1180     if (!(*(char *)(&swap_test))) {
1181       c = (char *)(points);              /* swap bytes */
1182       for (i=0; i<coords; i+=4) {
1183         cSwap = c[i];
1184         c[i]   = c[i+3];
1185         c[i+3] = cSwap;
1186         cSwap = c[i+1];
1187         c[i+1] = c[i+2];
1188         c[i+2] = cSwap;
1189       }
1190     }
1191
1192     if (!checked_write(f, points, coords, buffer))
1193       return AVS_ERROR;
1194
1195     if (!(*(char *)(&swap_test))) {
1196       c = (char *)(points);              /* swap bytes back */
1197       for (i=0; i<coords; i+=4) {
1198         cSwap = c[i];
1199         c[i]   = c[i+3];
1200         c[i+3] = cSwap;
1201         cSwap = c[i+1];
1202         c[i+1] = c[i+2];
1203         c[i+2] = cSwap;
1204       }
1205     }
1206   }
1207
1208   if (!(tobuffer || getsize))
1209     if (f != fileno(stdout)) close(f);
1210
1211   if (getsize) return;
1212
1213 #ifdef _WIN32
1214   _set_fmode(oldFMode ? oldFMode : _O_TEXT); /* restore default binary i/o */
1215 #endif
1216
1217   return AVS_OK;
1218 }