Index: /trunk/Ohana/src/libfits/Makefile
===================================================================
--- /trunk/Ohana/src/libfits/Makefile	(revision 23723)
+++ /trunk/Ohana/src/libfits/Makefile	(revision 23724)
@@ -60,5 +60,6 @@
 $(EXT)/fits_hdecompress.$(ARCH).o \
 $(EXT)/pliocomp.$(ARCH).o \
-$(EXT)/ricecomp.$(ARCH).o
+$(EXT)/ricecomp.$(ARCH).o \
+$(EXT)/gzip.$(ARCH).o
 
 OBJS = $(HEADER_OBJ) $(MATRIX_OBJ) $(TABLE_OBJ) $(EXTERN_OBJ)
Index: /trunk/Ohana/src/libfits/extern/gzip.c
===================================================================
--- /trunk/Ohana/src/libfits/extern/gzip.c	(revision 23724)
+++ /trunk/Ohana/src/libfits/extern/gzip.c	(revision 23724)
@@ -0,0 +1,151 @@
+# include <ohana.h>
+# include <gfitsio.h>
+# include <zlib.h>
+
+/** the two functions in this file re-implement the uncompress function of zlib.  
+    For reasons I don't understand, it seems that I need to parse the header 
+    segment of the compressed data myself rather than ship it to 'uncompress'.  
+    It could be that CFITSIO is doing something bad, or it could be my 
+    misunderstanding **/
+
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.3, July 18th, 2005
+
+  Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+/*
+     The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed
+  data.  This version of the library supports only one compression method
+  (deflation) but other algorithms will be added later and will have the same
+  stream interface.
+
+     Compression can be done in a single step if the buffers are large
+  enough (for example if an input file is mmap'ed), or can be done by
+  repeated calls of the compression function.  In the latter case, the
+  application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+     The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+     The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+     This library can optionally read and write gzip streams in memory as well.
+
+     The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+     The library does not install any signal handler. The decoder checks
+  the consistency of the compressed data, so the library should never
+  crash even in case of corrupted input.
+*/
+
+// the header segments of a gzip file uses bytes and should not be swapped...
+int gfits_gz_stripheader (unsigned char *data, int *ndata) {
+  
+  int nstart, Ndata;
+
+  if (data[0] != 0x1f) return FALSE; // magic
+  if (data[1] != 0x8b) return FALSE; // magic
+  if (data[2] != 0x08) return FALSE; // DEFLATED
+  if (data[3] &  0xe0) return FALSE; // uses reserved flags?
+  
+  // data[4] - data[9] : time, xflags, OS code
+
+  nstart = 10; // data[nstart] is first byte after header
+
+  // check for an extra field
+  if (data[3] & 0x04) {
+    nstart += data[10];
+    nstart += (data[11] << 8); // data[10], data[11] are a single 2byte word that should be swapped
+  }
+  
+  // check for filename
+  if (data[3] & 0x08) {
+    while (data[nstart]) nstart ++;
+  }
+
+  // check for comment
+  if (data[3] & 0x10) {
+    while (data[nstart]) nstart ++;
+  }
+
+  // check for CRC
+  if (data[3] & 0x02) {
+    nstart ++;
+    nstart ++;
+  }
+
+  Ndata = *ndata - nstart;
+  memmove (data, &data[nstart], Ndata);
+  *ndata = Ndata;
+
+  return TRUE;
+}
+
+// XXX ??? is cfitsio writing data which is incompatible with zlib ???
+int gfits_uncompress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen)
+{
+    z_stream stream;
+    int err;
+
+    stream.next_in = (Bytef*)source;
+    stream.avail_in = (uInt)sourceLen;
+    /* Check for source > 64K on 16-bit machine: */
+    if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
+
+    stream.next_out = dest;
+    stream.avail_out = (uInt)*destLen;
+    if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
+
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+
+    // MAX_WBITS = 15
+    err = inflateInit2(&stream, -15);
+    if (err != Z_OK) return err;
+
+    err = inflate(&stream, Z_FINISH);
+    if (err != Z_STREAM_END) {
+        inflateEnd(&stream);
+        if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
+            return Z_DATA_ERROR;
+        return err;
+    }
+    *destLen = stream.total_out;
+
+    err = inflateEnd(&stream);
+    return err;
+}
Index: /trunk/Ohana/src/libfits/matrix/F_compress_M.c
===================================================================
--- /trunk/Ohana/src/libfits/matrix/F_compress_M.c	(revision 23723)
+++ /trunk/Ohana/src/libfits/matrix/F_compress_M.c	(revision 23724)
@@ -248,5 +248,8 @@
     // XXX not certain this is the correct place to do the swap (or if zdata_pixsize is
     // the correct size to guide the swap)
-    if (!gfits_byteswap_zdata (zdata, Nzdata, zdata_pixsize)) return (FALSE);
+
+    if (strcasecmp(cmptype, "GZIP_1")) {
+      if (!gfits_byteswap_zdata (zdata, Nzdata, zdata_pixsize)) return (FALSE);
+    }
 
     // gfits_uncompress_data uncompresses from zdata to the temporary output buffer which must be allocated
@@ -496,5 +499,10 @@
 
   if (!strcasecmp(cmptype, "GZIP_1")) {
-    return (4);
+    if (out_bitpix == 8)  return (1);
+    if (out_bitpix == 16) return (2);
+    if (out_bitpix == 32) return (4);
+    if (out_bitpix == -32) return (4);
+    if (out_bitpix == -64) return (8);
+    return (1);
   }
   if (!strcasecmp(cmptype, "RICE_1")) {
Index: /trunk/Ohana/src/libfits/matrix/F_uncompress_data.c
===================================================================
--- /trunk/Ohana/src/libfits/matrix/F_uncompress_data.c	(revision 23723)
+++ /trunk/Ohana/src/libfits/matrix/F_uncompress_data.c	(revision 23724)
@@ -22,4 +22,8 @@
 int pl_l2pi (short *ll_src, int xs, int *px_dst, int npix);
 
+/* functions defined in gzip.c */
+int gfits_gz_stripheader (unsigned char *data, int *ndata);
+int gfits_uncompress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen);
+
 int gfits_uncompress_data (char *zdata, int Nzdata, char *cmptype, char **optname, char **optvalue, int Nopt, char *outdata, int *Nout, int out_pixsize) {
 
@@ -30,11 +34,19 @@
   if (!strcasecmp(cmptype, "GZIP_1")) {
     unsigned long tNout = *Nout * out_pixsize;
+
+    // for GZIP data, I need to check for and remove the header on the first block:
+    gfits_gz_stripheader ((unsigned char *)zdata, &Nzdata);
+
     // uncompress does not require us to know the expected number of pixel; it tells us the number
-    status = uncompress ((Bytef *) outdata, &tNout, (Bytef *) zdata, Nzdata);
+    status = gfits_uncompress ((Bytef *) outdata, &tNout, (Bytef *) zdata, Nzdata);
     if (status != Z_OK) {
       fprintf (stderr, "error in uncompress (GZIP)\n");
       return (FALSE);
     }
-    *Nout = tNout;
+
+    // the resulting uncompressed data is byteswapped
+    if (!gfits_byteswap_zdata (outdata, tNout, out_pixsize)) return (FALSE);
+
+    *Nout = tNout / out_pixsize;
     return (TRUE);
   }