Skip to content
Snippets Groups Projects
Commit f550f624 authored by Alexandre Julliard's avatar Alexandre Julliard
Browse files

libs: Import code from upstream lcms2 2.12.

parent d36615ee
No related branches found
No related tags found
No related merge requests found
Showing
with 17127 additions and 0 deletions
......@@ -707,6 +707,8 @@ TIFF_PE_LIBS
TIFF_PE_CFLAGS
PNG_PE_LIBS
PNG_PE_CFLAGS
LCMS2_PE_LIBS
LCMS2_PE_CFLAGS
JPEG_PE_LIBS
JPEG_PE_CFLAGS
EXCESS_PRECISION_CFLAGS
......@@ -1785,6 +1787,7 @@ enable_dxerr8
enable_dxerr9
enable_dxguid
enable_jpeg
enable_lcms2
enable_mfuuid
enable_png
enable_strmiids
......@@ -1926,6 +1929,8 @@ OBJCFLAGS
OBJCPP
JPEG_PE_CFLAGS
JPEG_PE_LIBS
LCMS2_PE_CFLAGS
LCMS2_PE_LIBS
PNG_PE_CFLAGS
PNG_PE_LIBS
TIFF_PE_CFLAGS
......@@ -2714,6 +2719,11 @@ Some influential environment variables:
C compiler flags for the PE jpeg, overriding the bundled version
JPEG_PE_LIBS
Linker flags for the PE jpeg, overriding the bundled version
LCMS2_PE_CFLAGS
C compiler flags for the PE lcms2, overriding the bundled
version
LCMS2_PE_LIBS
Linker flags for the PE lcms2, overriding the bundled version
PNG_PE_CFLAGS
C compiler flags for the PE png, overriding the bundled version
PNG_PE_LIBS Linker flags for the PE png, overriding the bundled version
......@@ -10720,6 +10730,19 @@ fi
$as_echo "$as_me:${as_lineno-$LINENO}: jpeg cflags: $JPEG_PE_CFLAGS" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: jpeg libs: $JPEG_PE_LIBS" >&5
 
if ${LCMS2_PE_CFLAGS:+false} :; then :
LCMS2_PE_CFLAGS="-I\$(top_srcdir)/libs/lcms2/include"
else
enable_lcms2=no
fi
if ${LCMS2_PE_LIBS:+false} :; then :
LCMS2_PE_LIBS=lcms2
else
enable_lcms2=no
fi
$as_echo "$as_me:${as_lineno-$LINENO}: lcms2 cflags: $LCMS2_PE_CFLAGS" >&5
$as_echo "$as_me:${as_lineno-$LINENO}: lcms2 libs: $LCMS2_PE_LIBS" >&5
if ${PNG_PE_CFLAGS:+false} :; then :
PNG_PE_CFLAGS="-I\$(top_srcdir)/libs/png"
else
......@@ -19487,6 +19510,8 @@ METAL_LIBS = $METAL_LIBS
EXCESS_PRECISION_CFLAGS = $EXCESS_PRECISION_CFLAGS
JPEG_PE_CFLAGS = $JPEG_PE_CFLAGS
JPEG_PE_LIBS = $JPEG_PE_LIBS
LCMS2_PE_CFLAGS = $LCMS2_PE_CFLAGS
LCMS2_PE_LIBS = $LCMS2_PE_LIBS
PNG_PE_CFLAGS = $PNG_PE_CFLAGS
PNG_PE_LIBS = $PNG_PE_LIBS
TIFF_PE_CFLAGS = $TIFF_PE_CFLAGS
......@@ -20782,6 +20807,7 @@ wine_fn_config_makefile libs/dxerr8 enable_dxerr8
wine_fn_config_makefile libs/dxerr9 enable_dxerr9
wine_fn_config_makefile libs/dxguid enable_dxguid
wine_fn_config_makefile libs/jpeg enable_jpeg
wine_fn_config_makefile libs/lcms2 enable_lcms2
wine_fn_config_makefile libs/mfuuid enable_mfuuid
wine_fn_config_makefile libs/png enable_png
wine_fn_config_makefile libs/strmiids enable_strmiids
......
......@@ -1062,6 +1062,7 @@ WINE_NOTICE_WITH(mingw,[test "x$CROSSTARGET" = "x"],
dnl **** External libraries ****
WINE_EXTLIB_FLAGS(JPEG, jpeg, jpeg, "-I\$(top_srcdir)/libs/jpeg")
WINE_EXTLIB_FLAGS(LCMS2, lcms2, lcms2, "-I\$(top_srcdir)/libs/lcms2/include")
WINE_EXTLIB_FLAGS(PNG, png, "png \$(ZLIB_PE_LIBS)", "-I\$(top_srcdir)/libs/png")
WINE_EXTLIB_FLAGS(TIFF, tiff, tiff, "-I\$(top_srcdir)/libs/tiff/libtiff")
WINE_EXTLIB_FLAGS(ZLIB, zlib, z, "-I\$(top_srcdir)/libs/zlib -DFAR= -DZ_SOLO")
......@@ -3781,6 +3782,7 @@ WINE_CONFIG_MAKEFILE(libs/dxerr8)
WINE_CONFIG_MAKEFILE(libs/dxerr9)
WINE_CONFIG_MAKEFILE(libs/dxguid)
WINE_CONFIG_MAKEFILE(libs/jpeg)
WINE_CONFIG_MAKEFILE(libs/lcms2)
WINE_CONFIG_MAKEFILE(libs/mfuuid)
WINE_CONFIG_MAKEFILE(libs/png)
WINE_CONFIG_MAKEFILE(libs/strmiids)
......
Main Author
------------
Marti Maria
Contributors
------------
Bob Friesenhahn
Kai-Uwe Behrmann
Stuart Nixon
Jordi Vilar
Richard Hughes
Auke Nauta
Chris Evans (Google)
Lorenzo Ridolfi
Robin Watts (Artifex)
Shawn Pedersen
Andrew Brygin
Samuli Suominen
Florian Hch
Aurelien Jarno
Claudiu Cebuc
Michael Vhrel (Artifex)
Michal Cihar
Daniel Kaneider
Mateusz Jurczyk (Google)
Paul Miller
Sbastien Lon
Christian Schmitz
XhmikosR
Stanislav Brabec (SuSe)
Leonhard Gruenschloss (Google)
Patrick Noffke
Christopher James Halse Rogers
John Hein
Thomas Weber (Debian)
Mark Allen
Noel Carboni
Sergei Trofimovic
Philipp Knechtges
Special Thanks
--------------
Artifex software
AlienSkin software
Jan Morovic
Jos Vernon (WebSupergoo)
Harald Schneider (Maxon)
Christian Albrecht
Dimitrios Anastassakis
Lemke Software
Tim Zaman
Little CMS
Copyright (c) 1998-2020 Marti Maria Saguer
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject
to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
EXTLIB = liblcms2.a
EXTRAINCL = -I$(srcdir)/include
C_SRCS = \
src/cmsalpha.c \
src/cmscnvrt.c \
src/cmserr.c \
src/cmsgamma.c \
src/cmsgmt.c \
src/cmshalf.c \
src/cmsintrp.c \
src/cmsio0.c \
src/cmsio1.c \
src/cmslut.c \
src/cmsmtrx.c \
src/cmsnamed.c \
src/cmsopt.c \
src/cmspack.c \
src/cmspcs.c \
src/cmsplugin.c \
src/cmssamp.c \
src/cmstypes.c \
src/cmsvirt.c \
src/cmswtpnt.c \
src/cmsxform.c
This diff is collapsed.
This diff is collapsed.
//---------------------------------------------------------------------------------
//
// Little Color Management System
// Copyright (c) 1998-2020 Marti Maria Saguer
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the Software
// is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//---------------------------------------------------------------------------------
//
#include "lcms2_internal.h"
// Alpha copy ------------------------------------------------------------------------------------------------------------------
// This macro return words stored as big endian
#define CHANGE_ENDIAN(w) (cmsUInt16Number) ((cmsUInt16Number) ((w)<<8)|((w)>>8))
// Floor to byte, taking care of saturation
cmsINLINE cmsUInt8Number _cmsQuickSaturateByte(cmsFloat64Number d)
{
d += 0.5;
if (d <= 0) return 0;
if (d >= 255.0) return 255;
return (cmsUInt8Number) _cmsQuickFloorWord(d);
}
// Return the size in bytes of a given formatter
static
cmsUInt32Number trueBytesSize(cmsUInt32Number Format)
{
cmsUInt32Number fmt_bytes = T_BYTES(Format);
// For double, the T_BYTES field returns zero
if (fmt_bytes == 0)
return sizeof(double);
// Otherwise, it is already correct for all formats
return fmt_bytes;
}
// Several format converters
typedef void(*cmsFormatterAlphaFn)(void* dst, const void* src);
// From 8
static
void copy8(void* dst, const void* src)
{
memmove(dst, src, 1);
}
static
void from8to16(void* dst, const void* src)
{
cmsUInt8Number n = *(cmsUInt8Number*)src;
*(cmsUInt16Number*) dst = (cmsUInt16Number) FROM_8_TO_16(n);
}
static
void from8to16SE(void* dst, const void* src)
{
cmsUInt8Number n = *(cmsUInt8Number*)src;
*(cmsUInt16Number*)dst = CHANGE_ENDIAN(FROM_8_TO_16(n));
}
static
void from8toFLT(void* dst, const void* src)
{
*(cmsFloat32Number*)dst = (cmsFloat32Number) (*(cmsUInt8Number*)src) / 255.0f;
}
static
void from8toDBL(void* dst, const void* src)
{
*(cmsFloat64Number*)dst = (cmsFloat64Number) (*(cmsUInt8Number*)src) / 255.0;
}
static
void from8toHLF(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
cmsFloat32Number n = (*(cmsUInt8Number*)src) / 255.0f;
*(cmsUInt16Number*)dst = _cmsFloat2Half(n);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
// From 16
static
void from16to8(void* dst, const void* src)
{
cmsUInt16Number n = *(cmsUInt16Number*)src;
*(cmsUInt8Number*) dst = FROM_16_TO_8(n);
}
static
void from16SEto8(void* dst, const void* src)
{
cmsUInt16Number n = *(cmsUInt16Number*)src;
*(cmsUInt8Number*)dst = FROM_16_TO_8(CHANGE_ENDIAN(n));
}
static
void copy16(void* dst, const void* src)
{
memmove(dst, src, 2);
}
static
void from16to16(void* dst, const void* src)
{
cmsUInt16Number n = *(cmsUInt16Number*)src;
*(cmsUInt16Number*)dst = CHANGE_ENDIAN(n);
}
static
void from16toFLT(void* dst, const void* src)
{
*(cmsFloat32Number*)dst = (*(cmsUInt16Number*)src) / 65535.0f;
}
static
void from16SEtoFLT(void* dst, const void* src)
{
*(cmsFloat32Number*)dst = (CHANGE_ENDIAN(*(cmsUInt16Number*)src)) / 65535.0f;
}
static
void from16toDBL(void* dst, const void* src)
{
*(cmsFloat64Number*)dst = (cmsFloat64Number) (*(cmsUInt16Number*)src) / 65535.0;
}
static
void from16SEtoDBL(void* dst, const void* src)
{
*(cmsFloat64Number*)dst = (cmsFloat64Number) (CHANGE_ENDIAN(*(cmsUInt16Number*)src)) / 65535.0;
}
static
void from16toHLF(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
cmsFloat32Number n = (*(cmsUInt16Number*)src) / 65535.0f;
*(cmsUInt16Number*)dst = _cmsFloat2Half(n);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
static
void from16SEtoHLF(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
cmsFloat32Number n = (CHANGE_ENDIAN(*(cmsUInt16Number*)src)) / 65535.0f;
*(cmsUInt16Number*)dst = _cmsFloat2Half(n);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
// From Float
static
void fromFLTto8(void* dst, const void* src)
{
cmsFloat32Number n = *(cmsFloat32Number*)src;
*(cmsUInt8Number*)dst = _cmsQuickSaturateByte(n * 255.0f);
}
static
void fromFLTto16(void* dst, const void* src)
{
cmsFloat32Number n = *(cmsFloat32Number*)src;
*(cmsUInt16Number*)dst = _cmsQuickSaturateWord(n * 65535.0f);
}
static
void fromFLTto16SE(void* dst, const void* src)
{
cmsFloat32Number n = *(cmsFloat32Number*)src;
cmsUInt16Number i = _cmsQuickSaturateWord(n * 65535.0f);
*(cmsUInt16Number*)dst = CHANGE_ENDIAN(i);
}
static
void copy32(void* dst, const void* src)
{
memmove(dst, src, sizeof(cmsFloat32Number));
}
static
void fromFLTtoDBL(void* dst, const void* src)
{
cmsFloat32Number n = *(cmsFloat32Number*)src;
*(cmsFloat64Number*)dst = (cmsFloat64Number)n;
}
static
void fromFLTtoHLF(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
cmsFloat32Number n = *(cmsFloat32Number*)src;
*(cmsUInt16Number*)dst = _cmsFloat2Half(n);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
// From HALF
static
void fromHLFto8(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
cmsFloat32Number n = _cmsHalf2Float(*(cmsUInt16Number*)src);
*(cmsUInt8Number*)dst = _cmsQuickSaturateByte(n * 255.0f);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
static
void fromHLFto16(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
cmsFloat32Number n = _cmsHalf2Float(*(cmsUInt16Number*)src);
*(cmsUInt16Number*)dst = _cmsQuickSaturateWord(n * 65535.0f);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
static
void fromHLFto16SE(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
cmsFloat32Number n = _cmsHalf2Float(*(cmsUInt16Number*)src);
cmsUInt16Number i = _cmsQuickSaturateWord(n * 65535.0f);
*(cmsUInt16Number*)dst = CHANGE_ENDIAN(i);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
static
void fromHLFtoFLT(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
*(cmsFloat32Number*)dst = _cmsHalf2Float(*(cmsUInt16Number*)src);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
static
void fromHLFtoDBL(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
*(cmsFloat64Number*)dst = (cmsFloat64Number)_cmsHalf2Float(*(cmsUInt16Number*)src);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
// From double
static
void fromDBLto8(void* dst, const void* src)
{
cmsFloat64Number n = *(cmsFloat64Number*)src;
*(cmsUInt8Number*)dst = _cmsQuickSaturateByte(n * 255.0);
}
static
void fromDBLto16(void* dst, const void* src)
{
cmsFloat64Number n = *(cmsFloat64Number*)src;
*(cmsUInt16Number*)dst = _cmsQuickSaturateWord(n * 65535.0f);
}
static
void fromDBLto16SE(void* dst, const void* src)
{
cmsFloat64Number n = *(cmsFloat64Number*)src;
cmsUInt16Number i = _cmsQuickSaturateWord(n * 65535.0f);
*(cmsUInt16Number*)dst = CHANGE_ENDIAN(i);
}
static
void fromDBLtoFLT(void* dst, const void* src)
{
cmsFloat64Number n = *(cmsFloat64Number*)src;
*(cmsFloat32Number*)dst = (cmsFloat32Number) n;
}
static
void fromDBLtoHLF(void* dst, const void* src)
{
#ifndef CMS_NO_HALF_SUPPORT
cmsFloat32Number n = (cmsFloat32Number) *(cmsFloat64Number*)src;
*(cmsUInt16Number*)dst = _cmsFloat2Half(n);
#else
cmsUNUSED_PARAMETER(dst);
cmsUNUSED_PARAMETER(src);
#endif
}
static
void copy64(void* dst, const void* src)
{
memmove(dst, src, sizeof(cmsFloat64Number));
}
// Returns the position (x or y) of the formatter in the table of functions
static
int FormatterPos(cmsUInt32Number frm)
{
cmsUInt32Number b = T_BYTES(frm);
if (b == 0 && T_FLOAT(frm))
return 5; // DBL
#ifndef CMS_NO_HALF_SUPPORT
if (b == 2 && T_FLOAT(frm))
return 3; // HLF
#endif
if (b == 4 && T_FLOAT(frm))
return 4; // FLT
if (b == 2 && !T_FLOAT(frm))
{
if (T_ENDIAN16(frm))
return 2; // 16SE
else
return 1; // 16
}
if (b == 1 && !T_FLOAT(frm))
return 0; // 8
return -1; // not recognized
}
// Obtains an alpha-to-alpha function formatter
static
cmsFormatterAlphaFn _cmsGetFormatterAlpha(cmsContext id, cmsUInt32Number in, cmsUInt32Number out)
{
static cmsFormatterAlphaFn FormattersAlpha[6][6] = {
/* from 8 */ { copy8, from8to16, from8to16SE, from8toHLF, from8toFLT, from8toDBL },
/* from 16*/ { from16to8, copy16, from16to16, from16toHLF, from16toFLT, from16toDBL },
/* from 16SE*/{ from16SEto8, from16to16, copy16, from16SEtoHLF,from16SEtoFLT, from16SEtoDBL },
/* from HLF*/ { fromHLFto8, fromHLFto16, fromHLFto16SE, copy16, fromHLFtoFLT, fromHLFtoDBL },
/* from FLT*/ { fromFLTto8, fromFLTto16, fromFLTto16SE, fromFLTtoHLF, copy32, fromFLTtoDBL },
/* from DBL*/ { fromDBLto8, fromDBLto16, fromDBLto16SE, fromDBLtoHLF, fromDBLtoFLT, copy64 }};
int in_n = FormatterPos(in);
int out_n = FormatterPos(out);
if (in_n < 0 || out_n < 0 || in_n > 5 || out_n > 5) {
cmsSignalError(id, cmsERROR_UNKNOWN_EXTENSION, "Unrecognized alpha channel width");
return NULL;
}
return FormattersAlpha[in_n][out_n];
}
// This function computes the distance from each component to the next one in bytes.
static
void ComputeIncrementsForChunky(cmsUInt32Number Format,
cmsUInt32Number ComponentStartingOrder[],
cmsUInt32Number ComponentPointerIncrements[])
{
cmsUInt32Number channels[cmsMAXCHANNELS];
cmsUInt32Number extra = T_EXTRA(Format);
cmsUInt32Number nchannels = T_CHANNELS(Format);
cmsUInt32Number total_chans = nchannels + extra;
cmsUInt32Number i;
cmsUInt32Number channelSize = trueBytesSize(Format);
cmsUInt32Number pixelSize = channelSize * total_chans;
// Sanity check
if (total_chans <= 0 || total_chans >= cmsMAXCHANNELS)
return;
memset(channels, 0, sizeof(channels));
// Separation is independent of starting point and only depends on channel size
for (i = 0; i < extra; i++)
ComponentPointerIncrements[i] = pixelSize;
// Handle do swap
for (i = 0; i < total_chans; i++)
{
if (T_DOSWAP(Format)) {
channels[i] = total_chans - i - 1;
}
else {
channels[i] = i;
}
}
// Handle swap first (ROL of positions), example CMYK -> KCMY | 0123 -> 3012
if (T_SWAPFIRST(Format) && total_chans > 1) {
cmsUInt32Number tmp = channels[0];
for (i = 0; i < total_chans-1; i++)
channels[i] = channels[i + 1];
channels[total_chans - 1] = tmp;
}
// Handle size
if (channelSize > 1)
for (i = 0; i < total_chans; i++) {
channels[i] *= channelSize;
}
for (i = 0; i < extra; i++)
ComponentStartingOrder[i] = channels[i + nchannels];
}
// On planar configurations, the distance is the stride added to any non-negative
static
void ComputeIncrementsForPlanar(cmsUInt32Number Format,
cmsUInt32Number BytesPerPlane,
cmsUInt32Number ComponentStartingOrder[],
cmsUInt32Number ComponentPointerIncrements[])
{
cmsUInt32Number channels[cmsMAXCHANNELS];
cmsUInt32Number extra = T_EXTRA(Format);
cmsUInt32Number nchannels = T_CHANNELS(Format);
cmsUInt32Number total_chans = nchannels + extra;
cmsUInt32Number i;
cmsUInt32Number channelSize = trueBytesSize(Format);
// Sanity check
if (total_chans <= 0 || total_chans >= cmsMAXCHANNELS)
return;
memset(channels, 0, sizeof(channels));
// Separation is independent of starting point and only depends on channel size
for (i = 0; i < extra; i++)
ComponentPointerIncrements[i] = channelSize;
// Handle do swap
for (i = 0; i < total_chans; i++)
{
if (T_DOSWAP(Format)) {
channels[i] = total_chans - i - 1;
}
else {
channels[i] = i;
}
}
// Handle swap first (ROL of positions), example CMYK -> KCMY | 0123 -> 3012
if (T_SWAPFIRST(Format) && total_chans > 0) {
cmsUInt32Number tmp = channels[0];
for (i = 0; i < total_chans - 1; i++)
channels[i] = channels[i + 1];
channels[total_chans - 1] = tmp;
}
// Handle size
for (i = 0; i < total_chans; i++) {
channels[i] *= BytesPerPlane;
}
for (i = 0; i < extra; i++)
ComponentStartingOrder[i] = channels[i + nchannels];
}
// Dispatcher por chunky and planar RGB
static
void ComputeComponentIncrements(cmsUInt32Number Format,
cmsUInt32Number BytesPerPlane,
cmsUInt32Number ComponentStartingOrder[],
cmsUInt32Number ComponentPointerIncrements[])
{
if (T_PLANAR(Format)) {
ComputeIncrementsForPlanar(Format, BytesPerPlane, ComponentStartingOrder, ComponentPointerIncrements);
}
else {
ComputeIncrementsForChunky(Format, ComponentStartingOrder, ComponentPointerIncrements);
}
}
// Handles extra channels copying alpha if requested by the flags
void _cmsHandleExtraChannels(_cmsTRANSFORM* p, const void* in,
void* out,
cmsUInt32Number PixelsPerLine,
cmsUInt32Number LineCount,
const cmsStride* Stride)
{
cmsUInt32Number i, j, k;
cmsUInt32Number nExtra;
cmsUInt32Number SourceStartingOrder[cmsMAXCHANNELS];
cmsUInt32Number SourceIncrements[cmsMAXCHANNELS];
cmsUInt32Number DestStartingOrder[cmsMAXCHANNELS];
cmsUInt32Number DestIncrements[cmsMAXCHANNELS];
cmsFormatterAlphaFn copyValueFn;
// Make sure we need some copy
if (!(p->dwOriginalFlags & cmsFLAGS_COPY_ALPHA))
return;
// Exit early if in-place color-management is occurring - no need to copy extra channels to themselves.
if (p->InputFormat == p->OutputFormat && in == out)
return;
// Make sure we have same number of alpha channels. If not, just return as this should be checked at transform creation time.
nExtra = T_EXTRA(p->InputFormat);
if (nExtra != T_EXTRA(p->OutputFormat))
return;
// Anything to do?
if (nExtra == 0)
return;
// Compute the increments
ComputeComponentIncrements(p->InputFormat, Stride->BytesPerPlaneIn, SourceStartingOrder, SourceIncrements);
ComputeComponentIncrements(p->OutputFormat, Stride->BytesPerPlaneOut, DestStartingOrder, DestIncrements);
// Check for conversions 8, 16, half, float, dbl
copyValueFn = _cmsGetFormatterAlpha(p->ContextID, p->InputFormat, p->OutputFormat);
if (copyValueFn == NULL)
return;
if (nExtra == 1) { // Optimized routine for copying a single extra channel quickly
cmsUInt8Number* SourcePtr;
cmsUInt8Number* DestPtr;
cmsUInt32Number SourceStrideIncrement = 0;
cmsUInt32Number DestStrideIncrement = 0;
// The loop itself
for (i = 0; i < LineCount; i++) {
// Prepare pointers for the loop
SourcePtr = (cmsUInt8Number*)in + SourceStartingOrder[0] + SourceStrideIncrement;
DestPtr = (cmsUInt8Number*)out + DestStartingOrder[0] + DestStrideIncrement;
for (j = 0; j < PixelsPerLine; j++) {
copyValueFn(DestPtr, SourcePtr);
SourcePtr += SourceIncrements[0];
DestPtr += DestIncrements[0];
}
SourceStrideIncrement += Stride->BytesPerLineIn;
DestStrideIncrement += Stride->BytesPerLineOut;
}
}
else { // General case with more than one extra channel
cmsUInt8Number* SourcePtr[cmsMAXCHANNELS];
cmsUInt8Number* DestPtr[cmsMAXCHANNELS];
cmsUInt32Number SourceStrideIncrements[cmsMAXCHANNELS];
cmsUInt32Number DestStrideIncrements[cmsMAXCHANNELS];
memset(SourceStrideIncrements, 0, sizeof(SourceStrideIncrements));
memset(DestStrideIncrements, 0, sizeof(DestStrideIncrements));
// The loop itself
for (i = 0; i < LineCount; i++) {
// Prepare pointers for the loop
for (j = 0; j < nExtra; j++) {
SourcePtr[j] = (cmsUInt8Number*)in + SourceStartingOrder[j] + SourceStrideIncrements[j];
DestPtr[j] = (cmsUInt8Number*)out + DestStartingOrder[j] + DestStrideIncrements[j];
}
for (j = 0; j < PixelsPerLine; j++) {
for (k = 0; k < nExtra; k++) {
copyValueFn(DestPtr[k], SourcePtr[k]);
SourcePtr[k] += SourceIncrements[k];
DestPtr[k] += DestIncrements[k];
}
}
for (j = 0; j < nExtra; j++) {
SourceStrideIncrements[j] += Stride->BytesPerLineIn;
DestStrideIncrements[j] += Stride->BytesPerLineOut;
}
}
}
}
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
//---------------------------------------------------------------------------------
//
// Little Color Management System
// Copyright (c) 1998-2020 Marti Maria Saguer
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the Software
// is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//---------------------------------------------------------------------------------
//
#include "lcms2_internal.h"
#define DSWAP(x, y) {cmsFloat64Number tmp = (x); (x)=(y); (y)=tmp;}
// Initiate a vector
void CMSEXPORT _cmsVEC3init(cmsVEC3* r, cmsFloat64Number x, cmsFloat64Number y, cmsFloat64Number z)
{
r -> n[VX] = x;
r -> n[VY] = y;
r -> n[VZ] = z;
}
// Vector subtraction
void CMSEXPORT _cmsVEC3minus(cmsVEC3* r, const cmsVEC3* a, const cmsVEC3* b)
{
r -> n[VX] = a -> n[VX] - b -> n[VX];
r -> n[VY] = a -> n[VY] - b -> n[VY];
r -> n[VZ] = a -> n[VZ] - b -> n[VZ];
}
// Vector cross product
void CMSEXPORT _cmsVEC3cross(cmsVEC3* r, const cmsVEC3* u, const cmsVEC3* v)
{
r ->n[VX] = u->n[VY] * v->n[VZ] - v->n[VY] * u->n[VZ];
r ->n[VY] = u->n[VZ] * v->n[VX] - v->n[VZ] * u->n[VX];
r ->n[VZ] = u->n[VX] * v->n[VY] - v->n[VX] * u->n[VY];
}
// Vector dot product
cmsFloat64Number CMSEXPORT _cmsVEC3dot(const cmsVEC3* u, const cmsVEC3* v)
{
return u->n[VX] * v->n[VX] + u->n[VY] * v->n[VY] + u->n[VZ] * v->n[VZ];
}
// Euclidean length
cmsFloat64Number CMSEXPORT _cmsVEC3length(const cmsVEC3* a)
{
return sqrt(a ->n[VX] * a ->n[VX] +
a ->n[VY] * a ->n[VY] +
a ->n[VZ] * a ->n[VZ]);
}
// Euclidean distance
cmsFloat64Number CMSEXPORT _cmsVEC3distance(const cmsVEC3* a, const cmsVEC3* b)
{
cmsFloat64Number d1 = a ->n[VX] - b ->n[VX];
cmsFloat64Number d2 = a ->n[VY] - b ->n[VY];
cmsFloat64Number d3 = a ->n[VZ] - b ->n[VZ];
return sqrt(d1*d1 + d2*d2 + d3*d3);
}
// 3x3 Identity
void CMSEXPORT _cmsMAT3identity(cmsMAT3* a)
{
_cmsVEC3init(&a-> v[0], 1.0, 0.0, 0.0);
_cmsVEC3init(&a-> v[1], 0.0, 1.0, 0.0);
_cmsVEC3init(&a-> v[2], 0.0, 0.0, 1.0);
}
static
cmsBool CloseEnough(cmsFloat64Number a, cmsFloat64Number b)
{
return fabs(b - a) < (1.0 / 65535.0);
}
cmsBool CMSEXPORT _cmsMAT3isIdentity(const cmsMAT3* a)
{
cmsMAT3 Identity;
int i, j;
_cmsMAT3identity(&Identity);
for (i=0; i < 3; i++)
for (j=0; j < 3; j++)
if (!CloseEnough(a ->v[i].n[j], Identity.v[i].n[j])) return FALSE;
return TRUE;
}
// Multiply two matrices
void CMSEXPORT _cmsMAT3per(cmsMAT3* r, const cmsMAT3* a, const cmsMAT3* b)
{
#define ROWCOL(i, j) \
a->v[i].n[0]*b->v[0].n[j] + a->v[i].n[1]*b->v[1].n[j] + a->v[i].n[2]*b->v[2].n[j]
_cmsVEC3init(&r-> v[0], ROWCOL(0,0), ROWCOL(0,1), ROWCOL(0,2));
_cmsVEC3init(&r-> v[1], ROWCOL(1,0), ROWCOL(1,1), ROWCOL(1,2));
_cmsVEC3init(&r-> v[2], ROWCOL(2,0), ROWCOL(2,1), ROWCOL(2,2));
#undef ROWCOL //(i, j)
}
// Inverse of a matrix b = a^(-1)
cmsBool CMSEXPORT _cmsMAT3inverse(const cmsMAT3* a, cmsMAT3* b)
{
cmsFloat64Number det, c0, c1, c2;
c0 = a -> v[1].n[1]*a -> v[2].n[2] - a -> v[1].n[2]*a -> v[2].n[1];
c1 = -a -> v[1].n[0]*a -> v[2].n[2] + a -> v[1].n[2]*a -> v[2].n[0];
c2 = a -> v[1].n[0]*a -> v[2].n[1] - a -> v[1].n[1]*a -> v[2].n[0];
det = a -> v[0].n[0]*c0 + a -> v[0].n[1]*c1 + a -> v[0].n[2]*c2;
if (fabs(det) < MATRIX_DET_TOLERANCE) return FALSE; // singular matrix; can't invert
b -> v[0].n[0] = c0/det;
b -> v[0].n[1] = (a -> v[0].n[2]*a -> v[2].n[1] - a -> v[0].n[1]*a -> v[2].n[2])/det;
b -> v[0].n[2] = (a -> v[0].n[1]*a -> v[1].n[2] - a -> v[0].n[2]*a -> v[1].n[1])/det;
b -> v[1].n[0] = c1/det;
b -> v[1].n[1] = (a -> v[0].n[0]*a -> v[2].n[2] - a -> v[0].n[2]*a -> v[2].n[0])/det;
b -> v[1].n[2] = (a -> v[0].n[2]*a -> v[1].n[0] - a -> v[0].n[0]*a -> v[1].n[2])/det;
b -> v[2].n[0] = c2/det;
b -> v[2].n[1] = (a -> v[0].n[1]*a -> v[2].n[0] - a -> v[0].n[0]*a -> v[2].n[1])/det;
b -> v[2].n[2] = (a -> v[0].n[0]*a -> v[1].n[1] - a -> v[0].n[1]*a -> v[1].n[0])/det;
return TRUE;
}
// Solve a system in the form Ax = b
cmsBool CMSEXPORT _cmsMAT3solve(cmsVEC3* x, cmsMAT3* a, cmsVEC3* b)
{
cmsMAT3 m, a_1;
memmove(&m, a, sizeof(cmsMAT3));
if (!_cmsMAT3inverse(&m, &a_1)) return FALSE; // Singular matrix
_cmsMAT3eval(x, &a_1, b);
return TRUE;
}
// Evaluate a vector across a matrix
void CMSEXPORT _cmsMAT3eval(cmsVEC3* r, const cmsMAT3* a, const cmsVEC3* v)
{
r->n[VX] = a->v[0].n[VX]*v->n[VX] + a->v[0].n[VY]*v->n[VY] + a->v[0].n[VZ]*v->n[VZ];
r->n[VY] = a->v[1].n[VX]*v->n[VX] + a->v[1].n[VY]*v->n[VY] + a->v[1].n[VZ]*v->n[VZ];
r->n[VZ] = a->v[2].n[VX]*v->n[VX] + a->v[2].n[VY]*v->n[VY] + a->v[2].n[VZ]*v->n[VZ];
}
This diff is collapsed.
This diff is collapsed.
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment