1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
module dmagick.c.quantum;
import dmagick.c.cacheView;
import dmagick.c.exception;
import dmagick.c.image;
import dmagick.c.magickType;
extern(C)
{
/**
* The endianess of the image when reading the image file.
*/
enum EndianType
{
UndefinedEndian, /// Not defined (default).
LSBEndian, /// Little Endian.
MSBEndian /// Big Endian.
}
enum QuantumAlphaType
{
UndefinedQuantumAlpha,
AssociatedQuantumAlpha,
DisassociatedQuantumAlpha
}
enum QuantumFormatType
{
UndefinedQuantumFormat,
FloatingPointQuantumFormat,
SignedQuantumFormat,
UnsignedQuantumFormat
}
enum QuantumType
{
UndefinedQuantum,
AlphaQuantum,
BlackQuantum,
BlueQuantum,
CMYKAQuantum,
CMYKQuantum,
CyanQuantum,
GrayAlphaQuantum,
GrayQuantum,
GreenQuantum,
IndexAlphaQuantum,
IndexQuantum,
MagentaQuantum,
OpacityQuantum,
RedQuantum,
RGBAQuantum,
BGRAQuantum,
RGBOQuantum,
RGBQuantum,
YellowQuantum,
GrayPadQuantum,
RGBPadQuantum,
CbYCrYQuantum,
CbYCrQuantum,
CbYCrAQuantum,
CMYKOQuantum,
BGRQuantum,
BGROQuantum
}
struct QuantumInfo {}
alias ClampToQuantum RoundToQuantum;
static pure nothrow Quantum ClampToQuantum(const MagickRealType value)
{
if (value <= 0.0)
return(cast(Quantum) 0);
if (value >= cast(MagickRealType) QuantumRange)
return(cast(Quantum) QuantumRange);
return(cast(Quantum) (value+0.5));
}
static pure nothrow ubyte ScaleQuantumToChar(const Quantum quantum)
{
static if ( MagickQuantumDepth == 8 )
return quantum;
else static if ( MagickQuantumDepth == 16 )
return cast(ubyte) (((quantum+128UL)-((quantum+128UL) >> 8)) >> 8);
else static if ( MagickQuantumDepth == 32 )
return cast(ubyte) (quantum+8421504UL/16843009UL );
else
return cast(ubyte) (quantum/72340172838076673.0+0.5);
}
static pure nothrow Quantum ScaleCharToQuantum(ubyte value)
{
enum Quantum factor = QuantumRange/255;
return cast(Quantum)(factor*value);
}
MagickBooleanType SetQuantumDepth(const(Image)*, QuantumInfo*, const size_t);
MagickBooleanType SetQuantumFormat(const(Image)*, QuantumInfo*, const QuantumFormatType);
MagickBooleanType SetQuantumPad(const(Image)*, QuantumInfo*, const size_t);
static if ( MagickLibVersion >= 0x674 )
{
QuantumFormatType GetQuantumFormat(const(QuantumInfo)*);
}
QuantumInfo* AcquireQuantumInfo(const(ImageInfo)*, Image*);
QuantumInfo* DestroyQuantumInfo(QuantumInfo*);
QuantumType GetQuantumType(Image*, ExceptionInfo*);
size_t ExportQuantumPixels(const(Image)*, const(CacheView)*, const(QuantumInfo)*, const QuantumType, ubyte*, ExceptionInfo*);
size_t GetQuantumExtent(const(Image)*, const(QuantumInfo)*, const QuantumType);
size_t ImportQuantumPixels(Image*, CacheView*, const(QuantumInfo)*, const QuantumType, const(ubyte)*, ExceptionInfo*);
ubyte* GetQuantumPixels(const(QuantumInfo)*);
void GetQuantumInfo(const(ImageInfo)*, QuantumInfo*);
void SetQuantumAlphaType(QuantumInfo*, const QuantumAlphaType);
void SetQuantumImageType(Image*, const QuantumType);
void SetQuantumMinIsWhite(QuantumInfo*, const MagickBooleanType);
void SetQuantumPack(QuantumInfo*, const MagickBooleanType);
void SetQuantumQuantum(QuantumInfo*, const size_t);
void SetQuantumScale(QuantumInfo*, const double);
}
|
