TDE
/
extra-dependencies
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/extra-dependencies.git
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3b0c3b8206'
${ noResults }
extra-dependencies/debian/lcms/lcms-1.19.dfsg2/python/lcms.i

644 lines
17 KiB
Raw Blame History

//
// Little cms
// Copyright (C) 1998-2007 Marti Maria
//
// 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.
//
// THIS SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
// EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
// WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
//
// IN NO EVENT SHALL MARTI MARIA BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
// INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
// OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
// WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
// LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
// OF THIS SOFTWARE.
//
// Version 1.17
/* File lcms.i */
%module lcms
%{
#include "lcms.h"
%}
#define register
%varargs(char* args) cmsSignalError;
%ignore USE_FLOAT;
%ignore USE_C;
%ignore USE_ASSEMBLER;
%ignore USE_INLINE;
%ignore LCMS_DLL;
%ignore LCMS_DLL_BUILD;
%ignore USE_BIG_ENDIAN;
%ignore USE_INT64;
%ignore USE_CUSTOM_SWAB;
%ignore M_PI;
%ignore LOGE;
%ignore MAX_PATH;
%ignore TRUE;
%ignore FALSE;
%ignore _cmsSAMPLER;
%ignore SAMPLEDCURVE;
%ignore LPSAMPLEDCURVE;
%rename (cmsSaveProfile) _cmsSaveProfile;
%{
static PyObject *lcmsError;
static volatile int InErrorFlag;
static
int MyErrorHandler(int Severity, const char* Txt)
{
if (Severity == LCMS_ERRC_WARNING)
PyErr_Warn(lcmsError, (char*) Txt);
else
PyErr_SetString(lcmsError, Txt);
InErrorFlag = 1;
return 1;
}
%}
%init %{
lcmsError = PyErr_NewException("lcms.error", NULL, NULL);
PyDict_SetItemString(d, "error", lcmsError);
cmsSetErrorHandler(MyErrorHandler);
%}
%exception %{
InErrorFlag = 0;
$function
if (InErrorFlag) SWIG_fail;
%}
/*
* Some typemaps
*/
/*
* Gamma triple. Must be specified as tuple.
*/
%typemap(in) LPGAMMATABLE[3](LPGAMMATABLE gamma[3]) {
PyObject* tmp[3];
if (PyTuple_Check($input)) {
if (!PyArg_ParseTuple($input,"OOO",&tmp[0],&tmp[1],&tmp[2])) {
PyErr_SetString(PyExc_TypeError,"gamma must have 3 elements");
return NULL;
}
if ((SWIG_ConvertPtr(tmp[0], (void **) &gamma[0], SWIGTYPE_p_GAMMATABLE,1)) == -1) return NULL;
if ((SWIG_ConvertPtr(tmp[1], (void **) &gamma[1], SWIGTYPE_p_GAMMATABLE,1)) == -1) return NULL;
if ((SWIG_ConvertPtr(tmp[2], (void **) &gamma[2], SWIGTYPE_p_GAMMATABLE,1)) == -1) return NULL;
$1 = gamma;
} else {
PyErr_SetString(PyExc_TypeError,"expected a tuple.");
return NULL;
}
}
/*
* 1-Color containers
*/
%inline %{
typedef struct {
WORD w[MAXCHANNELS];
} COLORW;
typedef COLORW* LPCOLORW;
typedef struct {
BYTE b[MAXCHANNELS];
} COLORB;
typedef COLORB* LPCOLORB;
typedef struct {
LCMSHANDLE hIT8;
} IT8;
typedef IT8* LPIT8;
%}
%include "lcms.h"
/*
** Extend our basic types
*/
%extend COLORB {
COLORB() {
LPCOLORB v;
v = (LPCOLORB) _cmsMalloc(sizeof(COLORB));
ZeroMemory(v, sizeof(COLORB));
return v;
}
~COLORB() {
_cmsFree(self);
}
const char* __repr__() {
return "Color 8 bps";
}
WORD __getitem__(int key) {
return self -> b[key];
}
void __setitem__(int key, int val) {
self -> b[key] = (BYTE) val;
}
};
%extend COLORW {
COLORW() {
LPCOLORW v;
v = (LPCOLORW) _cmsMalloc(sizeof(COLORW));
ZeroMemory(v, sizeof(COLORW));
return v;
}
~COLORB() {
_cmsFree(self);
}
const char* __repr__() {
return "Color 16 bps";
}
WORD __getitem__(int key) {
return self -> w[key];
}
void __setitem__(int key, int val) {
self -> w[key] = (WORD) val;
}
};
%extend cmsCIEXYZ {
cmsCIEXYZ(double x=0, double y=0, double z=0) {
LPcmsCIEXYZ v;
v = (LPcmsCIEXYZ) _cmsMalloc(sizeof(cmsCIEXYZ));
v->X = x;
v->Y = y;
v->Z = z;
return v;
}
~cmsCIEXYZ() {
_cmsFree(self);
}
const char* __repr__() {
static char Buffer[256];
sprintf(Buffer, "XYZ [%g, %g, %g]", self->X,self->Y,self->Z);
return Buffer;
}
};
%extend cmsCIExyY {
cmsCIExyY(double x=0, double y=0, double Y=0) {
LPcmsCIExyY v;
v = (LPcmsCIExyY) _cmsMalloc(sizeof(cmsCIExyY));
v->x = x;
v->y = y;
v->Y = Y;
return v;
}
~cmsCIExyY() {
_cmsFree(self);
}
const char* __repr__() {
static char Buffer[256];
sprintf(Buffer, "xyY [%g, %g, %g]", self->x,self->y,self->Y);
return Buffer;
}
};
%extend cmsCIELab {
cmsCIELab(double L=0, double a=0, double b=0) {
LPcmsCIELab v;
v = (LPcmsCIELab) _cmsMalloc(sizeof(cmsCIELab));
v->L = L;
v->a = a;
v->b = b;
return v;
}
~cmsCIELab() {
_cmsFree(self);
}
const char* __repr__() {
static char Buffer[256];
sprintf(Buffer, "Lab [%g, %g, %g]", self->L,self->a,self->b);
return Buffer;
}
int __cmp__(cmsCIELab* a) {
return cmsDeltaE(self, a) > 0.0;
}
};
%extend cmsCIELCh {
cmsCIELCh(double L=0, double C=0, double h=0) {
LPcmsCIELCh v;
v = (LPcmsCIELCh) _cmsMalloc(sizeof(cmsCIELCh));
v->L = L;
v->C = C;
v->h = h;
return v;
}
~cmsCIELCh() {
_cmsFree(self);
}
const char* __repr__() {
static char Buffer[256];
sprintf(Buffer, "LCh [%g, %g, %g]", self->L,self->C,self->h);
return Buffer;
}
};
%extend cmsJCh {
cmsJCh(double J=0, double C=0, double h=0) {
LPcmsJCh v;
v = (LPcmsJCh) _cmsMalloc(sizeof(cmsJCh));
v->J = J;
v->C = C;
v->h = h;
return v;
}
~cmsJCh() {
_cmsFree(self);
}
const char* __repr__() {
static char Buffer[256];
sprintf(Buffer, "CIECAM JCh [%g, %g, %g]", self->J,self->C,self->h);
return Buffer;
}
};
%extend GAMMATABLE {
GAMMATABLE(double Gamma, int nEntries=256) {
return Gamma <= 0 ? cmsAllocGamma(nEntries) : cmsBuildGamma(nEntries, Gamma);
}
~GAMMATABLE() {
cmsFreeGamma(self);
}
const char* __repr__() {
static char Buffer[256];
sprintf(Buffer, "Gamma Table of %d entries [estimated gamma %g]", self ->nEntries, cmsEstimateGamma(self));
return Buffer;
}
WORD __getitem__(int key) {
return self -> GammaTable[key];
}
void __setitem__(int key, WORD val) {
self -> GammaTable[key] = val;
}
};
%extend cmsCIExyYTRIPLE {
cmsCIExyYTRIPLE(cmsCIExyY* Red, cmsCIExyY* Green, cmsCIExyY* Blue) {
LPcmsCIExyYTRIPLE v;
v = (LPcmsCIExyYTRIPLE) _cmsMalloc(sizeof(cmsCIExyYTRIPLE));
CopyMemory(&v->Red, Red, sizeof(cmsCIExyY));
CopyMemory(&v->Green, Green, sizeof(cmsCIExyY));
CopyMemory(&v->Blue, Blue, sizeof(cmsCIExyY));
return v;
}
~cmsCIExyYTRIPLE() {
_cmsFree(self);
}
const char* __repr__() {
return "xyY Triple";
}
};
%extend cmsCIEXYZTRIPLE {
cmsCIEXYZTRIPLE(cmsCIEXYZ* Red, cmsCIEXYZ* Green, cmsCIEXYZ* Blue) {
LPcmsCIEXYZTRIPLE v;
v = (LPcmsCIEXYZTRIPLE) _cmsMalloc(sizeof(cmsCIEXYZTRIPLE));
CopyMemory(&v->Red, Red, sizeof(cmsCIExyY));
CopyMemory(&v->Green, Green, sizeof(cmsCIExyY));
CopyMemory(&v->Blue, Blue, sizeof(cmsCIExyY));
return v;
}
~cmsCIEXYZTRIPLE() {
_cmsFree(self);
}
const char* __repr__() {
return "xyY Triple";
}
};
%extend cmsViewingConditions {
cmsViewingConditions(cmsCIEXYZ* WhitePoint, double Yb, double La, int surround, double D_value) {
LPcmsViewingConditions v;
v = (LPcmsViewingConditions) _cmsMalloc(sizeof(cmsViewingConditions));
CopyMemory(&v -> whitePoint, WhitePoint, sizeof(cmsCIEXYZ));
v ->Yb = Yb;
v ->La = La;
v -> surround = surround;
v -> D_value = D_value;
return v;
}
~cmsViewingConditions() {
_cmsFree(self);
}
const char* __repr__() {
return "CIECAM97s viewing conditions";
}
};
%extend VEC3 {
VEC3(double vx=0, double vy=0, double vz=0) {
LPVEC3 v;
v = (LPVEC3) _cmsMalloc(sizeof(VEC3));
v->n[VX] =vx;
v->n[VY] =vy;
v->n[VZ] =vz;
return v;
}
~VEC3() {
_cmsFree(self);
}
double __getitem__(int key) {
return self -> n[key];
}
void __setitem__(int key, double val) {
self -> n[key] = val;
}
const char* __repr__() {
static char Buffer[256];
sprintf(Buffer, "VEC3 [%g, %g, %g]", self->n[VX],self->n[VY],self->n[VZ]);
return Buffer;
}
};
class icTagSignature {
};
%extend icTagSignature {
icTagSignature(unsigned int n) {
icTagSignature* v = (icTagSignature*) _cmsMalloc(sizeof(icTagSignature));
*v = (icTagSignature) n;
return v;
}
~icTagSignature() {
_cmsFree(self);
}
};
%extend IT8 {
IT8(const char* FileName) {
LPIT8 it8;
it8 = (LPIT8) _cmsMalloc(sizeof(IT8));
InErrorFlag = 0;
it8 -> hIT8 = cmsIT8LoadFromFile(FileName);
if (InErrorFlag) {
_cmsFree(it8);
return NULL;
}
return it8;
}
IT8() {
LPIT8 it8;
it8 = (LPIT8) _cmsMalloc(sizeof(IT8));
it8 -> hIT8 = cmsIT8Alloc();
return it8;
}
~IT8() {
cmsIT8Free(self -> hIT8);
_cmsFree(self);
}
const char* __repr__() {
return "CGATS.13/IT8 parser";
}
int saveToFile(const char* Filename) {
return cmsIT8SaveToFile(self -> hIT8, Filename);
}
int tableCount() { return cmsIT8TableCount(self -> hIT8); }
int setTable(int n) { return cmsIT8SetTable(self -> hIT8, n); }
const char* getSheetType() { return cmsIT8GetSheetType(self -> hIT8); }
int setSheetType(const char* Type) { return cmsIT8SetSheetType(self -> hIT8, Type); }
int addComment(const char* txt) { return cmsIT8SetComment(self -> hIT8, txt); }
int setProperty(const char* Prop, const char* Str) { return cmsIT8SetPropertyStr(self -> hIT8, Prop, Str); }
int setProperty(const char* Prop, double dbl) { return cmsIT8SetPropertyDbl(self -> hIT8, Prop, dbl); }
int setPropertyAsHex(const char* Prop, int Val) { return cmsIT8SetPropertyHex(self -> hIT8, Prop, Val); }
int setPropertyUncooked(const char* Prop,
const char* Str) { return cmsIT8SetPropertyUncooked(self -> hIT8, Prop, Str); }
const char* getProperty(const char* Prop) { return cmsIT8GetProperty(self -> hIT8, Prop); }
double getPropertyAsDbl(const char* Prop) { return cmsIT8GetPropertyDbl(self -> hIT8, Prop); }
const char* getData(int row, int col) { return cmsIT8GetDataRowCol(self -> hIT8, row, col); }
const char* getData(const char* Patch,
const char* Sample) { return cmsIT8GetData(self -> hIT8, Patch, Sample); }
double getDataAsDbl(int row, int col) { return cmsIT8GetDataRowColDbl(self -> hIT8, row, col); }
double getDataAsDbl(const char* Patch,
const char* Sample) { return cmsIT8GetDataDbl(self -> hIT8, Patch, Sample); }
int setData(int row, int col, const char* Val) { return cmsIT8SetDataRowCol(self ->hIT8, row, col, Val); }
int setData(int row, int col, double dbl) { return cmsIT8SetDataRowColDbl(self ->hIT8, row, col, dbl); }
int setData(const char* Patch,
const char* Sample,
const char* Val) { return cmsIT8SetData(self ->hIT8, Patch, Sample, Val); }
int setData(const char* Patch,
const char* Sample,
double dbl) { return cmsIT8SetDataDbl(self ->hIT8, Patch, Sample, dbl); }
int setDataFormat(int nSample, const char* Sample) { return cmsIT8SetDataFormat(self -> hIT8, nSample, Sample); }
const char* getPatchName(int nPatch) { return cmsIT8GetPatchName(self -> hIT8, nPatch, NULL); }
int getDataFormat(const char* Patch) { return cmsIT8GetDataFormat(self -> hIT8, Patch); }
PyObject* enumDataFormat() {
char** DataFormat;
PyObject* TheList;
PyObject* OneDataFormat;
int i, n;
n = cmsIT8EnumDataFormat(self -> hIT8, &DataFormat);
TheList = PyList_New(n);
if (!TheList) return NULL;
for (i = 0; i < n; i++) {
OneDataFormat = PyString_FromString(DataFormat[i]);
PyList_SET_ITEM(TheList, i, OneDataFormat);
}
return TheList;
}
PyObject* enumProperties() {
const char** Props;
PyObject* TheList;
PyObject* OneProp;
int i, n;
n = cmsIT8EnumProperties(self -> hIT8, &Props);
TheList = PyList_New(n);
if (!TheList) return NULL;
for (i = 0; i < n; i++) {
OneProp = PyString_FromString(Props[i]);
PyList_SET_ITEM(TheList, i, OneProp);
}
return TheList;
}
int setTableByLabel(const char* cSet, const char *cFld = NULL, const char* ExpectedType = NULL) {
return cmsIT8SetTableByLabel(self -> hIT8, cSet, cFld, ExpectedType);
}
PyObject* getRow(int n) {
PyObject* TheList;
PyObject* OneProp;
int i;
int nf = (int) cmsIT8GetPropertyDbl(self -> hIT8, "NUMBER_OF_FIELDS");
if (nf <= 0) return NULL;
TheList = PyList_New(nf);
if (!TheList) return NULL;
for (i = 0; i < nf; i++) {
OneProp = PyString_FromString(cmsIT8GetDataRowCol(self ->hIT8, n, i));
PyList_SET_ITEM(TheList, i, OneProp);
}
return TheList;
}
PyObject* getCol(const char *Patch) {
PyObject* TheList;
PyObject* OneProp;
int i;
int n = cmsIT8GetDataFormat(self -> hIT8, Patch);
if (n < 0) return NULL;
int ns = (int) cmsIT8GetPropertyDbl(self -> hIT8, "NUMBER_OF_SETS");
if (ns <= 0) return NULL;
TheList = PyList_New(ns);
if (!TheList) return NULL;
for (i = 0; i < ns; i++) {
OneProp = PyString_FromString(cmsIT8GetDataRowCol(self ->hIT8, i, n));
PyList_SET_ITEM(TheList, i, OneProp);
}
return TheList;
}
};
// ----------------------------------------------------------------------- TODO
%inline %{
class StrPointer {
};
%}
%extend StrPointer {
StrPointer(char* s) {
return (StrPointer*) s;
}
};
View Git Blame Copy Permalink