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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
|
/* See LICENSE file for copyright and license details. */
package libgamma;
/**
* Cathode ray tube controller state
* <p>
* The CRTC controls the gamma ramps for the
* monitor that is plugged in to the connector
* that the CRTC belongs to
*/
public class CRTC
{
/**
* Type initialiser
*/
static
{
Libgamma.initialise();
}
/**
* Constructor
*
* @param partition The partition this CRTC belongs to
* @param crtc The index of the CRTC within its partition
*/
public CRTC(Partition partition, int crtc) throws LibgammaException
{
this.partition = partition;
this.crtc = crtc;
long[] r = libgamma_crtc_create(partition.address, crtc);
this.address = r[0];
if (r[1] != 0)
throw new LibgammaException((int)(r[1]));
}
/**
* The partition this CRTC belongs to
*/
public final Partition partition;
/**
* The index of the CRTC within its partition
*/
public final int crtc;
/**
* The address of the native object
*/
final long address;
/**
* Release resources
*/
public void close()
{
libgamma_crtc_free(this.address);
}
/**
* Restore the gamma ramps for the CRTC to the system settings
*/
public void restore() throws LibgammaException
{
int r = libgamma_crtc_restore(this.address);
if (r != 0)
throw new LibgammaException(r);
}
/**
* Read information about the CRTC
*
* @param fields OR:ed identifiers for the information about the CRTC that should be read
* @return Information about the CRTC
*/
public CRTCInformation get_information(int fields)
{
Object[] r = libgamma_get_crtc_information(this.address, fields);
byte[] edid = (byte[])(r[0]);
String connector_name = (String)(r[1]);
float[] gamma = (float[])(r[2]);
int[] ints = (int[])(r[3]);
return new CRTCInformation(edid, connector_name, gamma, ints);
}
/**
* Get the current gamma ramps for the CRTC
*
* @param output The gamma ramp structure to fill
*/
public <T extends Ramp> void get_gamma(GammaRamps<T> output) throws LibgammaException
{
int r = 0;
if (output.depth == 8) r = libgamma_crtc_get_gamma_ramps8(this.address, output.address);
else if (output.depth == 16) r = libgamma_crtc_get_gamma_ramps16(this.address, output.address);
else if (output.depth == 32) r = libgamma_crtc_get_gamma_ramps32(this.address, output.address);
else if (output.depth == 64) r = libgamma_crtc_get_gamma_ramps64(this.address, output.address);
else if (output.depth == -1) r = libgamma_crtc_get_gamma_rampsf(this.address, output.address);
else if (output.depth == -2) r = libgamma_crtc_get_gamma_rampsd(this.address, output.address);
if (r != 0)
throw new LibgammaException(r);
}
/**
* Set the gamma ramps for the CRTC
*
* @param values The gamma ramps to apply
*/
public <T extends Ramp> void set_gamma(GammaRamps<T> values) throws LibgammaException
{
int r = 0;
if (values.depth == 8) r = libgamma_crtc_set_gamma_ramps8(this.address, values.address);
else if (values.depth == 16) r = libgamma_crtc_set_gamma_ramps16(this.address, values.address);
else if (values.depth == 32) r = libgamma_crtc_set_gamma_ramps32(this.address, values.address);
else if (values.depth == 64) r = libgamma_crtc_set_gamma_ramps64(this.address, values.address);
else if (values.depth == -1) r = libgamma_crtc_set_gamma_rampsf(this.address, values.address);
else if (values.depth == -2) r = libgamma_crtc_set_gamma_rampsd(this.address, values.address);
if (r != 0)
throw new LibgammaException(r);
}
/**
* {@inheritDoc}
*/
public String toString()
{
return "<Site: partition = " + this.partition.toString() + ", " +
"crtc = " + Integer.toString(this.crtc) + ">";
}
/**
* Create a CRTC state
*
* @param partition The partition state for the partition that the CRTC belongs to
* @param crtc The index of the CRTC within the partition
* @return Element 0: The value for {@link #address}<br>
* Element 1: Error code, zero on success
*/
private static native long[] libgamma_crtc_create(long partition, int crtc);
/**
* Release all resources held by a CRTC state
* and free the CRTC state pointer
*
* @param address The CRTC state
*/
private static native void libgamma_crtc_free(long address);
/**
* Restore the gamma ramps for a CRTC to the system settings for that CRTC
*
* @param address The CRTC state
* @return Zero on success, and error code on failure
*/
private static native int libgamma_crtc_restore(long address);
/**
* Read information about a CRTC
*
* @param crtc The state of the CRTC whose information should be read
* @param fields OR:ed identifiers for the information about the CRTC that should be read
* @return Input parameters for the constructor of {@link CRTCInformation}
*/
private static native Object[] libgamma_get_crtc_information(long crtc, int fields);
/**
* Get the current gamma ramps for a CRTC, 8-bit gamma-depth version
*
* @param address The CRTC state
* @param ramps The gamma ramps to fill with the current values
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_get_gamma_ramps8(long address, long ramps);
/**
* Set the gamma ramps for a CRTC, 8-bit gamma-depth version
*
* @param address The CRTC state
* @param ramps The gamma ramps to apply
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_set_gamma_ramps8(long address, long ramps);
/**
* Get the current gamma ramps for a CRTC, 16-bit gamma-depth version
*
* @param address The CRTC state
* @param ramps The gamma ramps to fill with the current values
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_get_gamma_ramps16(long address, long ramps);
/**
* Set the gamma ramps for a CRTC, 16-bit gamma-depth version
*
* @param address The CRTC state
* @param ramps The gamma ramps to apply
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_set_gamma_ramps16(long address, long ramps);
/**
* Get the current gamma ramps for a CRTC, 32-bit gamma-depth version
*
* @param address The CRTC state
* @param ramps The gamma ramps to fill with the current values
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_get_gamma_ramps32(long address, long ramps);
/**
* Set the gamma ramps for a CRTC, 32-bit gamma-depth version
*
* @param address The CRTC state
* @param ramps The gamma ramps to apply
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_set_gamma_ramps32(long address, long ramps);
/**
* Get the current gamma ramps for a CRTC, 64-bit gamma-depth version
*
* @param address The CRTC state
* @param ramps The gamma ramps to fill with the current values
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_get_gamma_ramps64(long address, long ramps);
/**
* Set the gamma ramps for a CRTC, 64-bit gamma-depth version
*
* @param address The CRTC state
* @param ramps The gamma ramps to apply
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_set_gamma_ramps64(long address, long ramps);
/**
* Set the gamma ramps for a CRTC, single precision floating point version
*
* @param address The CRTC state
* @param ramps The gamma ramps to apply
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_set_gamma_rampsf(long address, long ramps);
/**
* Get the current gamma ramps for a CRTC, single precision floating point version
*
* @param address The CRTC state
* @param ramps The gamma ramps to fill with the current values
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_get_gamma_rampsf(long address, long ramps);
/**
* Get the current gamma ramps for a CRTC, double precision floating point version
*
* @param address The CRTC state
* @param ramps The gamma ramps to fill with the current values
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_get_gamma_rampsd(long address, long ramps);
/**
* Set the gamma ramps for a CRTC, double precision floating point version
*
* @param address The CRTC state
* @param ramps The gamma ramps to apply
* @return Zero on success, an error code on failure
*/
private static native int libgamma_crtc_set_gamma_rampsd(long address, long ramps);
}
|
