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
126
127
128
129
130
131
132
133
134
135
136
137
|
module dmagick.c.quantum;
import dmagick.c.cacheView;
import dmagick.c.exception;
import dmagick.c.image;
import dmagick.c.magickType;
import dmagick.c.magickVersion;
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);
}
static if ( MagickLibVersion >= 0x681 )
{
EndianType GetQuantumEndian(const(QuantumInfo)*);
}
MagickBooleanType SetQuantumDepth(const(Image)*, QuantumInfo*, const size_t);
static if ( MagickLibVersion >= 0x681 )
{
MagickBooleanType SetQuantumEndian(const(Image)*, QuantumInfo*, const EndianType);
}
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);
}
|
