/*

  Teem: Tools to process and visualize scientific data and images             .

  Copyright (C) 2013, 2012, 2011, 2010, 2009  University of Chicago

  Copyright (C) 2008, 2007, 2006, 2005  Gordon Kindlmann

  Copyright (C) 2004, 2003, 2002, 2001, 2000, 1999, 1998  University of Utah

  This library is free software; you can redistribute it and/or

  modify it under the terms of the GNU Lesser General Public License

  (LGPL) as published by the Free Software Foundation; either

  version 2.1 of the License, or (at your option) any later version.

  The terms of redistributing and/or modifying this software also

  include exceptions to the LGPL that facilitate static linking.

  This library is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License

  along with this library; if not, write to Free Software Foundation, Inc.,

  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "nrrd.h"

#include "privateNrrd.h"

static int

_nrrdEncodingGzip_available(void) {

#if TEEM_ZLIB

#else

  return AIR_FALSE;

#endif

}

#if TEEM_ZLIB

/*

** Maximum size that allow zlib to try to read or write at once.

** The real limit is UINT_MAX, but a smaller value here permits

** exercising the multi-chunk capability of the code below.

*/

static unsigned int

_nrrdZlibMaxChunk = UINT_MAX;

#endif

/*

** nio->byteSkip < 0 functionality contributed by Katharina Quintus

*/

static int

_nrrdEncodingGzip_read(FILE *file, void *_data, size_t elNum,

                       Nrrd *nrrd, NrrdIoState *nio) {

  static const char me[]="_nrrdEncodingGzip_read";

#if TEEM_ZLIB

  size_t sizeData, sizeRed;

  int error;

  long int bi;

  char *data;

  gzFile gzfin;

  airPtrPtrUnion appu;

  /* Create the gzFile for reading in the gzipped data. */

    /* there was a problem */

  }

  /* keeps track of how many bytes have been successfully read in */

  sizeRed = 0;

  /* zlib can only handle data sizes up to UINT_MAX ==> if there's more than

     UINT_MAX bytes to read in, we read in in chunks. However, we wrap a value

     _nrrdZlibMaxChunk around UINT_MAX for testing purposes.  Given how

     sizeChunk is used below, we also cap chunk size at _nrrdZlibMaxChunk/2 to

     prevent overflow. */

    /* We don't know the size of the size to skip before the data, so

       decompress the data first into a temporary memory buffer.  Then

       the byteskipping is then just memcpy-ing the appropriate region

       of memory from "buff" into the given "_data" pointer */

    airArray *buffArr;

    long backwards;

    /* setting the airArray increment to twice the chunk size means that for

       headers that are small compared to the data, the airArray never

       actually has to reallocate.  The unit is 1 because we are managing

       the reading in terms of bytes (sizeof(char)==1 by definition) */

    appu.c = &buff;

    }

    /* we keep reading in chunks as long as there hasn't been an error,

       and we haven't hit EOF (EOF signified by read == 0).  Unlike the

       code below (for positive byteskip), we are obligated to read until

       the bitter end, and can't update sizeChunk to encompass only the

       required data. */

                                 sizeChunk, &didread))

        /* we were able to read as much data as we requested, maybe there is

           more, so we need to make our temp buffer bigger */

        }

        }

      }

    }

    }

    /* backwards is (positive) number of bytes AFTER data that we ignore */

      return 1;

    }

    /* also handles nio->byteSkip == -N-1 signifying extra N bytes at end */

    /* no negative byteskip: after byteskipping, we can read directly

       into given data buffer */

        /* Check to see if a single byte was able to be read. */

        }

      }

    }

    /* Pointer to chunks as we read them. */

    data = AIR_CAST(char *, _data);

      /* Increment the data pointer to the next available chunk. */

      /* We only want to read as much data as we need, so we need to check

         to make sure that we don't request data that might be there but that

         we don't want.  This will reduce sizeChunk when we get to the last

         block (which may be smaller than the original sizeChunk). */

      }

    }

    }

    /* Check to see if we got out as much as we thought we should. */

      return 1;

    }

  }

  /* Close the gzFile.  Since _nrrdGzClose does not close the FILE* we

     will not encounter problems when dataFile is closed later. */

  }

#else

  AIR_UNUSED(file);

  AIR_UNUSED(_data);

  AIR_UNUSED(elNum);

  AIR_UNUSED(nrrd);

  AIR_UNUSED(nio);

  biffAddf(NRRD, "%s: sorry, this nrrd not compiled with gzip enabled", me);

  return 1;

#endif

}

static int

_nrrdEncodingGzip_write(FILE *file, const void *_data, size_t elNum,

                        const Nrrd *nrrd, NrrdIoState *nio) {

  static const char me[]="_nrrdEncodingGzip_write";

#if TEEM_ZLIB

  size_t sizeData, sizeWrit;

  int fmt_i=0, error;

  const char *data;

  gzFile gzfout;

  /* Set format string based on the NrrdIoState parameters. */

  case nrrdZlibStrategyHuffman:

  case nrrdZlibStrategyFiltered:

  case nrrdZlibStrategyDefault:

  default:

    break;

  }

  /* Create the gzFile for writing in the gzipped data. */

    /* there was a problem */

  }

  /* zlib can only handle data sizes up to UINT_MAX ==> if there's more than

     UINT_MAX bytes to write out, we write out in chunks.  As above, we wrap

     _nrrdZlibMaxChunk around UINT_MAX for testing purposes. */

  /* keeps track of what how much has been successfully written */

  sizeWrit = 0;

  /* Pointer to the chunks as we write them. */

  data = AIR_CAST(const char *, _data);

  /* Ok, now we can begin writing. */

    /* Increment the data pointer to the next available spot. */

    /* We only want to write as much data as we need, so we need to check

       to make sure that we don't write more data than is there.  This

       will reduce sizeChunk when we get to the last block (which may

       be smaller than the original sizeChunk).

    */

  }

  }

  /* Check to see if we wrote out as much as we thought we should. */

    return 1;

  }

  /* Close the gzFile.  Since _nrrdGzClose does not close the FILE* we

     will not encounter problems when dataFile is closed later. */

  }

#else

  AIR_UNUSED(file);

  AIR_UNUSED(_data);

  AIR_UNUSED(elNum);

  AIR_UNUSED(nrrd);

  AIR_UNUSED(nio);

  biffAddf(NRRD, "%s: sorry, this nrrd not compiled with zlib "

           "(needed for gzip) enabled", me);

  return 1;

#endif

}

const NrrdEncoding

_nrrdEncodingGzip = {

  "gzip",      /* name */

  "raw.gz",    /* suffix */

  AIR_TRUE,    /* endianMatters */

  AIR_TRUE,   /* isCompression */

  _nrrdEncodingGzip_available,

  _nrrdEncodingGzip_read,

  _nrrdEncodingGzip_write

};

const NrrdEncoding *const

nrrdEncodingGzip = &_nrrdEncodingGzip;