src/_imagingcms.c

Bug Summary

File:	_imagingcms.c
Warning:	line 1531, column 13 PyObject ownership leak with reference count of 1

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name _imagingcms.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-output=html -analyzer-checker=python -analyzer-disable-checker=deadcode -analyzer-config prune-paths=true,suppress-c++-stdlib=true,suppress-null-return-paths=false,crosscheck-with-z3=true,model-path=/opt/pyrefcon/lib/pyrefcon/models/models -analyzer-config experimental-enable-naive-ctu-analysis=true,ctu-dir=/tmp/pyrefcon/Pillow/csa-scan,ctu-index-name=/tmp/pyrefcon/Pillow/csa-scan/externalDefMap.txt,ctu-invocation-list=/tmp/pyrefcon/Pillow/csa-scan/invocations.yaml,display-ctu-progress=false -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debug-info-kind=limited -dwarf-version=4 -debugger-tuning=gdb -fcoverage-compilation-dir=/tmp/pyrefcon/Pillow -resource-dir /opt/pyrefcon/lib/clang/13.0.0 -isystem /opt/pyrefcon/lib/pyrefcon/models/python3.8 -D NDEBUG -D _FORTIFY_SOURCE=2 -I /usr/include/freetype2 -I /usr/include/openjpeg-2.3 -I /tmp/pyrefcon/Pillow -I /usr/include/x86_64-linux-gnu -I /usr/include/fribidi -I /usr/include -internal-isystem /opt/pyrefcon/lib/clang/13.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-result -Wsign-compare -Wall -Wformat -Werror=format-security -Wformat -Werror=format-security -Wdate-time -fdebug-compilation-dir=/tmp/pyrefcon/Pillow -ferror-limit 19 -fwrapv -pthread -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/pyrefcon/Pillow/csa-scan/reports -x c src/_imagingcms.c

src/_imagingcms.c

→

1/*
* pyCMS
* a Python / PIL interface to the littleCMS ICC Color Management System
* Copyright (C) 2002-2003 Kevin Cazabon
* kevin@cazabon.com
* http://www.cazabon.com
* Adapted/reworked for PIL by Fredrik Lundh
* Copyright (c) 2009 Fredrik Lundh
* Updated to LCMS2
* Copyright (c) 2013 Eric Soroos
*
* pyCMS home page:  http://www.cazabon.com/pyCMS
* littleCMS home page:  http://www.littlecms.com
* (littleCMS is Copyright (C) 1998-2001 Marti Maria)
*
* Originally released under LGPL.  Graciously donated to PIL in
* March 2009, for distribution under the standard PIL license
*/

20#define COPYRIGHTINFO"pyCMS\na Python / PIL interface to the littleCMS ICC Color Management System\nCopyright (C) 2002-2003 Kevin Cazabon\nkevin@cazabon.com\nhttp://www.cazabon.com\n" \
  "\
22pyCMS\n\
23a Python / PIL interface to the littleCMS ICC Color Management System\n\
24Copyright (C) 2002-2003 Kevin Cazabon\n\
25kevin@cazabon.com\n\
26http://www.cazabon.com\n\
27"

29#define PY_SSIZE_T_CLEAN
30#include "Python.h"  // Include before wchar.h so _GNU_SOURCE is set
31#include "wchar.h"
32#include "datetime.h"

34#include "lcms2.h"
35#include "libImaging/Imaging.h"

37#define PYCMSVERSION"1.0.0 pil" "1.0.0 pil"

39/* version history */

41/*
1.0.0 pil Integrating littleCMS2
0.1.0 pil integration & refactoring
0.0.2 alpha:  Minor updates, added interfaces to littleCMS features, Jan 6, 2003
- fixed some memory holes in how transforms/profiles were created and passed back to
Python due to improper destructor setup for PyCObjects
- added buildProofTransformFromOpenProfiles() function
- eliminated some code redundancy, centralizing several common tasks with internal
functions

0.0.1 alpha:  First public release Dec 26, 2002

53*/

55/* known to-do list with current version:

 Verify that PILmode->littleCMStype conversion in findLCMStype is correct for all
 PIL modes (it probably isn't for the more obscure ones)

 Add support for creating custom RGB profiles on the fly
 Add support for checking presence of a specific tag in a profile
 Add support for other littleCMS features as required

64*/

66/*
INTENT_PERCEPTUAL                 0
INTENT_RELATIVE_COLORIMETRIC      1
INTENT_SATURATION                 2
INTENT_ABSOLUTE_COLORIMETRIC      3
71*/

73/* -------------------------------------------------------------------- */
74/* wrapper classes */

76/* a profile represents the ICC characteristics for a specific device */

78typedef struct {
  PyObject_HEADPyObject ob_base; cmsHPROFILE profile;
80} CmsProfileObject;

82static PyTypeObject CmsProfile_Type;

84#define CmsProfile_Check(op)((((PyObject*)(op))->ob_type) == &CmsProfile_Type) (Py_TYPE(op)(((PyObject*)(op))->ob_type) == &CmsProfile_Type)

86static PyObject *
87cms_profile_new(cmsHPROFILE profile) {
  CmsProfileObject *self;

  self = PyObject_New(CmsProfileObject, &CmsProfile_Type)( (CmsProfileObject *) _PyObject_New(&CmsProfile_Type) );
  if (!self) {
      return NULL((void*)0);
  }

  self->profile = profile;

  return (PyObject *)self;
98}

100static PyObject *
101cms_profile_open(PyObject *self, PyObject *args) {
  cmsHPROFILE hProfile;

  char *sProfile;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s:profile_open", &sProfile)) {
      return NULL((void*)0);
  }

  hProfile = cmsOpenProfileFromFile(sProfile, "r");
  if (!hProfile) {
      PyErr_SetString(PyExc_OSError, "cannot open profile file");
      return NULL((void*)0);
  }

  return cms_profile_new(hProfile);
116}

118static PyObject *
119cms_profile_fromstring(PyObject *self, PyObject *args) {
  cmsHPROFILE hProfile;

  char *pProfile;
  Py_ssize_t nProfile;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "y#:profile_frombytes", &pProfile, &nProfile)) {
      return NULL((void*)0);
  }

  hProfile = cmsOpenProfileFromMem(pProfile, nProfile);
  if (!hProfile) {
      PyErr_SetString(PyExc_OSError, "cannot open profile from string");
      return NULL((void*)0);
  }

  return cms_profile_new(hProfile);
135}

137static PyObject *
138cms_profile_tobytes(PyObject *self, PyObject *args) {
  char *pProfile = NULL((void*)0);
  cmsUInt32Number nProfile;
  PyObject *CmsProfile;

  cmsHPROFILE *profile;

  PyObject *ret;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "O", &CmsProfile)) {
      return NULL((void*)0);
  }

  profile = ((CmsProfileObject *)CmsProfile)->profile;

  if (!cmsSaveProfileToMem(profile, pProfile, &nProfile)) {
      PyErr_SetString(PyExc_OSError, "Could not determine profile size");
      return NULL((void*)0);
  }

  pProfile = (char *)malloc(nProfile);
  if (!pProfile) {
      PyErr_SetString(PyExc_OSError, "Out of Memory");
      return NULL((void*)0);
  }

  if (!cmsSaveProfileToMem(profile, pProfile, &nProfile)) {
      PyErr_SetString(PyExc_OSError, "Could not get profile");
      free(pProfile);
      return NULL((void*)0);
  }

  ret = PyBytes_FromStringAndSize(pProfile, (Py_ssize_t)nProfile);

  free(pProfile);
  return ret;
173}

175static void
176cms_profile_dealloc(CmsProfileObject *self) {
  (void)cmsCloseProfile(self->profile);
  PyObject_DelPyObject_Free(self);
179}

181/* a transform represents the mapping between two profiles */

183typedef struct {
  PyObject_HEADPyObject ob_base; char mode_in[8];
  char mode_out[8];
  cmsHTRANSFORM transform;
187} CmsTransformObject;

189static PyTypeObject CmsTransform_Type;

191#define CmsTransform_Check(op)((((PyObject*)(op))->ob_type) == &CmsTransform_Type) (Py_TYPE(op)(((PyObject*)(op))->ob_type) == &CmsTransform_Type)

193static PyObject *
194cms_transform_new(cmsHTRANSFORM transform, char *mode_in, char *mode_out) {
  CmsTransformObject *self;

  self = PyObject_New(CmsTransformObject, &CmsTransform_Type)( (CmsTransformObject *) _PyObject_New(&CmsTransform_Type
) );
  if (!self) {
      return NULL((void*)0);
  }

  self->transform = transform;

  strcpy(self->mode_in, mode_in);
  strcpy(self->mode_out, mode_out);

  return (PyObject *)self;
208}

210static void
211cms_transform_dealloc(CmsTransformObject *self) {
  cmsDeleteTransform(self->transform);
  PyObject_DelPyObject_Free(self);
214}

216/* -------------------------------------------------------------------- */
217/* internal functions */

219static cmsUInt32Number
220findLCMStype(char *PILmode) {
  if (strcmp(PILmode, "RGB") == 0) {
      return TYPE_RGBA_8(((4) << 16)|((1) << 7)|((3) << 3)|(1));
  } else if (strcmp(PILmode, "RGBA") == 0) {
      return TYPE_RGBA_8(((4) << 16)|((1) << 7)|((3) << 3)|(1));
  } else if (strcmp(PILmode, "RGBX") == 0) {
      return TYPE_RGBA_8(((4) << 16)|((1) << 7)|((3) << 3)|(1));
  } else if (strcmp(PILmode, "RGBA;16B") == 0) {
      return TYPE_RGBA_16(((4) << 16)|((1) << 7)|((3) << 3)|(2));
  } else if (strcmp(PILmode, "CMYK") == 0) {
      return TYPE_CMYK_8(((6) << 16)|((4) << 3)|(1));
  } else if (strcmp(PILmode, "L") == 0) {
      return TYPE_GRAY_8(((3) << 16)|((1) << 3)|(1));
  } else if (strcmp(PILmode, "L;16") == 0) {
      return TYPE_GRAY_16(((3) << 16)|((1) << 3)|(2));
  } else if (strcmp(PILmode, "L;16B") == 0) {
      return TYPE_GRAY_16_SE(((3) << 16)|((1) << 3)|(2)|((1) << 11));
  } else if (strcmp(PILmode, "YCCA") == 0) {
      return TYPE_YCbCr_8(((7) << 16)|((3) << 3)|(1));
  } else if (strcmp(PILmode, "YCC") == 0) {
      return TYPE_YCbCr_8(((7) << 16)|((3) << 3)|(1));
  } else if (strcmp(PILmode, "LAB") == 0) {
      // LabX equivalent like ALab, but not reversed -- no #define in lcms2
      return (COLORSPACE_SH(PT_LabV2)((30) << 16) | CHANNELS_SH(3)((3) << 3) | BYTES_SH(1)(1) | EXTRA_SH(1)((1) << 7));
  }

  else {
      /* take a wild guess... but you probably should fail instead. */
      return TYPE_GRAY_8(((3) << 16)|((1) << 3)|(1)); /* so there's no buffer overrun... */
  }
250}

252#define Cms_Min(a, b)((a) < (b) ? (a) : (b)) ((a) < (b) ? (a) : (b))

254static int
255pyCMSgetAuxChannelChannel(cmsUInt32Number format, int auxChannelNdx) {
  int numColors = T_CHANNELS(format)(((format)>>3)&15);
  int numExtras = T_EXTRA(format)(((format)>>7)&7);

  if (T_SWAPFIRST(format)(((format)>>14)&1) && T_DOSWAP(format)(((format)>>10)&1)) {
      // reverse order, before anything but last extra is shifted last
      if (auxChannelNdx == numExtras - 1) {
          return numColors + numExtras - 1;
      } else {
          return numExtras - 2 - auxChannelNdx;
      }
  } else if (T_SWAPFIRST(format)(((format)>>14)&1)) {
      // in order, after color channels, but last extra is shifted to first
      if (auxChannelNdx == numExtras - 1) {
          return 0;
      } else {
          return numColors + 1 + auxChannelNdx;
      }
  } else if (T_DOSWAP(format)(((format)>>10)&1)) {
      // reverse order, before anything
      return numExtras - 1 - auxChannelNdx;
  } else {
      // in order, after color channels
      return numColors + auxChannelNdx;
  }
280}

282static void
283pyCMScopyAux(cmsHTRANSFORM hTransform, Imaging imDst, const Imaging imSrc) {
  cmsUInt32Number dstLCMSFormat;
  cmsUInt32Number srcLCMSFormat;
  int numSrcExtras;
  int numDstExtras;
  int numExtras;
  int ySize;
  int xSize;
  int channelSize;
  int srcChunkSize;
  int dstChunkSize;
  int e;

  // trivially copied
  if (imDst == imSrc) {
      return;
  }

  dstLCMSFormat = cmsGetTransformOutputFormat(hTransform);
  srcLCMSFormat = cmsGetTransformInputFormat(hTransform);

  // currently, all Pillow formats are chunky formats, but check it anyway
  if (T_PLANAR(dstLCMSFormat)(((dstLCMSFormat)>>12)&1) || T_PLANAR(srcLCMSFormat)(((srcLCMSFormat)>>12)&1)) {
      return;
  }

  // copy only if channel format is identical, except OPTIMIZED is ignored as it
  // does not affect the aux channel
  if (T_FLOAT(dstLCMSFormat)(((dstLCMSFormat)>>22)&1) != T_FLOAT(srcLCMSFormat)(((srcLCMSFormat)>>22)&1) ||
      T_FLAVOR(dstLCMSFormat)(((dstLCMSFormat)>>13)&1) != T_FLAVOR(srcLCMSFormat)(((srcLCMSFormat)>>13)&1) ||
      T_ENDIAN16(dstLCMSFormat)(((dstLCMSFormat)>>11)&1) != T_ENDIAN16(srcLCMSFormat)(((srcLCMSFormat)>>11)&1) ||
      T_BYTES(dstLCMSFormat)((dstLCMSFormat)&7) != T_BYTES(srcLCMSFormat)((srcLCMSFormat)&7)) {
      return;
  }

  numSrcExtras = T_EXTRA(srcLCMSFormat)(((srcLCMSFormat)>>7)&7);
  numDstExtras = T_EXTRA(dstLCMSFormat)(((dstLCMSFormat)>>7)&7);
  numExtras = Cms_Min(numSrcExtras, numDstExtras)((numSrcExtras) < (numDstExtras) ? (numSrcExtras) : (numDstExtras
));
  ySize = Cms_Min(imSrc->ysize, imDst->ysize)((imSrc->ysize) < (imDst->ysize) ? (imSrc->ysize)
 : (imDst->ysize));
  xSize = Cms_Min(imSrc->xsize, imDst->xsize)((imSrc->xsize) < (imDst->xsize) ? (imSrc->xsize)
 : (imDst->xsize));
  channelSize = T_BYTES(dstLCMSFormat)((dstLCMSFormat)&7);
  srcChunkSize = (T_CHANNELS(srcLCMSFormat)(((srcLCMSFormat)>>3)&15) + T_EXTRA(srcLCMSFormat)(((srcLCMSFormat)>>7)&7)) * channelSize;
  dstChunkSize = (T_CHANNELS(dstLCMSFormat)(((dstLCMSFormat)>>3)&15) + T_EXTRA(dstLCMSFormat)(((dstLCMSFormat)>>7)&7)) * channelSize;

  for (e = 0; e < numExtras; ++e) {
      int y;
      int dstChannel = pyCMSgetAuxChannelChannel(dstLCMSFormat, e);
      int srcChannel = pyCMSgetAuxChannelChannel(srcLCMSFormat, e);

      for (y = 0; y < ySize; y++) {
          int x;
          char *pDstExtras = imDst->image[y] + dstChannel * channelSize;
          const char *pSrcExtras = imSrc->image[y] + srcChannel * channelSize;

          for (x = 0; x < xSize; x++) {
              memcpy(
                  pDstExtras + x * dstChunkSize,
                  pSrcExtras + x * srcChunkSize,
                  channelSize);
          }
      }
  }
345}

347static int
348pyCMSdoTransform(Imaging im, Imaging imOut, cmsHTRANSFORM hTransform) {
  int i;

  if (im->xsize > imOut->xsize || im->ysize > imOut->ysize) {
      return -1;
  }

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();

      // transform color channels only
      for (i = 0; i < im->ysize; i++) {
      cmsDoTransform(hTransform, im->image[i], imOut->image[i], im->xsize);
  }

  // lcms by default does nothing to the auxiliary channels leaving those
  // unchanged. To do "the right thing" here, i.e. maintain identical results
  // with and without inPlace, we replicate those channels to the output.
  //
  // As of lcms 2.8, a new cmsFLAGS_COPY_ALPHA flag is introduced which would
  // do the same thing automagically. Unfortunately, lcms2.8 is not yet widely
  // enough available on all platforms, so we polyfill it here for now.
  pyCMScopyAux(hTransform, imOut, im);

  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

      return 0;
374}

376static cmsHTRANSFORM
377_buildTransform(
  cmsHPROFILE hInputProfile,
  cmsHPROFILE hOutputProfile,
  char *sInMode,
  char *sOutMode,
  int iRenderingIntent,
  cmsUInt32Number cmsFLAGS) {
  cmsHTRANSFORM hTransform;

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();

      /* create the transform */
      hTransform = cmsCreateTransform(
          hInputProfile,
          findLCMStype(sInMode),
          hOutputProfile,
          findLCMStype(sOutMode),
          iRenderingIntent,
          cmsFLAGS);

  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

      if (!hTransform) {
      PyErr_SetString(PyExc_ValueError, "cannot build transform");
  }

  return hTransform; /* if NULL, an exception is set */
404}

406static cmsHTRANSFORM
407_buildProofTransform(
  cmsHPROFILE hInputProfile,
  cmsHPROFILE hOutputProfile,
  cmsHPROFILE hProofProfile,
  char *sInMode,
  char *sOutMode,
  int iRenderingIntent,
  int iProofIntent,
  cmsUInt32Number cmsFLAGS) {
  cmsHTRANSFORM hTransform;

  Py_BEGIN_ALLOW_THREADS{ PyThreadState *_save; _save = PyEval_SaveThread();

      /* create the transform */
      hTransform = cmsCreateProofingTransform(
          hInputProfile,
          findLCMStype(sInMode),
          hOutputProfile,
          findLCMStype(sOutMode),
          hProofProfile,
          iRenderingIntent,
          iProofIntent,
          cmsFLAGS);

  Py_END_ALLOW_THREADSPyEval_RestoreThread(_save); }

      if (!hTransform) {
      PyErr_SetString(PyExc_ValueError, "cannot build proof transform");
  }

  return hTransform; /* if NULL, an exception is set */
438}

440/* -------------------------------------------------------------------- */
441/* Python callable functions */

443static PyObject *
444buildTransform(PyObject *self, PyObject *args) {
  CmsProfileObject *pInputProfile;
  CmsProfileObject *pOutputProfile;
  char *sInMode;
  char *sOutMode;
  int iRenderingIntent = 0;
  int cmsFLAGS = 0;

  cmsHTRANSFORM transform = NULL((void*)0);

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args,
          "O!O!ss|ii:buildTransform",
          &CmsProfile_Type,
          &pInputProfile,
          &CmsProfile_Type,
          &pOutputProfile,
          &sInMode,
          &sOutMode,
          &iRenderingIntent,
          &cmsFLAGS)) {
      return NULL((void*)0);
  }

  transform = _buildTransform(
      pInputProfile->profile,
      pOutputProfile->profile,
      sInMode,
      sOutMode,
      iRenderingIntent,
      cmsFLAGS);

  if (!transform) {
      return NULL((void*)0);
  }

  return cms_transform_new(transform, sInMode, sOutMode);
481}

483static PyObject *
484buildProofTransform(PyObject *self, PyObject *args) {
  CmsProfileObject *pInputProfile;
  CmsProfileObject *pOutputProfile;
  CmsProfileObject *pProofProfile;
  char *sInMode;
  char *sOutMode;
  int iRenderingIntent = 0;
  int iProofIntent = 0;
  int cmsFLAGS = 0;

  cmsHTRANSFORM transform = NULL((void*)0);

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args,
          "O!O!O!ss|iii:buildProofTransform",
          &CmsProfile_Type,
          &pInputProfile,
          &CmsProfile_Type,
          &pOutputProfile,
          &CmsProfile_Type,
          &pProofProfile,
          &sInMode,
          &sOutMode,
          &iRenderingIntent,
          &iProofIntent,
          &cmsFLAGS)) {
      return NULL((void*)0);
  }

  transform = _buildProofTransform(
      pInputProfile->profile,
      pOutputProfile->profile,
      pProofProfile->profile,
      sInMode,
      sOutMode,
      iRenderingIntent,
      iProofIntent,
      cmsFLAGS);

  if (!transform) {
      return NULL((void*)0);
  }

  return cms_transform_new(transform, sInMode, sOutMode);
528}

530static PyObject *
531cms_transform_apply(CmsTransformObject *self, PyObject *args) {
  Py_ssize_t idIn;
  Py_ssize_t idOut;
  Imaging im;
  Imaging imOut;

  int result;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "nn:apply", &idIn, &idOut)) {
      return NULL((void*)0);
  }

  im = (Imaging)idIn;
  imOut = (Imaging)idOut;

  result = pyCMSdoTransform(im, imOut, self->transform);

  return Py_BuildValue_Py_BuildValue_SizeT("i", result);
549}

551/* -------------------------------------------------------------------- */
552/* Python-Callable On-The-Fly profile creation functions */

554static PyObject *
555createProfile(PyObject *self, PyObject *args) {
  char *sColorSpace;
  cmsHPROFILE hProfile;
  cmsFloat64Number dColorTemp = 0.0;
  cmsCIExyY whitePoint;
  cmsBool result;

  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "s|d:createProfile", &sColorSpace, &dColorTemp)) {
      return NULL((void*)0);
  }

  if (strcmp(sColorSpace, "LAB") == 0) {
      if (dColorTemp > 0.0) {
          result = cmsWhitePointFromTemp(&whitePoint, dColorTemp);
          if (!result) {
              PyErr_SetString(
                  PyExc_ValueError,
                  "ERROR: Could not calculate white point from color temperature "
                  "provided, must be float in degrees Kelvin");
              return NULL((void*)0);
          }
          hProfile = cmsCreateLab2Profile(&whitePoint);
      } else {
          hProfile = cmsCreateLab2Profile(NULL((void*)0));
      }
  } else if (strcmp(sColorSpace, "XYZ") == 0) {
      hProfile = cmsCreateXYZProfile();
  } else if (strcmp(sColorSpace, "sRGB") == 0) {
      hProfile = cmsCreate_sRGBProfile();
  } else {
      hProfile = NULL((void*)0);
  }

  if (!hProfile) {
      PyErr_SetString(PyExc_ValueError, "failed to create requested color space");
      return NULL((void*)0);
  }

  return cms_profile_new(hProfile);
594}

596/* -------------------------------------------------------------------- */
597/* profile methods */

599static PyObject *
600cms_profile_is_intent_supported(CmsProfileObject *self, PyObject *args) {
  cmsBool result;

  int intent;
  int direction;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(args, "ii:is_intent_supported", &intent, &direction)) {
      return NULL((void*)0);
  }

  result = cmsIsIntentSupported(self->profile, intent, direction);

  /* printf("cmsIsIntentSupported(%p, %d, %d) => %d\n", self->profile, intent,
   * direction, result); */

  return PyLong_FromLong(result != 0);
615}

617#ifdef _WIN32

619#ifdef _WIN64
620#define F_HANDLE "K"
621#else
622#define F_HANDLE "k"
623#endif

625static PyObject *
626cms_get_display_profile_win32(PyObject *self, PyObject *args) {
  char filename[MAX_PATH];
  cmsUInt32Number filename_size;
  BOOL ok;

  HANDLE handle = 0;
  int is_dc = 0;
  if (!PyArg_ParseTuple_PyArg_ParseTuple_SizeT(
          args, "|" F_HANDLE "i:get_display_profile", &handle, &is_dc)) {
      return NULL((void*)0);
  }

  filename_size = sizeof(filename);

  if (is_dc) {
      ok = GetICMProfile((HDC)handle, &filename_size, filename);
  } else {
      HDC dc = GetDC((HWND)handle);
      ok = GetICMProfile(dc, &filename_size, filename);
      ReleaseDC((HWND)handle, dc);
  }

  if (ok) {
      return PyUnicode_FromStringAndSize(filename, filename_size - 1);
  }

  Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
  return Py_None(&_Py_NoneStruct);
654}
655#endif

657/* -------------------------------------------------------------------- */
658/* Helper functions.  */

660static PyObject *
661_profile_read_mlu(CmsProfileObject *self, cmsTagSignature info) {
  PyObject *uni;
  char *lc = "en";
  char *cc = cmsNoCountry"\0\0";
  cmsMLU *mlu;
  cmsUInt32Number len;
  wchar_t *buf;

  if (!cmsIsTag(self->profile, info)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  mlu = cmsReadTag(self->profile, info);
  if (!mlu) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  len = cmsMLUgetWide(mlu, lc, cc, NULL((void*)0), 0);
  if (len == 0) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  buf = malloc(len);
  if (!buf) {
      PyErr_SetString(PyExc_OSError, "Out of Memory");
      return NULL((void*)0);
  }
  /* Just in case the next call fails.  */
  buf[0] = '\0';

  cmsMLUgetWide(mlu, lc, cc, buf, len);
  // buf contains additional junk after \0
  uni = PyUnicode_FromWideChar(buf, wcslen(buf));
  free(buf);

  return uni;
700}

702static PyObject *
703_profile_read_int_as_string(cmsUInt32Number nr) {
  PyObject *ret;
  char buf[5];
  buf[0] = (char)((nr >> 24) & 0xff);
  buf[1] = (char)((nr >> 16) & 0xff);
  buf[2] = (char)((nr >> 8) & 0xff);
  buf[3] = (char)(nr & 0xff);
  buf[4] = 0;

  ret = PyUnicode_DecodeASCII(buf, 4, NULL((void*)0));
  return ret;
714}

716static PyObject *
717_profile_read_signature(CmsProfileObject *self, cmsTagSignature info) {
  unsigned int *sig;

  if (!cmsIsTag(self->profile, info)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  sig = (unsigned int *)cmsReadTag(self->profile, info);
  if (!sig) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  return _profile_read_int_as_string(*sig);
732}

734static PyObject *
735_xyz_py(cmsCIEXYZ *XYZ) {
  cmsCIExyY xyY;
  cmsXYZ2xyY(&xyY, XYZ);
  return Py_BuildValue_Py_BuildValue_SizeT(
      "((d,d,d),(d,d,d))", XYZ->X, XYZ->Y, XYZ->Z, xyY.x, xyY.y, xyY.Y);
740}

742static PyObject *
743_xyz3_py(cmsCIEXYZ *XYZ) {
  cmsCIExyY xyY[3];
  cmsXYZ2xyY(&xyY[0], &XYZ[0]);
  cmsXYZ2xyY(&xyY[1], &XYZ[1]);
  cmsXYZ2xyY(&xyY[2], &XYZ[2]);

  return Py_BuildValue_Py_BuildValue_SizeT(
      "(((d,d,d),(d,d,d),(d,d,d)),((d,d,d),(d,d,d),(d,d,d)))",
      XYZ[0].X,
      XYZ[0].Y,
      XYZ[0].Z,
      XYZ[1].X,
      XYZ[1].Y,
      XYZ[1].Z,
      XYZ[2].X,
      XYZ[2].Y,
      XYZ[2].Z,
      xyY[0].x,
      xyY[0].y,
      xyY[0].Y,
      xyY[1].x,
      xyY[1].y,
      xyY[1].Y,
      xyY[2].x,
      xyY[2].y,
      xyY[2].Y);
769}

771static PyObject *
772_profile_read_ciexyz(CmsProfileObject *self, cmsTagSignature info, int multi) {
  cmsCIEXYZ *XYZ;

  if (!cmsIsTag(self->profile, info)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  XYZ = (cmsCIEXYZ *)cmsReadTag(self->profile, info);
  if (!XYZ) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }
  if (multi) {
      return _xyz3_py(XYZ);
  } else {
      return _xyz_py(XYZ);
  }
790}

792static PyObject *
793_profile_read_ciexyy_triple(CmsProfileObject *self, cmsTagSignature info) {
  cmsCIExyYTRIPLE *triple;

  if (!cmsIsTag(self->profile, info)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  triple = (cmsCIExyYTRIPLE *)cmsReadTag(self->profile, info);
  if (!triple) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  /* Note: lcms does all the heavy lifting and error checking (nr of
     channels == 3).  */
  return Py_BuildValue_Py_BuildValue_SizeT(
      "((d,d,d),(d,d,d),(d,d,d)),",
      triple->Red.x,
      triple->Red.y,
      triple->Red.Y,
      triple->Green.x,
      triple->Green.y,
      triple->Green.Y,
      triple->Blue.x,
      triple->Blue.y,
      triple->Blue.Y);
820}

822static PyObject *
823_profile_read_named_color_list(CmsProfileObject *self, cmsTagSignature info) {
  cmsNAMEDCOLORLIST *ncl;
  int i, n;
  char name[cmsMAX_PATH256];
  PyObject *result;

  if (!cmsIsTag(self->profile, info)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  ncl = (cmsNAMEDCOLORLIST *)cmsReadTag(self->profile, info);
  if (ncl == NULL((void*)0)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  n = cmsNamedColorCount(ncl);
  result = PyList_New(n);
  if (!result) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  for (i = 0; i < n; i++) {
      PyObject *str;
      cmsNamedColorInfo(ncl, i, name, NULL((void*)0), NULL((void*)0), NULL((void*)0), NULL((void*)0));
      str = PyUnicode_FromString(name);
      if (str == NULL((void*)0)) {
          Py_DECREF(result)_Py_DECREF(((PyObject*)(result)));
          Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
          return Py_None(&_Py_NoneStruct);
      }
      PyList_SET_ITEM(result, i, str)PyList_SetItem(result, i, str);
  }

  return result;
860}

862static cmsBool
863_calculate_rgb_primaries(CmsProfileObject *self, cmsCIEXYZTRIPLE *result) {
  double input[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
  cmsHPROFILE hXYZ;
  cmsHTRANSFORM hTransform;

  /* https://littlecms2.blogspot.com/2009/07/less-is-more.html */

  // double array of RGB values with max on each identity
  hXYZ = cmsCreateXYZProfile();
  if (hXYZ == NULL((void*)0)) {
      return 0;
  }

  // transform from our profile to XYZ using doubles for highest precision
  hTransform = cmsCreateTransform(
      self->profile,
      TYPE_RGB_DBL(((1) << 22)|((4) << 16)|((3) << 3)|(0)),
      hXYZ,
      TYPE_XYZ_DBL(((1) << 22)|((9) << 16)|((3) << 3)|(0)),
      INTENT_RELATIVE_COLORIMETRIC1,
      cmsFLAGS_NOCACHE0x0040 | cmsFLAGS_NOOPTIMIZE0x0100);
  cmsCloseProfile(hXYZ);
  if (hTransform == NULL((void*)0)) {
      return 0;
  }

  cmsDoTransform(hTransform, (void *)input, result, 3);
  cmsDeleteTransform(hTransform);
  return 1;
892}

894static cmsBool
895_check_intent(
  int clut,
  cmsHPROFILE hProfile,
  cmsUInt32Number Intent,
  cmsUInt32Number UsedDirection) {
  if (clut) {
      return cmsIsCLUT(hProfile, Intent, UsedDirection);
  } else {
      return cmsIsIntentSupported(hProfile, Intent, UsedDirection);
  }
905}

907#define INTENTS200 200

909static PyObject *
910_is_intent_supported(CmsProfileObject *self, int clut) {
  PyObject *result;
  int n;
  int i;
  cmsUInt32Number intent_ids[INTENTS200];
  char *intent_descs[INTENTS200];

  result = PyDict_New();
  if (result == NULL((void*)0)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  n = cmsGetSupportedIntents(INTENTS200, intent_ids, intent_descs);
  for (i = 0; i < n; i++) {
      int intent = (int)intent_ids[i];
      PyObject *id;
      PyObject *entry;

      /* Only valid for ICC Intents (otherwise we read invalid memory in lcms
       * cmsio1.c). */
      if (!(intent == INTENT_PERCEPTUAL0 || intent == INTENT_RELATIVE_COLORIMETRIC1 ||
            intent == INTENT_SATURATION2 || intent == INTENT_ABSOLUTE_COLORIMETRIC3)) {
          continue;
      }

      id = PyLong_FromLong((long)intent);
      entry = Py_BuildValue_Py_BuildValue_SizeT(
          "(OOO)",
          _check_intent(clut, self->profile, intent, LCMS_USED_AS_INPUT0) ? Py_True((PyObject *) &_Py_TrueStruct)
                                                                         : Py_False((PyObject *) &_Py_FalseStruct),
          _check_intent(clut, self->profile, intent, LCMS_USED_AS_OUTPUT1) ? Py_True((PyObject *) &_Py_TrueStruct)
                                                                          : Py_False((PyObject *) &_Py_FalseStruct),
          _check_intent(clut, self->profile, intent, LCMS_USED_AS_PROOF2) ? Py_True((PyObject *) &_Py_TrueStruct)
                                                                         : Py_False((PyObject *) &_Py_FalseStruct));
      if (id == NULL((void*)0) || entry == NULL((void*)0)) {
          Py_XDECREF(id)_Py_XDECREF(((PyObject*)(id)));
          Py_XDECREF(entry)_Py_XDECREF(((PyObject*)(entry)));
          Py_XDECREF(result)_Py_XDECREF(((PyObject*)(result)));
          Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
          return Py_None(&_Py_NoneStruct);
      }
      PyDict_SetItem(result, id, entry);
  }
  return result;
955}

957/* -------------------------------------------------------------------- */
958/* Python interface setup */

960static PyMethodDef pyCMSdll_methods[] = {

  {"profile_open", cms_profile_open, METH_VARARGS0x0001},
  {"profile_frombytes", cms_profile_fromstring, METH_VARARGS0x0001},
  {"profile_fromstring", cms_profile_fromstring, METH_VARARGS0x0001},
  {"profile_tobytes", cms_profile_tobytes, METH_VARARGS0x0001},

  /* profile and transform functions */
  {"buildTransform", buildTransform, METH_VARARGS0x0001},
  {"buildProofTransform", buildProofTransform, METH_VARARGS0x0001},
  {"createProfile", createProfile, METH_VARARGS0x0001},

972/* platform specific tools */
973#ifdef _WIN32
  {"get_display_profile_win32", cms_get_display_profile_win32, METH_VARARGS0x0001},
975#endif

  {NULL((void*)0), NULL((void*)0)}};

979static struct PyMethodDef cms_profile_methods[] = {
  {"is_intent_supported", (PyCFunction)cms_profile_is_intent_supported, METH_VARARGS0x0001},
  {NULL((void*)0), NULL((void*)0)} /* sentinel */
982};

984static PyObject *
985cms_profile_getattr_rendering_intent(CmsProfileObject *self, void *closure) {
  return PyLong_FromLong(cmsGetHeaderRenderingIntent(self->profile));
987}

989/* New-style unicode interfaces.  */
990static PyObject *
991cms_profile_getattr_copyright(CmsProfileObject *self, void *closure) {
  return _profile_read_mlu(self, cmsSigCopyrightTag);
993}

995static PyObject *
996cms_profile_getattr_target(CmsProfileObject *self, void *closure) {
  return _profile_read_mlu(self, cmsSigCharTargetTag);
998}

1000static PyObject *
1001cms_profile_getattr_manufacturer(CmsProfileObject *self, void *closure) {
  return _profile_read_mlu(self, cmsSigDeviceMfgDescTag);
1003}

1005static PyObject *
1006cms_profile_getattr_model(CmsProfileObject *self, void *closure) {
  return _profile_read_mlu(self, cmsSigDeviceModelDescTag);
1008}

1010static PyObject *
1011cms_profile_getattr_profile_description(CmsProfileObject *self, void *closure) {
  return _profile_read_mlu(self, cmsSigProfileDescriptionTag);
1013}

1015static PyObject *
1016cms_profile_getattr_screening_description(CmsProfileObject *self, void *closure) {
  return _profile_read_mlu(self, cmsSigScreeningDescTag);
1018}

1020static PyObject *
1021cms_profile_getattr_viewing_condition(CmsProfileObject *self, void *closure) {
  return _profile_read_mlu(self, cmsSigViewingCondDescTag);
1023}

1025static PyObject *
1026cms_profile_getattr_creation_date(CmsProfileObject *self, void *closure) {
  cmsBool result;
  struct tm ct;

  result = cmsGetHeaderCreationDateTime(self->profile, &ct);
  if (!result) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  return PyDateTime_FromDateAndTime(PyDateTimeAPI->DateTime_FromDateAndTime(1900 + ct.tm_year,
 ct.tm_mon, ct.tm_mday, ct.tm_hour, ct.tm_min, ct.tm_sec, 0, (
&_Py_NoneStruct), PyDateTimeAPI->DateTimeType)
      1900 + ct.tm_year, ct.tm_mon, ct.tm_mday, ct.tm_hour, ct.tm_min, ct.tm_sec, 0)PyDateTimeAPI->DateTime_FromDateAndTime(1900 + ct.tm_year,
 ct.tm_mon, ct.tm_mday, ct.tm_hour, ct.tm_min, ct.tm_sec, 0, (
&_Py_NoneStruct), PyDateTimeAPI->DateTimeType);
1038}

1040static PyObject *
1041cms_profile_getattr_version(CmsProfileObject *self, void *closure) {
  cmsFloat64Number version = cmsGetProfileVersion(self->profile);
  return PyFloat_FromDouble(version);
1044}

1046static PyObject *
1047cms_profile_getattr_icc_version(CmsProfileObject *self, void *closure) {
  return PyLong_FromLong((long)cmsGetEncodedICCversion(self->profile));
1049}

1051static PyObject *
1052cms_profile_getattr_attributes(CmsProfileObject *self, void *closure) {
  cmsUInt64Number attr;
  cmsGetHeaderAttributes(self->profile, &attr);
  /* This works just as well on Windows (LLP64), 32-bit Linux
     (ILP32) and 64-bit Linux (LP64) systems.  */
  return PyLong_FromUnsignedLongLong((unsigned long long)attr);
1058}

1060static PyObject *
1061cms_profile_getattr_header_flags(CmsProfileObject *self, void *closure) {
  cmsUInt32Number flags = cmsGetHeaderFlags(self->profile);
  return PyLong_FromLong(flags);
1064}

1066static PyObject *
1067cms_profile_getattr_header_manufacturer(CmsProfileObject *self, void *closure) {
  return _profile_read_int_as_string(cmsGetHeaderManufacturer(self->profile));
1069}

1071static PyObject *
1072cms_profile_getattr_header_model(CmsProfileObject *self, void *closure) {
  return _profile_read_int_as_string(cmsGetHeaderModel(self->profile));
1074}

1076static PyObject *
1077cms_profile_getattr_device_class(CmsProfileObject *self, void *closure) {
  return _profile_read_int_as_string(cmsGetDeviceClass(self->profile));
1079}

1081static PyObject *
1082cms_profile_getattr_connection_space(CmsProfileObject *self, void *closure) {
  return _profile_read_int_as_string(cmsGetPCS(self->profile));
1084}

1086static PyObject *
1087cms_profile_getattr_xcolor_space(CmsProfileObject *self, void *closure) {
  return _profile_read_int_as_string(cmsGetColorSpace(self->profile));
1089}

1091static PyObject *
1092cms_profile_getattr_profile_id(CmsProfileObject *self, void *closure) {
  cmsUInt8Number id[16];
  cmsGetHeaderProfileID(self->profile, id);
  return PyBytes_FromStringAndSize((char *)id, 16);
1096}

1098static PyObject *
1099cms_profile_getattr_is_matrix_shaper(CmsProfileObject *self, void *closure) {
  return PyBool_FromLong((long)cmsIsMatrixShaper(self->profile));
1101}

1103static PyObject *
1104cms_profile_getattr_technology(CmsProfileObject *self, void *closure) {
  return _profile_read_signature(self, cmsSigTechnologyTag);
1106}

1108static PyObject *
1109cms_profile_getattr_colorimetric_intent(CmsProfileObject *self, void *closure) {
  return _profile_read_signature(self, cmsSigColorimetricIntentImageStateTag);
1111}

1113static PyObject *
1114cms_profile_getattr_perceptual_rendering_intent_gamut(
  CmsProfileObject *self, void *closure) {
  return _profile_read_signature(self, cmsSigPerceptualRenderingIntentGamutTag);
1117}

1119static PyObject *
1120cms_profile_getattr_saturation_rendering_intent_gamut(
  CmsProfileObject *self, void *closure) {
  return _profile_read_signature(self, cmsSigSaturationRenderingIntentGamutTag);
1123}

1125static PyObject *
1126cms_profile_getattr_red_colorant(CmsProfileObject *self, void *closure) {
  if (!cmsIsMatrixShaper(self->profile)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }
  return _profile_read_ciexyz(self, cmsSigRedColorantTag, 0);
1132}

1134static PyObject *
1135cms_profile_getattr_green_colorant(CmsProfileObject *self, void *closure) {
  if (!cmsIsMatrixShaper(self->profile)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }
  return _profile_read_ciexyz(self, cmsSigGreenColorantTag, 0);
1141}

1143static PyObject *
1144cms_profile_getattr_blue_colorant(CmsProfileObject *self, void *closure) {
  if (!cmsIsMatrixShaper(self->profile)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }
  return _profile_read_ciexyz(self, cmsSigBlueColorantTag, 0);
1150}

1152static PyObject *
1153cms_profile_getattr_media_white_point_temperature(
  CmsProfileObject *self, void *closure) {
  cmsCIEXYZ *XYZ;
  cmsCIExyY xyY;
  cmsFloat64Number tempK;
  cmsTagSignature info = cmsSigMediaWhitePointTag;
  cmsBool result;

  if (!cmsIsTag(self->profile, info)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  XYZ = (cmsCIEXYZ *)cmsReadTag(self->profile, info);
  if (XYZ == NULL((void*)0) || XYZ->X == 0) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  cmsXYZ2xyY(&xyY, XYZ);
  result = cmsTempFromWhitePoint(&tempK, &xyY);
  if (!result) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }
  return PyFloat_FromDouble(tempK);
1179}

1181static PyObject *
1182cms_profile_getattr_media_white_point(CmsProfileObject *self, void *closure) {
  return _profile_read_ciexyz(self, cmsSigMediaWhitePointTag, 0);
1184}

1186static PyObject *
1187cms_profile_getattr_media_black_point(CmsProfileObject *self, void *closure) {
  return _profile_read_ciexyz(self, cmsSigMediaBlackPointTag, 0);
1189}

1191static PyObject *
1192cms_profile_getattr_luminance(CmsProfileObject *self, void *closure) {
  return _profile_read_ciexyz(self, cmsSigLuminanceTag, 0);
1194}

1196static PyObject *
1197cms_profile_getattr_chromatic_adaptation(CmsProfileObject *self, void *closure) {
  return _profile_read_ciexyz(self, cmsSigChromaticAdaptationTag, 1);
1199}

1201static PyObject *
1202cms_profile_getattr_chromaticity(CmsProfileObject *self, void *closure) {
  return _profile_read_ciexyy_triple(self, cmsSigChromaticityTag);
1204}

1206static PyObject *
1207cms_profile_getattr_red_primary(CmsProfileObject *self, void *closure) {
  cmsBool result = 0;
  cmsCIEXYZTRIPLE primaries;

  if (cmsIsMatrixShaper(self->profile)) {
      result = _calculate_rgb_primaries(self, &primaries);
  }
  if (!result) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  return _xyz_py(&primaries.Red);
1220}

1222static PyObject *
1223cms_profile_getattr_green_primary(CmsProfileObject *self, void *closure) {
  cmsBool result = 0;
  cmsCIEXYZTRIPLE primaries;

  if (cmsIsMatrixShaper(self->profile)) {
      result = _calculate_rgb_primaries(self, &primaries);
  }
  if (!result) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  return _xyz_py(&primaries.Green);
1236}

1238static PyObject *
1239cms_profile_getattr_blue_primary(CmsProfileObject *self, void *closure) {
  cmsBool result = 0;
  cmsCIEXYZTRIPLE primaries;

  if (cmsIsMatrixShaper(self->profile)) {
      result = _calculate_rgb_primaries(self, &primaries);
  }
  if (!result) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  return _xyz_py(&primaries.Blue);
1252}

1254static PyObject *
1255cms_profile_getattr_colorant_table(CmsProfileObject *self, void *closure) {
  return _profile_read_named_color_list(self, cmsSigColorantTableTag);
1257}

1259static PyObject *
1260cms_profile_getattr_colorant_table_out(CmsProfileObject *self, void *closure) {
  return _profile_read_named_color_list(self, cmsSigColorantTableOutTag);
1262}

1264static PyObject *
1265cms_profile_getattr_is_intent_supported(CmsProfileObject *self, void *closure) {
  return _is_intent_supported(self, 0);
1267}

1269static PyObject *
1270cms_profile_getattr_is_clut(CmsProfileObject *self, void *closure) {
  return _is_intent_supported(self, 1);
1272}

1274static const char *
1275_illu_map(int i) {
  switch (i) {
      case 0:
          return "unknown";
      case 1:
          return "D50";
      case 2:
          return "D65";
      case 3:
          return "D93";
      case 4:
          return "F2";
      case 5:
          return "D55";
      case 6:
          return "A";
      case 7:
          return "E";
      case 8:
          return "F8";
      default:
          return NULL((void*)0);
  }
1298}

1300static PyObject *
1301cms_profile_getattr_icc_measurement_condition(CmsProfileObject *self, void *closure) {
  cmsICCMeasurementConditions *mc;
  cmsTagSignature info = cmsSigMeasurementTag;
  const char *geo;

  if (!cmsIsTag(self->profile, info)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  mc = (cmsICCMeasurementConditions *)cmsReadTag(self->profile, info);
  if (!mc) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  if (mc->Geometry == 1) {
      geo = "45/0, 0/45";
  } else if (mc->Geometry == 2) {
      geo = "0d, d/0";
  } else {
      geo = "unknown";
  }

  return Py_BuildValue_Py_BuildValue_SizeT(
      "{s:i,s:(ddd),s:s,s:d,s:s}",
      "observer",
      mc->Observer,
      "backing",
      mc->Backing.X,
      mc->Backing.Y,
      mc->Backing.Z,
      "geo",
      geo,
      "flare",
      mc->Flare,
      "illuminant_type",
      _illu_map(mc->IlluminantType));
1339}

1341static PyObject *
1342cms_profile_getattr_icc_viewing_condition(CmsProfileObject *self, void *closure) {
  cmsICCViewingConditions *vc;
  cmsTagSignature info = cmsSigViewingConditionsTag;

  if (!cmsIsTag(self->profile, info)) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  vc = (cmsICCViewingConditions *)cmsReadTag(self->profile, info);
  if (!vc) {
      Py_INCREF(Py_None)_Py_INCREF(((PyObject*)((&_Py_NoneStruct))));
      return Py_None(&_Py_NoneStruct);
  }

  return Py_BuildValue_Py_BuildValue_SizeT(
      "{s:(ddd),s:(ddd),s:s}",
      "illuminant",
      vc->IlluminantXYZ.X,
      vc->IlluminantXYZ.Y,
      vc->IlluminantXYZ.Z,
      "surround",
      vc->SurroundXYZ.X,
      vc->SurroundXYZ.Y,
      vc->SurroundXYZ.Z,
      "illuminant_type",
      _illu_map(vc->IlluminantType));
1369}

1371static struct PyGetSetDef cms_profile_getsetters[] = {
  /* New style interfaces.  */
  {"rendering_intent", (getter)cms_profile_getattr_rendering_intent},
  {"creation_date", (getter)cms_profile_getattr_creation_date},
  {"copyright", (getter)cms_profile_getattr_copyright},
  {"target", (getter)cms_profile_getattr_target},
  {"manufacturer", (getter)cms_profile_getattr_manufacturer},
  {"model", (getter)cms_profile_getattr_model},
  {"profile_description", (getter)cms_profile_getattr_profile_description},
  {"screening_description", (getter)cms_profile_getattr_screening_description},
  {"viewing_condition", (getter)cms_profile_getattr_viewing_condition},
  {"version", (getter)cms_profile_getattr_version},
  {"icc_version", (getter)cms_profile_getattr_icc_version},
  {"attributes", (getter)cms_profile_getattr_attributes},
  {"header_flags", (getter)cms_profile_getattr_header_flags},
  {"header_manufacturer", (getter)cms_profile_getattr_header_manufacturer},
  {"header_model", (getter)cms_profile_getattr_header_model},
  {"device_class", (getter)cms_profile_getattr_device_class},
  {"connection_space", (getter)cms_profile_getattr_connection_space},
  {"xcolor_space", (getter)cms_profile_getattr_xcolor_space},
  {"profile_id", (getter)cms_profile_getattr_profile_id},
  {"is_matrix_shaper", (getter)cms_profile_getattr_is_matrix_shaper},
  {"technology", (getter)cms_profile_getattr_technology},
  {"colorimetric_intent", (getter)cms_profile_getattr_colorimetric_intent},
  {"perceptual_rendering_intent_gamut",
   (getter)cms_profile_getattr_perceptual_rendering_intent_gamut},
  {"saturation_rendering_intent_gamut",
   (getter)cms_profile_getattr_saturation_rendering_intent_gamut},
  {"red_colorant", (getter)cms_profile_getattr_red_colorant},
  {"green_colorant", (getter)cms_profile_getattr_green_colorant},
  {"blue_colorant", (getter)cms_profile_getattr_blue_colorant},
  {"red_primary", (getter)cms_profile_getattr_red_primary},
  {"green_primary", (getter)cms_profile_getattr_green_primary},
  {"blue_primary", (getter)cms_profile_getattr_blue_primary},
  {"media_white_point_temperature",
   (getter)cms_profile_getattr_media_white_point_temperature},
  {"media_white_point", (getter)cms_profile_getattr_media_white_point},
  {"media_black_point", (getter)cms_profile_getattr_media_black_point},
  {"luminance", (getter)cms_profile_getattr_luminance},
  {"chromatic_adaptation", (getter)cms_profile_getattr_chromatic_adaptation},
  {"chromaticity", (getter)cms_profile_getattr_chromaticity},
  {"colorant_table", (getter)cms_profile_getattr_colorant_table},
  {"colorant_table_out", (getter)cms_profile_getattr_colorant_table_out},
  {"intent_supported", (getter)cms_profile_getattr_is_intent_supported},
  {"clut", (getter)cms_profile_getattr_is_clut},
  {"icc_measurement_condition",
   (getter)cms_profile_getattr_icc_measurement_condition},
  {"icc_viewing_condition", (getter)cms_profile_getattr_icc_viewing_condition},

  {NULL((void*)0)}};

1422static PyTypeObject CmsProfile_Type = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 }, "PIL._imagingcms.CmsProfile", /*tp_name */
  sizeof(CmsProfileObject),
  0, /*tp_basicsize, tp_itemsize */
  /* methods */
  (destructor)cms_profile_dealloc, /*tp_dealloc*/
  0,                               /*tp_print*/
  0,                               /*tp_getattr*/
  0,                               /*tp_setattr*/
  0,                               /*tp_compare*/
  0,                               /*tp_repr*/
  0,                               /*tp_as_number */
  0,                               /*tp_as_sequence */
  0,                               /*tp_as_mapping */
  0,                               /*tp_hash*/
  0,                               /*tp_call*/
  0,                               /*tp_str*/
  0,                               /*tp_getattro*/
  0,                               /*tp_setattro*/
  0,                               /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),              /*tp_flags*/
  0,                               /*tp_doc*/
  0,                               /*tp_traverse*/
  0,                               /*tp_clear*/
  0,                               /*tp_richcompare*/
  0,                               /*tp_weaklistoffset*/
  0,                               /*tp_iter*/
  0,                               /*tp_iternext*/
  cms_profile_methods,             /*tp_methods*/
  0,                               /*tp_members*/
  cms_profile_getsetters,          /*tp_getset*/
1453};

1455static struct PyMethodDef cms_transform_methods[] = {
  {"apply", (PyCFunction)cms_transform_apply, 1}, {NULL((void*)0), NULL((void*)0)} /* sentinel */
1457};

1459static PyObject *
1460cms_transform_getattr_inputMode(CmsTransformObject *self, void *closure) {
  return PyUnicode_FromString(self->mode_in);
1462}

1464static PyObject *
1465cms_transform_getattr_outputMode(CmsTransformObject *self, void *closure) {
  return PyUnicode_FromString(self->mode_out);
1467}

1469static struct PyGetSetDef cms_transform_getsetters[] = {
  {"inputMode", (getter)cms_transform_getattr_inputMode},
  {"outputMode", (getter)cms_transform_getattr_outputMode},
  {NULL((void*)0)}};

1474static PyTypeObject CmsTransform_Type = {
  PyVarObject_HEAD_INIT(NULL, 0){ { 1, ((void*)0) }, 0 }, "CmsTransform",
  sizeof(CmsTransformObject),
  0,
  /* methods */
  (destructor)cms_transform_dealloc, /*tp_dealloc*/
  0,                                 /*tp_print*/
  0,                                 /*tp_getattr*/
  0,                                 /*tp_setattr*/
  0,                                 /*tp_compare*/
  0,                                 /*tp_repr*/
  0,                                 /*tp_as_number */
  0,                                 /*tp_as_sequence */
  0,                                 /*tp_as_mapping */
  0,                                 /*tp_hash*/
  0,                                 /*tp_call*/
  0,                                 /*tp_str*/
  0,                                 /*tp_getattro*/
  0,                                 /*tp_setattro*/
  0,                                 /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT( 0 | (1UL << 18) | 0),                /*tp_flags*/
  0,                                 /*tp_doc*/
  0,                                 /*tp_traverse*/
  0,                                 /*tp_clear*/
  0,                                 /*tp_richcompare*/
  0,                                 /*tp_weaklistoffset*/
  0,                                 /*tp_iter*/
  0,                                 /*tp_iternext*/
  cms_transform_methods,             /*tp_methods*/
  0,                                 /*tp_members*/
  cms_transform_getsetters,          /*tp_getset*/
1505};

1507static int
1508setup_module(PyObject *m) {
  PyObject *d;
  PyObject *v;
  int vn;

  CmsProfile_Type.tp_new = PyType_GenericNew;

  /* Ready object types */
  PyType_Ready(&CmsProfile_Type);
  PyType_Ready(&CmsTransform_Type);

  Py_INCREF(&CmsProfile_Type)_Py_INCREF(((PyObject*)(&CmsProfile_Type)));
  PyModule_AddObject(m, "CmsProfile", (PyObject *)&CmsProfile_Type);

  d = PyModule_GetDict(m);

  /* this check is also in PIL.features.pilinfo() */
1525#if LCMS_VERSION2090 < 2070
  vn = LCMS_VERSION2090;
1527#else
  vn = cmsGetEncodedCMMversion();
1529#endif
  if (vn % 10) {
2
←
Assuming the condition is true→
3
←
Taking true branch→
      v = PyUnicode_FromFormat("%d.%d.%d", vn / 1000, (vn / 10) % 100, vn % 10);
4
←
Calling 'PyUnicode_FromFormat'→
6
←
Returning from 'PyUnicode_FromFormat'→
7
←
PyObject ownership leak with reference count of 1
  } else {
      v = PyUnicode_FromFormat("%d.%d", vn / 1000, (vn / 10) % 100);
  }
  PyDict_SetItemString(d, "littlecms_version", v);

  return 0;
1538}

1540PyMODINIT_FUNCPyObject*
1541PyInit__imagingcms(void) {
  PyObject *m;

  static PyModuleDef module_def = {
      PyModuleDef_HEAD_INIT{ { 1, ((void*)0) }, ((void*)0), 0, ((void*)0), },
      "_imagingcms",    /* m_name */
      NULL((void*)0),             /* m_doc */
      -1,               /* m_size */
      pyCMSdll_methods, /* m_methods */
  };

  m = PyModule_Create(&module_def)PyModule_Create2(&module_def, 1013);

  if (setup_module(m) < 0) {
1
Calling 'setup_module'→
      return NULL((void*)0);
  }

  PyDateTime_IMPORTPyDateTimeAPI = (PyDateTime_CAPI *)PyCapsule_Import("datetime.datetime_CAPI"
, 0);

  return m;
1561}

←

/opt/pyrefcon/lib/pyrefcon/models/models/PyUnicode_FromFormat.model

1#ifndef PyUnicode_FromFormat
2struct _object;
3typedef struct _object PyObject;
4PyObject* clang_analyzer_PyObject_New_Reference();
5PyObject* PyUnicode_FromFormat(const char *format, ...) {
6  return clang_analyzer_PyObject_New_Reference();
5
←
Setting reference count to 1→
7}
8#else
9#warning "API PyUnicode_FromFormat is defined as a macro."
10#endif