Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-30 21:55:31 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
7f41e525df
gecko-dev/modules/libimg/mng/libmng_cms.c
tor%cs.brown.edu 067fdfadec Update tree libmng to 1.0.1 rs=blizzard
2001-05-20 17:36:25 +00:00

929 lines
34 KiB
C
Raw Blame History

/* ************************************************************************** */
/* * For conditions of distribution and use, * */
/* * see copyright notice in libmng.h * */
/* ************************************************************************** */
/* * * */
/* * project : libmng * */
/* * file : libmng_cms.c copyright (c) 2000 G.Juyn * */
/* * version : 1.0.1 * */
/* * * */
/* * purpose : color management routines (implementation) * */
/* * * */
/* * author : G.Juyn * */
/* * web : http://www.3-t.com * */
/* * email : mailto:info@3-t.com * */
/* * * */
/* * comment : implementation of the color management routines * */
/* * * */
/* * changes : 0.5.1 - 05/01/2000 - G.Juyn * */
/* * - B001(105795) - fixed a typo and misconception about * */
/* * freeing allocated gamma-table. (reported by Marti Maria) * */
/* * 0.5.1 - 05/08/2000 - G.Juyn * */
/* * - changed strict-ANSI stuff * */
/* * 0.5.1 - 05/09/2000 - G.Juyn * */
/* * - filled application-based color-management routines * */
/* * 0.5.1 - 05/11/2000 - G.Juyn * */
/* * - added creatememprofile * */
/* * - added callback error-reporting support * */
/* * 0.5.1 - 05/12/2000 - G.Juyn * */
/* * - changed trace to macro for callback error-reporting * */
/* * * */
/* * 0.5.2 - 06/10/2000 - G.Juyn * */
/* * - fixed some compilation-warnings (contrib Jason Morris) * */
/* * * */
/* * 0.5.3 - 06/21/2000 - G.Juyn * */
/* * - fixed problem with color-correction for stored images * */
/* * 0.5.3 - 06/23/2000 - G.Juyn * */
/* * - fixed problem with incorrect gamma-correction * */
/* * * */
/* * 0.9.2 - 08/05/2000 - G.Juyn * */
/* * - changed file-prefixes * */
/* * * */
/* * 0.9.3 - 08/31/2000 - G.Juyn * */
/* * - fixed sRGB precedence for gamma_only corection * */
/* * * */
/* * 0.9.4 - 12/16/2000 - G.Juyn * */
/* * - fixed mixup of data- & function-pointers (thanks Dimitri)* */
/* * * */
/* * 1.0.1 - 03/31/2001 - G.Juyn * */
/* * - ignore gamma=0 (see png-list for more info) * */
/* * 1.0.1 - 04/25/2001 - G.Juyn (reported by Gregg Kelly) * */
/* * - fixed problem with cms profile being created multiple * */
/* * times when both iCCP & cHRM/gAMA are present * */
/* * 1.0.1 - 04/25/2001 - G.Juyn * */
/* * - moved mng_clear_cms to libmng_cms * */
/* * 1.0.1 - 05/02/2001 - G.Juyn * */
/* * - added "default" sRGB generation (Thanks Marti!) * */
/* * * */
/* ************************************************************************** */
#include "libmng.h"
#include "libmng_data.h"
#include "libmng_error.h"
#include "libmng_trace.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#include "libmng_objects.h"
#include "libmng_cms.h"
#if defined(__BORLANDC__) && defined(MNG_STRICT_ANSI)
#pragma option -A /* force ANSI-C */
#endif
/* ************************************************************************** */
#ifdef MNG_INCLUDE_DISPLAY_PROCS
/* ************************************************************************** */
/* * * */
/* * Little CMS helper routines * */
/* * * */
/* ************************************************************************** */
#ifdef MNG_INCLUDE_LCMS
#define MNG_CMS_FLAGS 0
/* ************************************************************************** */
void mnglcms_initlibrary ()
{
cmsErrorAction (LCMS_ERROR_IGNORE); /* LCMS should ignore errors! */
}
/* ************************************************************************** */
mng_cmsprof mnglcms_createfileprofile (mng_pchar zFilename)
{
return cmsOpenProfileFromFile (zFilename, "r");
}
/* ************************************************************************** */
mng_cmsprof mnglcms_creatememprofile (mng_uint32 iProfilesize,
mng_ptr pProfile)
{
return cmsOpenProfileFromMem (pProfile, iProfilesize);
}
/* ************************************************************************** */
mng_cmsprof mnglcms_createsrgbprofile (void)
{
cmsCIExyY D65;
cmsCIExyYTRIPLE Rec709Primaries = {
{0.6400, 0.3300, 1.0},
{0.3000, 0.6000, 1.0},
{0.1500, 0.0600, 1.0}
};
LPGAMMATABLE Gamma24[3];
mng_cmsprof hsRGB;
cmsWhitePointFromTemp(6504, &D65);
Gamma24[0] = Gamma24[1] = Gamma24[2] = cmsBuildGamma(256, 2.4);
hsRGB = cmsCreateRGBProfile(&D65, &Rec709Primaries, Gamma24);
cmsFreeGamma(Gamma24[0]);
return hsRGB;
}
/* ************************************************************************** */
void mnglcms_freeprofile (mng_cmsprof hProf)
{
cmsCloseProfile (hProf);
return;
}
/* ************************************************************************** */
void mnglcms_freetransform (mng_cmstrans hTrans)
{
/* B001 start */
cmsDeleteTransform (hTrans);
/* B001 end */
return;
}
/* ************************************************************************** */
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;
}
/* ************************************************************************** */
#endif /* MNG_INCLUDE_LCMS */
/* ************************************************************************** */
/* * * */
/* * Color-management initialization & correction routines * */
/* * * */
/* ************************************************************************** */
#ifdef MNG_INCLUDE_LCMS
mng_retcode init_full_cms (mng_datap pData)
{
mng_cmsprof hProf;
mng_cmstrans hTrans;
mng_imagep pImage = (mng_imagep)pData->pCurrentobj;
mng_imagedatap pBuf;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_FULL_CMS, MNG_LC_START)
#endif
if (!pImage) /* no current object? then use object 0 */
pImage = (mng_imagep)pData->pObjzero;
pBuf = pImage->pImgbuf; /* address the buffer */
if ((pBuf->bHasICCP) || (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->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)
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)correct_full_cms;
return MNG_NOERROR; /* and done */
}
else
if ((pBuf->bHasSRGB) || (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->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)correct_full_cms;
return MNG_NOERROR; /* and done */
}
else
if ( ((pBuf->bHasCHRM) || (pData->bHasglobalCHRM)) &&
( ((pBuf->bHasGAMA) && (pBuf->iGamma > 0)) ||
((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)
}
if (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;
}
sWhitepoint.Y = /* Y component is always 1.0 */
sPrimaries.Red.Y =
sPrimaries.Green.Y =
sPrimaries.Blue.Y = 1.0;
if (pBuf->bHasGAMA) /* get the gamma value */
dGamma = (mng_float)pBuf->iGamma / 100000;
else
dGamma = (mng_float)pData->iGlobalGamma / 100000;
/* dGamma = pData->dViewgamma / (dGamma * pData->dDisplaygamma); ??? */
dGamma = pData->dViewgamma / dGamma;
pGammatable [0] = /* and build the lookup tables */
pGammatable [1] =
pGammatable [2] = cmsBuildGamma (256, dGamma);
/* B001 start */
if (!pGammatable [0]) /* enough memory ? */
/* B001 end */
MNG_ERRORL (pData, MNG_LCMS_NOMEM)
/* create the profile */
hProf = cmsCreateRGBProfile (&sWhitepoint, &sPrimaries, pGammatable);
/* B001 start */
cmsFreeGamma (pGammatable [0]); /* free the temporary gamma tables ? */
/* yes! but just the one! */
/* B001 end */
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)correct_full_cms;
return MNG_NOERROR; /* and done */
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_FULL_CMS, MNG_LC_END)
#endif
return init_gamma_only (pData); /* if we get here, we'll only do gamma */
}
#endif /* MNG_INCLUDE_LCMS */
/* ************************************************************************** */
#ifdef MNG_INCLUDE_LCMS
mng_retcode init_full_cms_object (mng_datap pData)
{
mng_cmsprof hProf;
mng_cmstrans hTrans;
mng_imagedatap pBuf;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_FULL_CMS_OBJ, MNG_LC_START)
#endif
/* address the object-buffer */
pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
if (pBuf->bHasICCP)
{
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)
}
/* generate a profile handle */
hProf = cmsOpenProfileFromMem (pBuf->pProfile, pBuf->iProfilesize);
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)correct_full_cms;
return MNG_NOERROR; /* and done */
}
else
if (pBuf->bHasSRGB)
{
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 (pData->bIsRGBA16) /* 16-bit intermediates ? */
hTrans = cmsCreateTransform (hProf, TYPE_RGBA_16_SE,
pData->hProf2, TYPE_RGBA_16_SE,
pBuf->iRenderingintent, MNG_CMS_FLAGS);
else
hTrans = cmsCreateTransform (hProf, TYPE_RGBA_8,
pData->hProf2, TYPE_RGBA_8,
pBuf->iRenderingintent, 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)correct_full_cms;
return MNG_NOERROR; /* and done */
}
else
if ((pBuf->bHasCHRM) && (pBuf->bHasGAMA) && (pBuf->iGamma > 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)
}
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;
sWhitepoint.Y = /* Y component is always 1.0 */
sPrimaries.Red.Y =
sPrimaries.Green.Y =
sPrimaries.Blue.Y = 1.0;
dGamma = (mng_float)pBuf->iGamma / 100000;
/* dGamma = pData->dViewgamma / (dGamma * pData->dDisplaygamma); ??? */
dGamma = pData->dViewgamma / dGamma;
pGammatable [0] = /* and build the lookup tables */
pGammatable [1] =
pGammatable [2] = cmsBuildGamma (256, dGamma);
/* B001 start */
if (!pGammatable [0]) /* enough memory ? */
/* B001 end */
MNG_ERRORL (pData, MNG_LCMS_NOMEM)
/* create the profile */
hProf = cmsCreateRGBProfile (&sWhitepoint, &sPrimaries, pGammatable);
/* B001 start */
cmsFreeGamma (pGammatable [0]); /* free the temporary gamma tables ? */
/* yes! but just the one! */
/* B001 end */
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)correct_full_cms;
return MNG_NOERROR; /* and done */
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_FULL_CMS_OBJ, MNG_LC_END)
#endif
/* if we get here, we'll only do gamma */
return init_gamma_only_object (pData);
}
#endif /* MNG_INCLUDE_LCMS */
/* ************************************************************************** */
#ifdef MNG_INCLUDE_LCMS
mng_retcode 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;
}
#endif /* MNG_INCLUDE_LCMS */
/* ************************************************************************** */
#if defined(MNG_GAMMA_ONLY) || defined(MNG_FULL_CMS)
mng_retcode init_gamma_only (mng_datap pData)
{
mng_float dGamma;
mng_imagep pImage = (mng_imagep)pData->pCurrentobj;
mng_imagedatap pBuf;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_GAMMA_ONLY, MNG_LC_START)
#endif
if (!pImage) /* no current object? then use object 0 */
pImage = (mng_imagep)pData->pObjzero;
pBuf = pImage->pImgbuf; /* address the buffer */
if (pBuf->bHasSRGB) /* get the gamma value */
dGamma = 0.45455;
else
if (pBuf->bHasGAMA)
dGamma = (mng_float)pBuf->iGamma / 100000;
else
if (pData->bHasglobalSRGB)
dGamma = 0.45455;
else
if (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)correct_gamma_only;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_GAMMA_ONLY, MNG_LC_END)
#endif
return MNG_NOERROR;
}
#endif /* MNG_GAMMA_ONLY || MNG_FULL_CMS */
/* ************************************************************************** */
#if defined(MNG_GAMMA_ONLY) || defined(MNG_FULL_CMS)
mng_retcode init_gamma_only_object (mng_datap pData)
{
mng_float dGamma;
mng_imagedatap pBuf;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_GAMMA_ONLY_OBJ, MNG_LC_START)
#endif
/* address the object-buffer */
pBuf = ((mng_imagep)pData->pRetrieveobj)->pImgbuf;
if (pBuf->bHasSRGB) /* get the gamma value */
dGamma = 0.45455;
else
if (pBuf->bHasGAMA)
dGamma = (mng_float)pBuf->iGamma / 100000;
else
dGamma = pData->dDfltimggamma;
if (dGamma) /* lets not divide by zero, shall we... */
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)correct_gamma_only;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_GAMMA_ONLY_OBJ, MNG_LC_END)
#endif
return MNG_NOERROR;
}
#endif /* MNG_GAMMA_ONLY || MNG_FULL_CMS */
/* ************************************************************************** */
#if defined(MNG_GAMMA_ONLY) || defined(MNG_FULL_CMS)
mng_retcode 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;
}
#endif /* MNG_GAMMA_ONLY || MNG_FULL_CMS */
/* ************************************************************************** */
#ifdef MNG_APP_CMS
mng_retcode init_app_cms (mng_datap pData)
{
mng_imagedatap pBuf = ((mng_imagep)pData->pObjzero)->pImgbuf;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_APP_CMS, MNG_LC_START)
#endif
if ( (pData->fProcessiccp) &&
((pBuf->bHasICCP) || (pData->bHasglobalICCP)) )
{
mng_uint32 iProfilesize;
mng_ptr pProfile;
if (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)correct_app_cms;
}
if ( (pData->fProcesssrgb) &&
((pBuf->bHasSRGB) || (pData->bHasglobalSRGB)) )
{
mng_uint8 iIntent;
if (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)correct_app_cms;
}
if ( (pData->fProcesschroma) &&
( ((pBuf->bHasCHRM) || (pData->bHasglobalCHRM)) ) )
{
mng_uint32 iWhitepointx, iWhitepointy;
mng_uint32 iPrimaryredx, iPrimaryredy;
mng_uint32 iPrimarygreenx, iPrimarygreeny;
mng_uint32 iPrimarybluex, iPrimarybluey;
if (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)correct_app_cms;
}
if ( (pData->fProcessgamma) &&
((pBuf->bHasGAMA) || (pData->bHasglobalGAMA)) )
{
mng_uint32 iGamma;
if (pBuf->bHasGAMA) /* get the gamma value */
iGamma = pBuf->iGamma;
else
iGamma = pData->iGlobalGamma;
/* inform the app */
if (!pData->fProcessgamma ((mng_handle)pData, iGamma))
MNG_ERROR (pData, MNG_APPCMSERROR)
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)correct_app_cms;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_APP_CMS, MNG_LC_END)
#endif
return MNG_NOERROR;
}
#endif /* MNG_APP_CMS */
/* ************************************************************************** */
#ifdef MNG_APP_CMS
mng_retcode init_app_cms_object (mng_datap pData)
{
mng_imagedatap pBuf = ((mng_imagep)pData->pCurrentobj)->pImgbuf;
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_APP_CMS_OBJ, MNG_LC_START)
#endif
if ((pData->fProcessiccp) && (pBuf->bHasICCP))
{ /* inform the app */
if (!pData->fProcessiccp ((mng_handle)pData, pBuf->iProfilesize, pBuf->pProfile))
MNG_ERROR (pData, MNG_APPCMSERROR)
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)correct_app_cms;
}
if ((pData->fProcesssrgb) && (pBuf->bHasSRGB))
{ /* inform the app */
if (!pData->fProcesssrgb ((mng_handle)pData, pBuf->iRenderingintent))
MNG_ERROR (pData, MNG_APPCMSERROR)
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)correct_app_cms;
}
if ((pData->fProcesschroma) && (pBuf->bHasCHRM))
{ /* inform the app */
if (!pData->fProcesschroma ((mng_handle)pData, pBuf->iWhitepointx, pBuf->iWhitepointy,
pBuf->iPrimaryredx, pBuf->iPrimaryredy,
pBuf->iPrimarygreenx, pBuf->iPrimarygreeny,
pBuf->iPrimarybluex, pBuf->iPrimarybluey))
MNG_ERROR (pData, MNG_APPCMSERROR)
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)correct_app_cms;
}
if ((pData->fProcessgamma) && (pBuf->bHasGAMA))
{ /* inform the app */
if (!pData->fProcessgamma ((mng_handle)pData, pBuf->iGamma))
MNG_ERROR (pData, MNG_APPCMSERROR)
/* load color-correction routine */
pData->fCorrectrow = (mng_fptr)correct_app_cms;
}
#ifdef MNG_SUPPORT_TRACE
MNG_TRACE (pData, MNG_FN_INIT_APP_CMS_OBJ, MNG_LC_END)
#endif
return MNG_NOERROR;
}
#endif /* MNG_APP_CMS */
/* ************************************************************************** */
#ifdef MNG_APP_CMS
mng_retcode 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;
}
#endif /* MNG_APP_CMS */
/* ************************************************************************** */
#endif /* MNG_INCLUDE_DISPLAY_PROCS */
/* ************************************************************************** */
/* * end of file * */
/* ************************************************************************** */
Reference in New Issue View Git Blame Copy Permalink