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