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
|
package com.mbien.opencl;
import java.nio.Buffer;
import static com.mbien.opencl.CLException.*;
import static com.mbien.opencl.CL.*;
/**
* Object representing an OpenCL sampler.
* @author Michael Bien
*/
public class CLSampler implements CLResource {
public final long ID;
private final CLContext context;
private final CL cl;
private final CLSamplerInfoAccessor samplerInfo;
CLSampler(CLContext context, AddressingMode addrMode, FilteringMode filtMode, boolean normalizedCoords) {
this.context = context;
this.cl = context.cl;
this.samplerInfo = new CLSamplerInfoAccessor();
int[] error = new int[1];
ID = cl.clCreateSampler(context.ID, normalizedCoords?CL_TRUE:CL_FALSE, addrMode.MODE, filtMode.MODE, error, 0);
checkForError(error[0], "can not create sampler");
}
public FilteringMode getFilteringMode() {
int info = (int)samplerInfo.getLong(CL_SAMPLER_FILTER_MODE);
return FilteringMode.valueOf(info);
}
public AddressingMode getAddressingMode() {
int info = (int)samplerInfo.getLong(CL_SAMPLER_ADDRESSING_MODE);
return AddressingMode.valueOf(info);
}
public boolean hasNormalizedCoords() {
return samplerInfo.getLong(CL_SAMPLER_NORMALIZED_COORDS) == CL_TRUE;
}
public void release() {
int ret = cl.clReleaseSampler(ID);
context.onSamplerReleased(this);
checkForError(ret, "can not release sampler");
}
private class CLSamplerInfoAccessor extends CLInfoAccessor {
@Override
protected int getInfo(int name, long valueSize, Buffer value, long[] valueSizeRet, int valueSizeRetOffset) {
return cl.clGetSamplerInfo(ID, name, valueSize, value, valueSizeRet, valueSizeRetOffset);
}
}
public enum FilteringMode {
NEAREST(CL_FILTER_NEAREST),
LINEAR(CL_FILTER_LINEAR);
/**
* Value of wrapped OpenCL sampler filtering mode type.
*/
public final int MODE;
private FilteringMode(int mode) {
this.MODE = mode;
}
public static FilteringMode valueOf(int mode) {
switch(mode) {
case(CL_FILTER_NEAREST):
return NEAREST;
case(CL_FILTER_LINEAR):
return LINEAR;
}
return null;
}
}
public enum AddressingMode {
REPEAT(CL_ADDRESS_REPEAT),
CLAMP_TO_EDGE(CL_ADDRESS_CLAMP_TO_EDGE),
CLAMP(CL_ADDRESS_CLAMP),
NONE(CL_ADDRESS_NONE);
/**
* Value of wrapped OpenCL sampler addressing mode type.
*/
public final int MODE;
private AddressingMode(int mode) {
this.MODE = mode;
}
public static AddressingMode valueOf(int mode) {
switch(mode) {
case(CL_ADDRESS_REPEAT):
return REPEAT;
case(CL_ADDRESS_CLAMP_TO_EDGE):
return CLAMP_TO_EDGE;
case(CL_ADDRESS_CLAMP):
return CLAMP;
case(CL_ADDRESS_NONE):
return NONE;
}
return null;
}
}
}
|
