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 mngjpeg_decompressinit (mng_datap pData)
{
#if defined(MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
mng_retcode iRetcode;
#endif
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_START)
#endif
#ifdef MNG_INCLUDE_IJG6B
/* allocate and initialize a JPEG decompression object */
pData->pJPEGdinfo->err = jpeg_std_error (pData->pJPEGderr);
#ifdef MNG_USE_SETJMP /* setup local JPEG error-routines */
pData->pJPEGderr->error_exit = mng_error_exit;
pData->pJPEGderr->output_message = mng_output_message;
iRetcode = setjmp (pData->sErrorbuf);/* setup local JPEG error-recovery */
if (iRetcode != 0) /* got here from longjmp ? */
MNG_ERRORJ (pData, iRetcode) /* then IJG-lib issued an error */
#endif /* MNG_USE_SETJMP */
/* allocate and initialize a JPEG decompression object (continued) */
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_JPEG_CREATE_DECOMPRESS)
#endif
jpeg_create_decompress (pData->pJPEGdinfo);
pData->bJPEGdecompress = MNG_TRUE; /* indicate it's initialized */
/* specify the source of the compressed data (eg, a file) */
/* no, not a file; we have buffered input */
pData->pJPEGdinfo->src = pData->pJPEGdsrc;
/* use the default handler */
pData->pJPEGdinfo->src->resync_to_restart = jpeg_resync_to_restart;
/* setup local source routine & parms */
pData->pJPEGdinfo->src->init_source = mng_init_source;
pData->pJPEGdinfo->src->fill_input_buffer = mng_fill_input_buffer;
pData->pJPEGdinfo->src->skip_input_data = mng_skip_input_data;
pData->pJPEGdinfo->src->term_source = mng_term_source;
pData->pJPEGdinfo->src->next_input_byte = pData->pJPEGcurrent;
pData->pJPEGdinfo->src->bytes_in_buffer = pData->iJPEGbufremain;
#endif /* MNG_INCLUDE_IJG6B */
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSINIT, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode mng_correct_full_cms (mng_datap pData)
{
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_CORRECT_FULL_CMS, MNG_LC_START);
#endif
cmsDoTransform (pData->hTrans, pData->pRGBArow, pData->pRGBArow, pData->iRowsamples);
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_CORRECT_FULL_CMS, MNG_LC_END);
#endif
return MNG_NOERROR;
}
mng_retcode differ_g16 (mng_datap pData)
{
mng_uint16p pRawi, pRawo;
mng_int32 iX;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_DIFFER_G16, MNG_LC_START)
#endif
pRawi = (mng_uint16p)(pData->pWorkrow + pData->iPixelofs);
pRawo = (mng_uint16p)(pData->pPrevrow + pData->iPixelofs);
for (iX = 0; iX < pData->iRowsamples; iX++)
{
*pRawo++ = (mng_uint16)(((mng_uint32)*pRawi + (mng_uint32)pData->iLevel0) & 0xFFFF);
pRawi++;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_DIFFER_G16, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode filter_paeth (mng_datap pData)
{
mng_int32 iBpp;
mng_uint8p pRawx;
mng_uint8p pRawx_prev;
mng_uint8p pPriorx;
mng_uint8p pPriorx_prev;
mng_int32 iX;
mng_uint32 iA, iB, iC;
mng_uint32 iP;
mng_uint32 iPa, iPb, iPc;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_FILTER_PAETH, MNG_LC_START)
#endif
iBpp = pData->iFilterbpp;
pRawx = pData->pWorkrow + pData->iPixelofs;
pPriorx = pData->pPrevrow + pData->iPixelofs;
pRawx_prev = pData->pWorkrow + pData->iPixelofs;
pPriorx_prev = pData->pPrevrow + pData->iPixelofs;
for (iX = 0; iX < iBpp; iX++)
{
*pRawx = (mng_uint8)(*pRawx + *pPriorx);
pRawx++;
pPriorx++;
}
for (iX = iBpp; iX < pData->iRowsize; iX++)
{
iA = (mng_uint32)*pRawx_prev;
iB = (mng_uint32)*pPriorx;
iC = (mng_uint32)*pPriorx_prev;
iP = iA + iB - iC;
iPa = abs (iP - iA);
iPb = abs (iP - iB);
iPc = abs (iP - iC);
if ((iPa <= iPb) && (iPa <= iPc))
*pRawx = (mng_uint8)(*pRawx + iA);
else
if (iPb <= iPc)
*pRawx = (mng_uint8)(*pRawx + iB);
else
*pRawx = (mng_uint8)(*pRawx + iC);
pRawx++;
pPriorx++;
pRawx_prev++;
pPriorx_prev++;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_FILTER_PAETH, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode differ_rgba16 (mng_datap pData)
{
mng_uint16p pRawi, pRawo;
mng_int32 iX;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_DIFFER_RGBA16, MNG_LC_START)
#endif
pRawi = (mng_uint16p)(pData->pWorkrow + pData->iPixelofs);
pRawo = (mng_uint16p)(pData->pPrevrow + pData->iPixelofs);
for (iX = 0; iX < pData->iRowsamples; iX++)
{
*(pRawo+1) = (mng_uint16)(((mng_uint32)*(pRawi+1) + (mng_uint32)pData->iLevel1) & 0xFFFF);
*pRawo = (mng_uint16)(((mng_uint32)*pRawi + (mng_uint32)pData->iLevel0 +
(mng_uint32)*(pRawo+1)) & 0xFFFF);
*(pRawo+2) = (mng_uint16)(((mng_uint32)*(pRawi+2) + (mng_uint32)pData->iLevel2 +
(mng_uint32)*(pRawo+1)) & 0xFFFF);
*(pRawo+3) = (mng_uint16)(((mng_uint32)*(pRawi+3) + (mng_uint32)pData->iLevel3) & 0xFFFF);
pRawi += 4;
pRawo += 4;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_DIFFER_RGBA16, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode filter_up (mng_datap pData)
{
mng_uint8p pRawx;
mng_uint8p pPriorx;
mng_int32 iX;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_FILTER_UP, MNG_LC_START)
#endif
pRawx = pData->pWorkrow + pData->iPixelofs;
pPriorx = pData->pPrevrow + pData->iPixelofs;
for (iX = 0; iX < pData->iRowsize; iX++)
{
*pRawx = (mng_uint8)(*pRawx + *pPriorx);
pRawx++;
pPriorx++;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_FILTER_UP, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode filter_sub (mng_datap pData)
{
mng_uint32 iBpp;
mng_uint8p pRawx;
mng_uint8p pRawx_prev;
mng_int32 iX;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_FILTER_SUB, MNG_LC_START)
#endif
iBpp = pData->iFilterbpp;
pRawx = pData->pWorkrow + pData->iPixelofs + iBpp;
pRawx_prev = pData->pWorkrow + pData->iPixelofs;
for (iX = iBpp; iX < pData->iRowsize; iX++)
{
*pRawx = (mng_uint8)(*pRawx + *pRawx_prev);
pRawx++;
pRawx_prev++;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_FILTER_SUB, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode differ_ga8 (mng_datap pData)
{
mng_uint8p pRawi, pRawo;
mng_int32 iX;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_DIFFER_GA8, MNG_LC_START)
#endif
pRawi = pData->pWorkrow + pData->iPixelofs;
pRawo = pData->pPrevrow + pData->iPixelofs;
for (iX = 0; iX < pData->iRowsamples; iX++)
{
*pRawo = (mng_uint8)(((mng_uint16)*pRawi + pData->iLevel0) & 0xFF);
*(pRawo+1) = (mng_uint8)(((mng_uint16)*(pRawi+1) + pData->iLevel1) & 0xFF);
pRawi += 2;
pRawo += 2;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_DIFFER_GA8, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode mng_correct_gamma_only (mng_datap pData)
{
mng_uint8p pWork;
mng_int32 iX;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_CORRECT_GAMMA_ONLY, MNG_LC_START);
#endif
pWork = pData->pRGBArow; /* address intermediate row */
if (pData->bIsRGBA16) /* 16-bit intermediate row ? */
{
/* TODO: 16-bit precision gamma processing */
/* we'll just do the high-order byte for now */
/* convert all samples in the row */
for (iX = 0; iX < pData->iRowsamples; iX++)
{ /* using the precalculated gamma lookup table */
*pWork = pData->aGammatab [*pWork];
*(pWork+2) = pData->aGammatab [*(pWork+2)];
*(pWork+4) = pData->aGammatab [*(pWork+4)];
pWork += 8;
}
}
else
{ /* convert all samples in the row */
for (iX = 0; iX < pData->iRowsamples; iX++)
{ /* using the precalculated gamma lookup table */
*pWork = pData->aGammatab [*pWork];
*(pWork+1) = pData->aGammatab [*(pWork+1)];
*(pWork+2) = pData->aGammatab [*(pWork+2)];
pWork += 4;
}
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_CORRECT_GAMMA_ONLY, MNG_LC_END);
#endif
return MNG_NOERROR;
}
mng_retcode mng_correct_app_cms (mng_datap pData)
{
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_CORRECT_APP_CMS, MNG_LC_START);
#endif
if (pData->fProcessarow) /* let the app do something with our row */
if (!pData->fProcessarow ((mng_handle)pData, pData->iRowsamples,
pData->bIsRGBA16, pData->pRGBArow))
MNG_ERROR (pData, MNG_APPCMSERROR);
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_CORRECT_APP_CMS, MNG_LC_END);
#endif
return MNG_NOERROR;
}
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 */
}
mng_retcode mng_clear_cms (mng_datap pData)
{
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_CLEAR_CMS, MNG_LC_START);
#endif
if (pData->hTrans) /* transformation still active ? */
mnglcms_freetransform (pData->hTrans);
pData->hTrans = 0;
if (pData->hProf1) /* file profile still active ? */
mnglcms_freeprofile (pData->hProf1);
pData->hProf1 = 0;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_CLEAR_CMS, MNG_LC_END);
#endif
return MNG_NOERROR;
}
mng_retcode differ_idx4 (mng_datap pData)
{
mng_uint8p pRawi, pRawo;
mng_int32 iX;
mng_int32 iC, iS;
mng_uint8 iB, iN, iQ;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_DIFFER_IDX4, MNG_LC_START)
#endif
pRawi = pData->pWorkrow + pData->iPixelofs;
pRawo = pData->pPrevrow + pData->iPixelofs;
iC = 0;
iB = 0;
iN = 0;
iS = 0;
for (iX = 0; iX < pData->iRowsamples; iX++)
{
if (!iC)
{
iC = 2;
iB = *pRawi++;
iN = 0;
iS = 8;
}
iS -= 4;
iQ = (mng_uint8)(((iB >> iS) + pData->iLevel0) & 0x0F);
iN = (mng_uint8)((iN << 4) + iQ);
iC--;
if (!iC)
*pRawo++ = iN;
}
if (iC)
*pRawo = (mng_uint8)(iN << iS);
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_DIFFER_IDX4, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode filter_average (mng_datap pData)
{
mng_int32 iBpp;
mng_uint8p pRawx;
mng_uint8p pRawx_prev;
mng_uint8p pPriorx;
mng_int32 iX;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_FILTER_AVERAGE, MNG_LC_START)
#endif
iBpp = pData->iFilterbpp;
pRawx = pData->pWorkrow + pData->iPixelofs;
pPriorx = pData->pPrevrow + pData->iPixelofs;
pRawx_prev = pData->pWorkrow + pData->iPixelofs;
for (iX = 0; iX < iBpp; iX++)
{
*pRawx = (mng_uint8)(*pRawx + ((*pPriorx) >> 1));
pRawx++;
pPriorx++;
}
for (iX = iBpp; iX < pData->iRowsize; iX++)
{
*pRawx = (mng_uint8)(*pRawx + ((*pRawx_prev + *pPriorx) >> 1));
pRawx++;
pPriorx++;
pRawx_prev++;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_FILTER_AVERAGE, MNG_LC_END)
#endif
return MNG_NOERROR;
}
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++;
}
}
mng_retcode mng_init_gamma_only (mng_datap pData,
mng_bool bGlobal,
mng_bool bObject,
mng_bool bRetrobj)
{
mng_float dGamma;
mng_imagep pImage = MNG_NULL;
mng_imagedatap pBuf = MNG_NULL;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_GAMMA_ONLY, MNG_LC_START);
#endif
if (bObject) /* use object if present ? */
{ /* current object ? */
if ((mng_imagep)pData->pCurrentobj)
pImage = (mng_imagep)pData->pCurrentobj;
else /* if not; use object 0 */
pImage = (mng_imagep)pData->pObjzero;
}
if (bRetrobj) /* retrieving from an object ? */
pImage = (mng_imagep)pData->pRetrieveobj;
if (pImage) /* are we using an object ? */
pBuf = pImage->pImgbuf; /* then address the buffer */
if ((!pBuf) || (!pBuf->bCorrected)) /* is the buffer already corrected ? */
{
if ((pBuf) && (pBuf->bHasSRGB)) /* get the gamma value */
dGamma = 0.45455;
else
if ((pBuf) && (pBuf->bHasGAMA))
dGamma = (mng_float)pBuf->iGamma / 100000;
else
if ((bGlobal) && (pData->bHasglobalSRGB))
dGamma = 0.45455;
else
if ((bGlobal) && (pData->bHasglobalGAMA))
dGamma = (mng_float)pData->iGlobalGamma / 100000;
else
dGamma = pData->dDfltimggamma;
if (dGamma > 0) /* ignore gamma=0 */
{
dGamma = pData->dViewgamma / (dGamma * pData->dDisplaygamma);
if (dGamma != pData->dLastgamma) /* lookup table needs to be computed ? */
{
mng_int32 iX;
pData->aGammatab [0] = 0;
for (iX = 1; iX <= 255; iX++)
pData->aGammatab [iX] = (mng_uint8)(pow (iX / 255.0, dGamma) * 255 + 0.5);
pData->dLastgamma = dGamma; /* keep for next time */
}
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_gamma_only;
}
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_GAMMA_ONLY, MNG_LC_END);
#endif
return MNG_NOERROR;
}
mng_retcode mng_init_app_cms (mng_datap pData,
mng_bool bGlobal,
mng_bool bObject,
mng_bool bRetrobj)
{
mng_imagep pImage = MNG_NULL;
mng_imagedatap pBuf = MNG_NULL;
mng_bool bDone = MNG_FALSE;
mng_retcode iRetcode;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_APP_CMS, MNG_LC_START);
#endif
if (bObject) /* use object if present ? */
{ /* current object ? */
if ((mng_imagep)pData->pCurrentobj)
pImage = (mng_imagep)pData->pCurrentobj;
else /* if not; use object 0 */
pImage = (mng_imagep)pData->pObjzero;
}
if (bRetrobj) /* retrieving from an object ? */
pImage = (mng_imagep)pData->pRetrieveobj;
if (pImage) /* are we using an object ? */
pBuf = pImage->pImgbuf; /* then address the buffer */
if ((!pBuf) || (!pBuf->bCorrected)) /* is the buffer already corrected ? */
{
#ifndef MNG_SKIPCHUNK_iCCP
if ( (pData->fProcessiccp) &&
(((pBuf) && (pBuf->bHasICCP)) || ((bGlobal) && (pData->bHasglobalICCP))) )
{
mng_uint32 iProfilesize;
mng_ptr pProfile;
if ((pBuf) && (pBuf->bHasICCP)) /* get the right profile */
{
iProfilesize = pBuf->iProfilesize;
pProfile = pBuf->pProfile;
}
else
{
iProfilesize = pData->iGlobalProfilesize;
pProfile = pData->pGlobalProfile;
}
/* inform the app */
if (!pData->fProcessiccp ((mng_handle)pData, iProfilesize, pProfile))
MNG_ERROR (pData, MNG_APPCMSERROR);
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_app_cms;
bDone = MNG_TRUE;
}
#endif
if ( (pData->fProcesssrgb) &&
(((pBuf) && (pBuf->bHasSRGB)) || ((bGlobal) && (pData->bHasglobalSRGB))) )
{
mng_uint8 iIntent;
if ((pBuf) && (pBuf->bHasSRGB)) /* determine rendering intent */
iIntent = pBuf->iRenderingintent;
else
iIntent = pData->iGlobalRendintent;
/* inform the app */
if (!pData->fProcesssrgb ((mng_handle)pData, iIntent))
MNG_ERROR (pData, MNG_APPCMSERROR);
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_app_cms;
bDone = MNG_TRUE;
}
#ifndef MNG_SKIPCHUNK_cHRM
if ( (pData->fProcesschroma) &&
(((pBuf) && (pBuf->bHasCHRM)) || ((bGlobal) && (pData->bHasglobalCHRM))) )
{
mng_uint32 iWhitepointx, iWhitepointy;
mng_uint32 iPrimaryredx, iPrimaryredy;
mng_uint32 iPrimarygreenx, iPrimarygreeny;
mng_uint32 iPrimarybluex, iPrimarybluey;
if ((pBuf) && (pBuf->bHasCHRM)) /* local cHRM ? */
{
iWhitepointx = pBuf->iWhitepointx;
iWhitepointy = pBuf->iWhitepointy;
iPrimaryredx = pBuf->iPrimaryredx;
iPrimaryredy = pBuf->iPrimaryredy;
iPrimarygreenx = pBuf->iPrimarygreenx;
iPrimarygreeny = pBuf->iPrimarygreeny;
iPrimarybluex = pBuf->iPrimarybluex;
iPrimarybluey = pBuf->iPrimarybluey;
}
else
{
iWhitepointx = pData->iGlobalWhitepointx;
iWhitepointy = pData->iGlobalWhitepointy;
iPrimaryredx = pData->iGlobalPrimaryredx;
iPrimaryredy = pData->iGlobalPrimaryredy;
iPrimarygreenx = pData->iGlobalPrimarygreenx;
iPrimarygreeny = pData->iGlobalPrimarygreeny;
iPrimarybluex = pData->iGlobalPrimarybluex;
iPrimarybluey = pData->iGlobalPrimarybluey;
}
/* inform the app */
if (!pData->fProcesschroma ((mng_handle)pData, iWhitepointx, iWhitepointy,
iPrimaryredx, iPrimaryredy,
iPrimarygreenx, iPrimarygreeny,
iPrimarybluex, iPrimarybluey))
MNG_ERROR (pData, MNG_APPCMSERROR);
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_app_cms;
bDone = MNG_TRUE;
}
#endif
if ( (pData->fProcessgamma) &&
(((pBuf) && (pBuf->bHasGAMA)) || ((bGlobal) && (pData->bHasglobalGAMA))) )
{
mng_uint32 iGamma;
if ((pBuf) && (pBuf->bHasGAMA)) /* get the gamma value */
iGamma = pBuf->iGamma;
else
iGamma = pData->iGlobalGamma;
/* inform the app */
if (!pData->fProcessgamma ((mng_handle)pData, iGamma))
{ /* app wants us to use internal routines ! */
iRetcode = mng_init_gamma_only (pData, bGlobal, bObject, bRetrobj);
if (iRetcode) /* on error bail out */
return iRetcode;
}
else
{ /* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_app_cms;
}
bDone = MNG_TRUE;
}
if (!bDone) /* no color-info at all ? */
{
/* then use default image gamma ! */
if (!pData->fProcessgamma ((mng_handle)pData,
(mng_uint32)((pData->dDfltimggamma * 100000) + 0.5)))
{ /* app wants us to use internal routines ! */
iRetcode = mng_init_gamma_only (pData, bGlobal, bObject, bRetrobj);
if (iRetcode) /* on error bail out */
return iRetcode;
}
else
{ /* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_app_cms;
}
}
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_APP_CMS, MNG_LC_END);
#endif
return MNG_NOERROR;
}
mng_retcode mngjpeg_cleanup (mng_datap pData)
{
#if defined(MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
mng_retcode iRetcode;
#endif
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_JPEG_CLEANUP, MNG_LC_START)
#endif
#ifdef MNG_INCLUDE_IJG6B
#ifdef MNG_USE_SETJMP
iRetcode = setjmp (pData->sErrorbuf);/* setup local JPEG error-recovery */
if (iRetcode != 0) /* got here from longjmp ? */
MNG_ERRORJ (pData, iRetcode) /* then IJG-lib issued an error */
#endif
#ifdef MNG_INCLUDE_JNG_READ /* still decompressing something ? */
if (pData->bJPEGdecompress)
jpeg_destroy_decompress (pData->pJPEGdinfo);
if (pData->bJPEGdecompress2)
jpeg_destroy_decompress (pData->pJPEGdinfo2);
#endif
#ifdef MNG_INCLUDE_JNG_WRITE
if (pData->bJPEGcompress) /* still compressing something ? */
jpeg_destroy_compress (pData->pJPEGcinfo);
#endif
#endif /* MNG_INCLUDE_IJG6B */
/* cleanup temporary buffers */
MNG_FREE (pData, pData->pJPEGbuf2, pData->iJPEGbufmax2)
MNG_FREE (pData, pData->pJPEGbuf, pData->iJPEGbufmax)
/* cleanup space for JPEG structures */
#ifdef MNG_INCLUDE_JNG_WRITE
MNG_FREE (pData, pData->pJPEGcinfo, sizeof (mngjpeg_comp ))
MNG_FREE (pData, pData->pJPEGcerr, sizeof (mngjpeg_error ))
#endif
#ifdef MNG_INCLUDE_JNG_READ
MNG_FREE (pData, pData->pJPEGdinfo, sizeof (mngjpeg_decomp))
MNG_FREE (pData, pData->pJPEGdsrc, sizeof (mngjpeg_source))
MNG_FREE (pData, pData->pJPEGderr, sizeof (mngjpeg_error ))
MNG_FREE (pData, pData->pJPEGdinfo2, sizeof (mngjpeg_decomp))
MNG_FREE (pData, pData->pJPEGdsrc2, sizeof (mngjpeg_source))
MNG_FREE (pData, pData->pJPEGderr2, sizeof (mngjpeg_error ))
#endif
MNG_FREE (pData, pData->pJPEGrow2, pData->iJPEGrowlen2)
MNG_FREE (pData, pData->pJPEGrow, pData->iJPEGrowlen)
/* whatever we were doing ... */
/* we don't anymore ... */
pData->bJPEGcompress = MNG_FALSE;
pData->bJPEGdecompress = MNG_FALSE;
pData->bJPEGhasheader = MNG_FALSE;
pData->bJPEGdecostarted = MNG_FALSE;
pData->bJPEGscanstarted = MNG_FALSE;
pData->bJPEGscanending = MNG_FALSE;
pData->bJPEGdecompress2 = MNG_FALSE;
pData->bJPEGhasheader2 = MNG_FALSE;
pData->bJPEGdecostarted2 = MNG_FALSE;
pData->bJPEGscanstarted2 = MNG_FALSE;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_JPEG_CLEANUP, MNG_LC_END)
#endif
return MNG_NOERROR;
}
mng_retcode mngjpeg_decompressdata (mng_datap pData,
mng_uint32 iRawsize,
mng_uint8p pRawdata)
{
mng_retcode iRetcode;
mng_uint32 iRemain;
mng_uint8p pWork;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_START)
#endif
#if defined (MNG_INCLUDE_IJG6B) && defined(MNG_USE_SETJMP)
iRetcode = setjmp (pData->sErrorbuf);/* initialize local JPEG error-recovery */
if (iRetcode != 0) /* got here from longjmp ? */
MNG_ERRORJ (pData, iRetcode) /* then IJG-lib issued an error */
#endif
pWork = pRawdata;
iRemain = iRawsize;
if (pData->iJPEGtoskip) /* JPEG-lib told us to skip some more data ? */
{
if (iRemain > pData->iJPEGtoskip) /* enough data in this buffer ? */
{
iRemain -= pData->iJPEGtoskip; /* skip enough to access the next byte */
pWork += pData->iJPEGtoskip;
pData->iJPEGtoskip = 0; /* no more to skip then */
}
else
{
pData->iJPEGtoskip -= iRemain; /* skip all data in the buffer */
iRemain = 0; /* and indicate this accordingly */
}
/* the skip set current-pointer to NULL ! */
pData->pJPEGcurrent = pData->pJPEGbuf;
}
while (iRemain) /* repeat until no more input-bytes */
{ /* need to shift anything ? */
if ((pData->pJPEGcurrent > pData->pJPEGbuf) &&
(pData->pJPEGcurrent - pData->pJPEGbuf + pData->iJPEGbufremain + iRemain > pData->iJPEGbufmax))
{
if (pData->iJPEGbufremain > 0) /* then do so */
MNG_COPY (pData->pJPEGbuf, pData->pJPEGcurrent, pData->iJPEGbufremain)
pData->pJPEGcurrent = pData->pJPEGbuf;
}
/* does the remaining input fit into the buffer ? */
if (pData->iJPEGbufremain + iRemain <= pData->iJPEGbufmax)
{ /* move the lot */
MNG_COPY ((pData->pJPEGcurrent + pData->iJPEGbufremain), pWork, iRemain)
pData->iJPEGbufremain += iRemain;/* adjust remaining_bytes counter */
iRemain = 0; /* and indicate there's no input left */
}
else
{ /* calculate what does fit */
mng_uint32 iFits = pData->iJPEGbufmax - pData->iJPEGbufremain;
if (iFits <= 0) /* no space is just bugger 'm all */
MNG_ERROR (pData, MNG_JPEGBUFTOOSMALL)
/* move that */
MNG_COPY ((pData->pJPEGcurrent + pData->iJPEGbufremain), pWork, iFits)
pData->iJPEGbufremain += iFits; /* adjust remain_bytes counter */
iRemain -= iFits; /* and the input-parms */
pWork += iFits;
}
#ifdef MNG_INCLUDE_IJG6B
pData->pJPEGdinfo->src->next_input_byte = pData->pJPEGcurrent;
pData->pJPEGdinfo->src->bytes_in_buffer = pData->iJPEGbufremain;
if (!pData->bJPEGhasheader) /* haven't got the header yet ? */
{
void *temp;
/* call jpeg_read_header() to obtain image info */
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_JPEG_DECOMPRESSDATA, MNG_LC_JPEG_READ_HEADER)
#endif
if (jpeg_read_header (pData->pJPEGdinfo, TRUE) != JPEG_SUSPENDED)
{ /* indicate the header's oke */
pData->bJPEGhasheader = MNG_TRUE;
/* let's do some sanity checks ! */
if ((pData->pJPEGdinfo->image_width != pData->iDatawidth ) ||
(pData->pJPEGdinfo->image_height != pData->iDataheight) )
MNG_ERROR (pData, MNG_JPEGPARMSERR)
if ( ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAY ) ||
(pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA) ) &&
(pData->pJPEGdinfo->jpeg_color_space != JCS_GRAYSCALE ) )
MNG_ERROR (pData, MNG_JPEGPARMSERR)
if ( ((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLOR ) ||
(pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) ) &&
(pData->pJPEGdinfo->jpeg_color_space != JCS_YCbCr ) )
MNG_ERROR (pData, MNG_JPEGPARMSERR)
/* indicate whether or not it's progressive */
pData->bJPEGprogressive = (mng_bool)jpeg_has_multiple_scans (pData->pJPEGdinfo);
/* progressive+alpha can't display "on-the-fly"!! */
if ((pData->bJPEGprogressive) &&
((pData->iJHDRcolortype == MNG_COLORTYPE_JPEGGRAYA ) ||
(pData->iJHDRcolortype == MNG_COLORTYPE_JPEGCOLORA) ))
pData->fDisplayrow = MNG_NULL;
/* allocate a row of JPEG-samples */
if (pData->pJPEGdinfo->jpeg_color_space == JCS_YCbCr)
pData->iJPEGrowlen = pData->pJPEGdinfo->image_width * 3;
else
pData->iJPEGrowlen = pData->pJPEGdinfo->image_width;
MNG_ALLOC (pData, temp, pData->iJPEGrowlen)
pData->pJPEGrow = (mng_uint8p)temp;
pData->iJPEGrgbrow = 0; /* quite empty up to now */
}
pData->pJPEGcurrent = (mng_uint8p)pData->pJPEGdinfo->src->next_input_byte;
pData->iJPEGbufremain = (mng_uint32)pData->pJPEGdinfo->src->bytes_in_buffer;
}
mng_retcode mng_init_full_cms (mng_datap pData,
mng_bool bGlobal,
mng_bool bObject,
mng_bool bRetrobj)
{
mng_cmsprof hProf;
mng_cmstrans hTrans;
mng_imagep pImage = MNG_NULL;
mng_imagedatap pBuf = MNG_NULL;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_FULL_CMS, MNG_LC_START);
#endif
if (bObject) /* use object if present ? */
{ /* current object ? */
if ((mng_imagep)pData->pCurrentobj)
pImage = (mng_imagep)pData->pCurrentobj;
else /* if not; use object 0 */
pImage = (mng_imagep)pData->pObjzero;
}
if (bRetrobj) /* retrieving from an object ? */
pImage = (mng_imagep)pData->pRetrieveobj;
if (pImage) /* are we using an object ? */
pBuf = pImage->pImgbuf; /* then address the buffer */
if ((!pBuf) || (!pBuf->bCorrected)) /* is the buffer already corrected ? */
{
#ifndef MNG_SKIPCHUNK_iCCP
if (((pBuf) && (pBuf->bHasICCP)) || ((bGlobal) && (pData->bHasglobalICCP)))
{
if (!pData->hProf2) /* output profile not defined ? */
{ /* then assume sRGB !! */
pData->hProf2 = mnglcms_createsrgbprofile ();
if (!pData->hProf2) /* handle error ? */
MNG_ERRORL (pData, MNG_LCMS_NOHANDLE);
}
if ((pBuf) && (pBuf->bHasICCP)) /* generate a profile handle */
hProf = cmsOpenProfileFromMem (pBuf->pProfile, pBuf->iProfilesize);
else
hProf = cmsOpenProfileFromMem (pData->pGlobalProfile, pData->iGlobalProfilesize);
pData->hProf1 = hProf; /* save for future use */
if (!hProf) /* handle error ? */
MNG_ERRORL (pData, MNG_LCMS_NOHANDLE);
#ifndef MNG_NO_16BIT_SUPPORT
if (pData->bIsRGBA16) /* 16-bit intermediates ? */
hTrans = cmsCreateTransform (hProf, TYPE_RGBA_16_SE,
pData->hProf2, TYPE_RGBA_16_SE,
INTENT_PERCEPTUAL, MNG_CMS_FLAGS);
else
#endif
hTrans = cmsCreateTransform (hProf, TYPE_RGBA_8,
pData->hProf2, TYPE_RGBA_8,
INTENT_PERCEPTUAL, MNG_CMS_FLAGS);
pData->hTrans = hTrans; /* save for future use */
if (!hTrans) /* handle error ? */
MNG_ERRORL (pData, MNG_LCMS_NOTRANS);
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_full_cms;
return MNG_NOERROR; /* and done */
}
else
#endif
if (((pBuf) && (pBuf->bHasSRGB)) || ((bGlobal) && (pData->bHasglobalSRGB)))
{
mng_uint8 iIntent;
if (pData->bIssRGB) /* sRGB system ? */
return MNG_NOERROR; /* no conversion required */
if (!pData->hProf3) /* sRGB profile not defined ? */
{ /* then create it implicitly !! */
pData->hProf3 = mnglcms_createsrgbprofile ();
if (!pData->hProf3) /* handle error ? */
MNG_ERRORL (pData, MNG_LCMS_NOHANDLE);
}
hProf = pData->hProf3; /* convert from sRGB profile */
if ((pBuf) && (pBuf->bHasSRGB)) /* determine rendering intent */
iIntent = pBuf->iRenderingintent;
else
iIntent = pData->iGlobalRendintent;
if (pData->bIsRGBA16) /* 16-bit intermediates ? */
hTrans = cmsCreateTransform (hProf, TYPE_RGBA_16_SE,
pData->hProf2, TYPE_RGBA_16_SE,
iIntent, MNG_CMS_FLAGS);
else
hTrans = cmsCreateTransform (hProf, TYPE_RGBA_8,
pData->hProf2, TYPE_RGBA_8,
iIntent, MNG_CMS_FLAGS);
pData->hTrans = hTrans; /* save for future use */
if (!hTrans) /* handle error ? */
MNG_ERRORL (pData, MNG_LCMS_NOTRANS);
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_full_cms;
return MNG_NOERROR; /* and done */
}
else
if ( (((pBuf) && (pBuf->bHasCHRM)) || ((bGlobal) && (pData->bHasglobalCHRM))) &&
( ((pBuf) && (pBuf->bHasGAMA) && (pBuf->iGamma > 0)) ||
((bGlobal) && (pData->bHasglobalGAMA) && (pData->iGlobalGamma > 0)) ) )
{
mng_CIExyY sWhitepoint;
mng_CIExyYTRIPLE sPrimaries;
mng_gammatabp pGammatable[3];
mng_float dGamma;
if (!pData->hProf2) /* output profile not defined ? */
{ /* then assume sRGB !! */
pData->hProf2 = mnglcms_createsrgbprofile ();
if (!pData->hProf2) /* handle error ? */
MNG_ERRORL (pData, MNG_LCMS_NOHANDLE);
}
#ifndef MNG_SKIPCHUNK_cHRM
if ((pBuf) && (pBuf->bHasCHRM)) /* local cHRM ? */
{
sWhitepoint.x = (mng_float)pBuf->iWhitepointx / 100000;
sWhitepoint.y = (mng_float)pBuf->iWhitepointy / 100000;
sPrimaries.Red.x = (mng_float)pBuf->iPrimaryredx / 100000;
sPrimaries.Red.y = (mng_float)pBuf->iPrimaryredy / 100000;
sPrimaries.Green.x = (mng_float)pBuf->iPrimarygreenx / 100000;
sPrimaries.Green.y = (mng_float)pBuf->iPrimarygreeny / 100000;
sPrimaries.Blue.x = (mng_float)pBuf->iPrimarybluex / 100000;
sPrimaries.Blue.y = (mng_float)pBuf->iPrimarybluey / 100000;
}
else
{
sWhitepoint.x = (mng_float)pData->iGlobalWhitepointx / 100000;
sWhitepoint.y = (mng_float)pData->iGlobalWhitepointy / 100000;
sPrimaries.Red.x = (mng_float)pData->iGlobalPrimaryredx / 100000;
sPrimaries.Red.y = (mng_float)pData->iGlobalPrimaryredy / 100000;
sPrimaries.Green.x = (mng_float)pData->iGlobalPrimarygreenx / 100000;
sPrimaries.Green.y = (mng_float)pData->iGlobalPrimarygreeny / 100000;
sPrimaries.Blue.x = (mng_float)pData->iGlobalPrimarybluex / 100000;
sPrimaries.Blue.y = (mng_float)pData->iGlobalPrimarybluey / 100000;
}
#endif
sWhitepoint.Y = /* Y component is always 1.0 */
sPrimaries.Red.Y =
sPrimaries.Green.Y =
sPrimaries.Blue.Y = 1.0;
if ((pBuf) && (pBuf->bHasGAMA)) /* get the gamma value */
dGamma = (mng_float)pBuf->iGamma / 100000;
else
dGamma = (mng_float)pData->iGlobalGamma / 100000;
dGamma = pData->dViewgamma / dGamma;
pGammatable [0] = /* and build the lookup tables */
pGammatable [1] =
pGammatable [2] = cmsBuildGamma (256, dGamma);
if (!pGammatable [0]) /* enough memory ? */
MNG_ERRORL (pData, MNG_LCMS_NOMEM);
/* create the profile */
hProf = cmsCreateRGBProfile (&sWhitepoint, &sPrimaries, pGammatable);
cmsFreeGamma (pGammatable [0]); /* free the temporary gamma tables ? */
/* yes! but just the one! */
pData->hProf1 = hProf; /* save for future use */
if (!hProf) /* handle error ? */
MNG_ERRORL (pData, MNG_LCMS_NOHANDLE);
if (pData->bIsRGBA16) /* 16-bit intermediates ? */
hTrans = cmsCreateTransform (hProf, TYPE_RGBA_16_SE,
pData->hProf2, TYPE_RGBA_16_SE,
INTENT_PERCEPTUAL, MNG_CMS_FLAGS);
else
hTrans = cmsCreateTransform (hProf, TYPE_RGBA_8,
pData->hProf2, TYPE_RGBA_8,
INTENT_PERCEPTUAL, MNG_CMS_FLAGS);
pData->hTrans = hTrans; /* save for future use */
if (!hTrans) /* handle error ? */
MNG_ERRORL (pData, MNG_LCMS_NOTRANS);
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)mng_correct_full_cms;
return MNG_NOERROR; /* and done */
}
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_FULL_CMS, MNG_LC_END);
#endif
/* if we get here, we'll only do gamma */
return mng_init_gamma_only (pData, bGlobal, bObject, bRetrobj);
}
