Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

1 files changed, 607 insertions, 0 deletions

diff --git a/src/3rdparty/libmng/libmng_zlib.c b/src/3rdparty/libmng/libmng_zlib.c
new file mode 100644
index 0000000000..7d102e160d
--- /dev/null
+++ b/src/3rdparty/libmng/libmng_zlib.c
@@ -0,0 +1,607 @@
+/* ************************************************************************** */
+/* *             For conditions of distribution and use,                    * */
+/* *                see copyright notice in libmng.h                        * */
+/* ************************************************************************** */
+/* *                                                                        * */
+/* * project   : libmng                                                     * */
+/* * file      : libmng_zlib.c             copyright (c) 2000-2004 G.Juyn   * */
+/* * version   : 1.0.9                                                      * */
+/* *                                                                        * */
+/* * purpose   : ZLIB library interface (implementation)                    * */
+/* *                                                                        * */
+/* * author    : G.Juyn                                                     * */
+/* *                                                                        * */
+/* * comment   : implementation of the ZLIB library interface               * */
+/* *                                                                        * */
+/* * changes   : 0.5.1 - 05/08/2000 - G.Juyn                                * */
+/* *             - changed strict-ANSI stuff                                * */
+/* *             0.5.1 - 05/11/2000 - G.Juyn                                * */
+/* *             - filled the deflatedata routine                           * */
+/* *             0.5.1 - 05/12/2000 - G.Juyn                                * */
+/* *             - changed trace to macro for callback error-reporting      * */
+/* *                                                                        * */
+/* *             0.5.2 - 05/20/2000 - G.Juyn                                * */
+/* *             - fixed for JNG alpha handling                             * */
+/* *             0.5.2 - 05/24/2000 - G.Juyn                                * */
+/* *             - moved init of default zlib parms from here to            * */
+/* *               "mng_hlapi.c"                                            * */
+/* *                                                                        * */
+/* *             0.5.3 - 06/16/2000 - G.Juyn                                * */
+/* *             - changed progressive-display processing                   * */
+/* *                                                                        * */
+/* *             0.9.2 - 08/05/2000 - G.Juyn                                * */
+/* *             - changed file-prefixes                                    * */
+/* *                                                                        * */
+/* *             0.9.3 - 08/08/2000 - G.Juyn                                * */
+/* *             - fixed compiler-warnings from Mozilla                     * */
+/* *             0.9.3 - 09/07/2000 - G.Juyn                                * */
+/* *             - added support for new filter_types                       * */
+/* *                                                                        * */
+/* *             1.0.5 - 08/07/2002 - G.Juyn                                * */
+/* *             - added test-option for PNG filter method 193 (=no filter) * */
+/* *             1.0.5 - 08/19/2002 - G.Juyn                                * */
+/* *             - B597134 - libmng pollutes the linker namespace           * */
+/* *             1.0.5 - 09/19/2002 - G.Juyn                                * */
+/* *             - added warning for too much IDAT data                     * */
+/* *                                                                        * */
+/* *             1.0.6 - 07/07/2003 - G.R-P                                 * */
+/* *             - added MNG_NO_16BIT_SUPPORT support                       * */
+/* *                                                                        * */
+/* *             1.0.9 - 10/09/2004 - G.R-P                                 * */
+/* *             - added MNG_NO_1_2_4BIT_SUPPORT support                    * */
+/* *                                                                        * */
+/* ************************************************************************** */
+
+#include "libmng.h"
+#include "libmng_data.h"
+#include "libmng_error.h"
+#include "libmng_trace.h"
+#ifdef __BORLANDC__
+#pragma hdrstop
+#endif
+#include "libmng_memory.h"
+#include "libmng_pixels.h"
+#include "libmng_filter.h"
+#include "libmng_zlib.h"
+
+#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
+#pragma option -A                      /* force ANSI-C */
+#endif
+
+/* ************************************************************************** */
+
+#ifdef MNG_INCLUDE_ZLIB
+
+/* ************************************************************************** */
+
+voidpf mngzlib_alloc (voidpf pData,
+                      uInt   iCount,
+                      uInt   iSize)
+{
+  voidpf pPtr;                         /* temporary space */
+
+#ifdef MNG_INTERNAL_MEMMNGMT
+  pPtr = calloc (iCount, iSize);       /* local allocation */
+#else
+  if (((mng_datap)pData)->fMemalloc)   /* callback function set ? */
+    pPtr = ((mng_datap)pData)->fMemalloc (iCount * iSize);
+  else
+    pPtr = Z_NULL;                     /* can't allocate! */
+#endif
+
+  return pPtr;                         /* return the result */
+}
+
+/* ************************************************************************** */
+
+void mngzlib_free (voidpf pData,
+                   voidpf pAddress)
+{
+#ifdef MNG_INTERNAL_MEMMNGMT
+  free (pAddress);                     /* free locally */
+#else
+  if (((mng_datap)pData)->fMemfree)    /* callback set? */
+    ((mng_datap)pData)->fMemfree (pAddress, 1);
+#endif
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_initialize (mng_datap pData)
+{
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INITIALIZE, MNG_LC_START);
+#endif
+
+#ifdef MNG_INTERNAL_MEMMNGMT
+  pData->sZlib.zalloc = Z_NULL;        /* let zlib figure out memory management */
+  pData->sZlib.zfree  = Z_NULL;
+  pData->sZlib.opaque = Z_NULL;
+#else                                  /* use user-provided callbacks */
+  pData->sZlib.zalloc = mngzlib_alloc;
+  pData->sZlib.zfree  = mngzlib_free;
+  pData->sZlib.opaque = (voidpf)pData;
+#endif
+
+  pData->bInflating   = MNG_FALSE;     /* not performing any action yet */
+  pData->bDeflating   = MNG_FALSE;
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INITIALIZE, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;                  /* done */
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_cleanup (mng_datap pData)
+{
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_CLEANUP, MNG_LC_START);
+#endif
+
+  if (pData->bInflating)               /* force zlib cleanup */
+    mngzlib_inflatefree (pData);
+  if (pData->bDeflating)
+    mngzlib_deflatefree (pData);
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_CLEANUP, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;                  /* done */
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_inflateinit (mng_datap pData)
+{
+  int iZrslt;
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INFLATEINIT, MNG_LC_START);
+#endif
+                                       /* initialize zlib structures and such */
+  iZrslt = inflateInit (&pData->sZlib);
+
+  if (iZrslt != Z_OK)                  /* on error bail out */
+    MNG_ERRORZ (pData, (mng_uint32)iZrslt);
+
+  pData->bInflating      = MNG_TRUE;   /* really inflating something now */
+  pData->sZlib.next_out  = 0;          /* force JIT initialization */
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INFLATEINIT, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;                  /* done */
+}
+
+/* ************************************************************************** */
+
+#ifdef MNG_SUPPORT_DISPLAY
+mng_retcode mngzlib_inflaterows (mng_datap  pData,
+                                 mng_uint32 iInlen,
+                                 mng_uint8p pIndata)
+{
+  int         iZrslt;
+  mng_retcode iRslt;
+  mng_ptr     pSwap;
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INFLATEROWS, MNG_LC_START);
+#endif
+
+  pData->sZlib.next_in   = pIndata;    /* let zlib know where to get stuff */
+  pData->sZlib.avail_in  = (uInt)iInlen;
+
+  if (pData->sZlib.next_out == 0)      /* initialize output variables ? */
+  {                                    /* let zlib know where to store stuff */
+    pData->sZlib.next_out  = pData->pWorkrow;
+    pData->sZlib.avail_out = (uInt)(pData->iRowsize + pData->iPixelofs);
+#ifdef MNG_NO_1_2_4BIT_SUPPORT
+    if (pData->iPNGdepth < 8)
+       pData->sZlib.avail_out = (uInt)((pData->iPNGdepth*pData->iRowsize + 7)/8
+           + pData->iPixelofs);
+#endif
+#ifdef MNG_NO_16BIT_SUPPORT
+    if (pData->iPNGdepth > 8)
+       pData->sZlib.avail_out = (uInt)(2*pData->iRowsize + pData->iPixelofs);
+#endif
+  }
+
+  do
+  {                                    /* now inflate a row */
+    iZrslt = inflate (&pData->sZlib, Z_SYNC_FLUSH);
+                                       /* produced a full row ? */
+    if (((iZrslt == Z_OK) || (iZrslt == Z_STREAM_END)) &&
+        (pData->sZlib.avail_out == 0))
+    {                                  /* image not completed yet ? */
+      if (pData->iRow < (mng_int32)pData->iDataheight)
+      {
+#ifdef MNG_NO_1_2_4BIT_SUPPORT
+        if (pData->iPNGdepth == 1)
+        {
+          /* Inflate Workrow to 8-bit */
+          mng_int32  iX;
+          mng_uint8p pSrc = pData->pWorkrow+1;
+          mng_uint8p pDest = pSrc + pData->iRowsize - (pData->iRowsize+7)/8;
+
+          for (iX = ((pData->iRowsize+7)/8) ; iX > 0 ; iX--)
+             *pDest++ = *pSrc++;
+
+          pDest = pData->pWorkrow+1;
+          pSrc = pDest + pData->iRowsize - (pData->iRowsize+7)/8;
+          for (iX = pData->iRowsize; ;)
+          {
+            *pDest++ = (((*pSrc)>>7)&1);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)>>6)&1);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)>>5)&1);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)>>4)&1);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)>>3)&1);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)>>2)&1);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)>>1)&1);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)   )&1);
+            if (iX-- <= 0)
+              break;
+            pSrc++;
+          }
+        }
+        else if (pData->iPNGdepth == 2)
+        {
+          /* Inflate Workrow to 8-bit */
+          mng_int32  iX;
+          mng_uint8p pSrc = pData->pWorkrow+1;
+          mng_uint8p pDest = pSrc + pData->iRowsize - (2*pData->iRowsize+7)/8;
+
+          for (iX = ((2*pData->iRowsize+7)/8) ; iX > 0 ; iX--)
+             *pDest++ = *pSrc++;
+
+          pDest = pData->pWorkrow+1;
+          pSrc = pDest + pData->iRowsize - (2*pData->iRowsize+7)/8;
+          for (iX = pData->iRowsize; ;)
+          {
+            *pDest++ = (((*pSrc)>>6)&3);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)>>4)&3);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)>>2)&3);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)   )&3);
+            if (iX-- <= 0)
+              break;
+            pSrc++;
+          }
+        }
+        else if (pData->iPNGdepth == 4)
+        {
+          /* Inflate Workrow to 8-bit */
+          mng_int32  iX;
+          mng_uint8p pSrc = pData->pWorkrow+1;
+          mng_uint8p pDest = pSrc + pData->iRowsize - (4*pData->iRowsize+7)/8;
+
+          for (iX = ((4*pData->iRowsize+7)/8) ; iX > 0 ; iX--)
+             *pDest++ = *pSrc++;
+
+          pDest = pData->pWorkrow+1;
+          pSrc = pDest + pData->iRowsize - (4*pData->iRowsize+7)/8;
+          for (iX = pData->iRowsize; ;)
+          {
+            *pDest++ = (((*pSrc)>>4)&0x0f);
+            if (iX-- <= 0)
+              break;
+            *pDest++ = (((*pSrc)   )&0x0f);
+            if (iX-- <= 0)
+              break;
+            pSrc++;
+          }
+        }
+        if (pData->iPNGdepth < 8 && pData->iColortype == 0)
+        {
+          /* Expand samples to 8-bit by LBR */
+          mng_int32  iX;
+          mng_uint8p pSrc = pData->pWorkrow+1;
+          mng_uint8 multiplier[]={0,255,85,0,17,0,0,0,1};
+
+          for (iX = pData->iRowsize; iX > 0; iX--)
+              *pSrc++ *= multiplier[pData->iPNGdepth];
+        }
+#endif
+#ifdef MNG_NO_16BIT_SUPPORT
+        if (pData->iPNGdepth > 8)
+        {
+          /* Reduce Workrow to 8-bit */
+          mng_int32  iX;
+          mng_uint8p pSrc = pData->pWorkrow+1;
+          mng_uint8p pDest = pSrc;
+
+          for (iX = pData->iRowsize; iX > 0; iX--)
+          {
+            *pDest = *pSrc;
+            pDest++;
+            pSrc+=2;
+          }
+        }
+#endif
+
+#ifdef FILTER192                       /* has leveling info ? */
+        if (pData->iFilterofs == MNG_FILTER_DIFFERING)
+          iRslt = init_rowdiffering (pData);
+        else
+#endif
+          iRslt = MNG_NOERROR;
+                                       /* filter the row if necessary */
+        if ((!iRslt) && (pData->iFilterofs < pData->iPixelofs  ) &&
+                        (*(pData->pWorkrow + pData->iFilterofs))    )
+          iRslt = mng_filter_a_row (pData);
+        else
+          iRslt = MNG_NOERROR;
+                                       /* additional leveling/differing ? */
+        if ((!iRslt) && (pData->fDifferrow))
+        {
+          iRslt = ((mng_differrow)pData->fDifferrow) (pData);
+
+          pSwap           = pData->pWorkrow;
+          pData->pWorkrow = pData->pPrevrow;
+          pData->pPrevrow = pSwap;     /* make sure we're processing the right data */
+        }
+
+        if (!iRslt)
+        {
+#ifdef MNG_INCLUDE_JNG
+          if (pData->bHasJHDR)         /* is JNG alpha-channel ? */
+          {                            /* just store in object ? */
+            if ((!iRslt) && (pData->fStorerow))
+              iRslt = ((mng_storerow)pData->fStorerow)     (pData);
+          }
+          else
+#endif /* MNG_INCLUDE_JNG */
+          {                            /* process this row */
+            if ((!iRslt) && (pData->fProcessrow))
+              iRslt = ((mng_processrow)pData->fProcessrow) (pData);
+                                       /* store in object ? */
+            if ((!iRslt) && (pData->fStorerow))
+              iRslt = ((mng_storerow)pData->fStorerow)     (pData);
+                                       /* color correction ? */
+            if ((!iRslt) && (pData->fCorrectrow))
+              iRslt = ((mng_correctrow)pData->fCorrectrow) (pData);
+                                       /* slap onto canvas ? */
+            if ((!iRslt) && (pData->fDisplayrow))
+            {
+              iRslt = ((mng_displayrow)pData->fDisplayrow) (pData);
+
+              if (!iRslt)              /* check progressive display refresh */
+                iRslt = mng_display_progressive_check (pData);
+
+            }
+          }
+        }
+
+        if (iRslt)                     /* on error bail out */
+          MNG_ERROR (pData, iRslt);
+
+        if (!pData->fDifferrow)        /* swap row-pointers */
+        {
+          pSwap           = pData->pWorkrow;
+          pData->pWorkrow = pData->pPrevrow;
+          pData->pPrevrow = pSwap;     /* so prev points to the processed row! */
+        }
+
+        iRslt = mng_next_row (pData);  /* adjust variables for next row */
+
+        if (iRslt)                     /* on error bail out */
+          MNG_ERROR (pData, iRslt);
+      }
+                                       /* let zlib know where to store next output */
+      pData->sZlib.next_out  = pData->pWorkrow;
+      pData->sZlib.avail_out = (uInt)(pData->iRowsize + pData->iPixelofs);
+#ifdef MNG_NO_1_2_4BIT_SUPPORT
+    if (pData->iPNGdepth < 8)
+       pData->sZlib.avail_out = (uInt)((pData->iPNGdepth*pData->iRowsize + 7)/8
+           + pData->iPixelofs);
+#endif
+#ifdef MNG_NO_16BIT_SUPPORT
+      if (pData->iPNGdepth > 8)
+        pData->sZlib.avail_out = (uInt)(2*pData->iRowsize + pData->iPixelofs);
+#endif
+    }
+  }                                    /* until some error or EOI
+                                          or all pixels received */
+  while ( (iZrslt == Z_OK) && (pData->sZlib.avail_in > 0)      &&
+          ( (pData->iRow < (mng_int32)pData->iDataheight) ||
+            ( (pData->iPass >= 0) && (pData->iPass < 7) )    )    );
+                                       /* on error bail out */
+  if ((iZrslt != Z_OK) && (iZrslt != Z_STREAM_END))
+    MNG_ERRORZ (pData, (mng_uint32)iZrslt);
+                                       /* too much data ? */
+  if ((iZrslt == Z_OK) && (pData->sZlib.avail_in > 0))
+    MNG_WARNING (pData, MNG_TOOMUCHIDAT);
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INFLATEROWS, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;
+}
+#endif /* MNG_SUPPORT_DISPLAY */
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_inflatedata (mng_datap  pData,
+                                 mng_uint32 iInlen,
+                                 mng_uint8p pIndata)
+{
+  int iZrslt;
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INFLATEDATA, MNG_LC_START);
+#endif
+                                       /* let zlib know where to get stuff */
+  pData->sZlib.next_in   = pIndata;
+  pData->sZlib.avail_in  = (uInt)iInlen;
+                                       /* now inflate the data in one go! */
+  iZrslt = inflate (&pData->sZlib, Z_FINISH);
+                                       /* not enough room in output-buffer ? */
+  if ((iZrslt == Z_BUF_ERROR) || (pData->sZlib.avail_in > 0))
+    return MNG_BUFOVERFLOW;
+                                       /* on error bail out */
+  if ((iZrslt != Z_OK) && (iZrslt != Z_STREAM_END))
+    MNG_ERRORZ (pData, (mng_uint32)iZrslt);
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INFLATEDATA, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_inflatefree (mng_datap pData)
+{
+  int iZrslt;
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INFLATEFREE, MNG_LC_START);
+#endif
+
+  pData->bInflating = MNG_FALSE;       /* stopped it */
+
+  iZrslt = inflateEnd (&pData->sZlib); /* let zlib cleanup its own stuff */
+
+  if (iZrslt != Z_OK)                  /* on error bail out */
+    MNG_ERRORZ (pData, (mng_uint32)iZrslt);
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_INFLATEFREE, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;                  /* done */
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_deflateinit (mng_datap pData)
+{
+  int iZrslt;
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_DEFLATEINIT, MNG_LC_START);
+#endif
+                                       /* initialize zlib structures and such */
+  iZrslt = deflateInit2 (&pData->sZlib, pData->iZlevel, pData->iZmethod,
+                         pData->iZwindowbits, pData->iZmemlevel,
+                         pData->iZstrategy);
+
+  if (iZrslt != Z_OK)                  /* on error bail out */
+    MNG_ERRORZ (pData, (mng_uint32)iZrslt);
+
+  pData->bDeflating = MNG_TRUE;        /* really deflating something now */
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_DEFLATEINIT, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;                  /* done */
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_deflaterows (mng_datap  pData,
+                                 mng_uint32 iInlen,
+                                 mng_uint8p pIndata)
+{
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_DEFLATEROWS, MNG_LC_START);
+#endif
+
+
+
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_DEFLATEROWS, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_deflatedata (mng_datap  pData,
+                                 mng_uint32 iInlen,
+                                 mng_uint8p pIndata)
+{
+  int iZrslt;
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_DEFLATEDATA, MNG_LC_START);
+#endif
+
+  pData->sZlib.next_in  = pIndata;     /* let zlib know where to get stuff */
+  pData->sZlib.avail_in = (uInt)iInlen;
+                                       /* now deflate the data in one go! */
+  iZrslt = deflate (&pData->sZlib, Z_FINISH);
+                                       /* not enough room in output-buffer ? */
+  if ((iZrslt == Z_BUF_ERROR) || (pData->sZlib.avail_in > 0))
+    return MNG_BUFOVERFLOW;
+                                       /* on error bail out */
+  if ((iZrslt != Z_OK) && (iZrslt != Z_STREAM_END))
+    MNG_ERRORZ (pData, (mng_uint32)iZrslt);
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_DEFLATEDATA, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;
+}
+
+/* ************************************************************************** */
+
+mng_retcode mngzlib_deflatefree (mng_datap pData)
+{
+  int iZrslt;
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_DEFLATEFREE, MNG_LC_START);
+#endif
+
+  iZrslt = deflateEnd (&pData->sZlib); /* let zlib cleanup its own stuff */
+
+  if (iZrslt != Z_OK)                  /* on error bail out */
+    MNG_ERRORZ (pData, (mng_uint32)iZrslt);
+
+  pData->bDeflating = MNG_FALSE;       /* stopped it */
+
+#ifdef MNG_SUPPORT_TRACE
+  MNG_TRACE (pData, MNG_FN_ZLIB_DEFLATEFREE, MNG_LC_END);
+#endif
+
+  return MNG_NOERROR;                  /* done */
+}
+
+/* ************************************************************************** */
+
+#endif /* MNG_INCLUDE_ZLIB */
+
+/* ************************************************************************** */
+/* * end of file                                                            * */
+/* ************************************************************************** */
+