/* ************************************************************************** */

/* *             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,