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