1 #include "rs_core.rsh"
2 #include "rs_graphics.rsh"
3 #include "rs_structs.h"
4
5 // Opaque Allocation type operations
6 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimX(rs_allocation a)7 rsAllocationGetDimX(rs_allocation a) {
8 Allocation_t *alloc = (Allocation_t *)a.p;
9 return alloc->mHal.drvState.lod[0].dimX;
10 }
11
12 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimY(rs_allocation a)13 rsAllocationGetDimY(rs_allocation a) {
14 Allocation_t *alloc = (Allocation_t *)a.p;
15 return alloc->mHal.drvState.lod[0].dimY;
16 }
17
18 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimZ(rs_allocation a)19 rsAllocationGetDimZ(rs_allocation a) {
20 Allocation_t *alloc = (Allocation_t *)a.p;
21 return alloc->mHal.drvState.lod[0].dimZ;
22 }
23
24 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimLOD(rs_allocation a)25 rsAllocationGetDimLOD(rs_allocation a) {
26 Allocation_t *alloc = (Allocation_t *)a.p;
27 return alloc->mHal.state.hasMipmaps;
28 }
29
30 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimFaces(rs_allocation a)31 rsAllocationGetDimFaces(rs_allocation a) {
32 Allocation_t *alloc = (Allocation_t *)a.p;
33 return alloc->mHal.state.hasFaces;
34 }
35
36
37 extern rs_element __attribute__((overloadable))
rsAllocationGetElement(rs_allocation a)38 rsAllocationGetElement(rs_allocation a) {
39 Allocation_t *alloc = (Allocation_t *)a.p;
40 if (alloc == NULL) {
41 rs_element nullElem = {0};
42 return nullElem;
43 }
44 Type_t *type = (Type_t *)alloc->mHal.state.type;
45 rs_element returnElem = {type->mHal.state.element};
46 return returnElem;
47 }
48
49 // TODO: this needs to be optimized, obviously
memcpy(void * dst,void * src,size_t size)50 static void memcpy(void* dst, void* src, size_t size) {
51 char* dst_c = (char*) dst, *src_c = (char*) src;
52 for (; size > 0; size--) {
53 *dst_c++ = *src_c++;
54 }
55 }
56
57 #ifdef RS_DEBUG_RUNTIME
58 #define ELEMENT_AT(T) \
59 extern void __attribute__((overloadable)) \
60 rsSetElementAt_##T(rs_allocation a, const T *val, uint32_t x); \
61 extern void __attribute__((overloadable)) \
62 rsSetElementAt_##T(rs_allocation a, const T *val, uint32_t x, uint32_t y); \
63 extern void __attribute__((overloadable)) \
64 rsSetElementAt_##T(rs_allocation a, const T *val, uint32_t x, uint32_t y, uint32_t z); \
65 extern void __attribute__((overloadable)) \
66 rsGetElementAt_##T(rs_allocation a, T *val, uint32_t x); \
67 extern void __attribute__((overloadable)) \
68 rsGetElementAt_##T(rs_allocation a, T *val, uint32_t x, uint32_t y); \
69 extern void __attribute__((overloadable)) \
70 rsGetElementAt_##T(rs_allocation a, T *val, uint32_t x, uint32_t y, uint32_t z); \
71 \
72 extern void __attribute__((overloadable)) \
73 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x) { \
74 rsSetElementAt_##T(a, &val, x); \
75 } \
76 extern void __attribute__((overloadable)) \
77 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x, uint32_t y) { \
78 rsSetElementAt_##T(a, &val, x, y); \
79 } \
80 extern void __attribute__((overloadable)) \
81 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x, uint32_t y, uint32_t z) { \
82 rsSetElementAt_##T(a, &val, x, y, z); \
83 } \
84 extern T __attribute__((overloadable)) \
85 rsGetElementAt_##T(rs_allocation a, uint32_t x) { \
86 T tmp; \
87 rsGetElementAt_##T(a, &tmp, x); \
88 return tmp; \
89 } \
90 extern T __attribute__((overloadable)) \
91 rsGetElementAt_##T(rs_allocation a, uint32_t x, uint32_t y) { \
92 T tmp; \
93 rsGetElementAt_##T(a, &tmp, x, y); \
94 return tmp; \
95 } \
96 extern T __attribute__((overloadable)) \
97 rsGetElementAt_##T(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { \
98 T tmp; \
99 rsGetElementAt_##T(a, &tmp, x, y, z); \
100 return tmp; \
101 }
102
103 #else
104
105 uint8_t*
rsOffset(rs_allocation a,uint32_t sizeOf,uint32_t x,uint32_t y,uint32_t z)106 rsOffset(rs_allocation a, uint32_t sizeOf, uint32_t x, uint32_t y,
107 uint32_t z) {
108 Allocation_t *alloc = (Allocation_t *)a.p;
109 uint8_t *p = (uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
110 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
111 const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
112 uint8_t *dp = &p[(sizeOf * x) + (y * stride) +
113 (z * stride * dimY)];
114 return dp;
115 }
116
117 #define ELEMENT_AT(T) \
118 \
119 void \
120 rsSetElementAtImpl_##T(rs_allocation a, T val, uint32_t x, \
121 uint32_t y, uint32_t z); \
122 \
123 extern void __attribute__((overloadable)) \
124 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x) { \
125 rsSetElementAtImpl_##T(a, val, x, 0, 0); \
126 } \
127 \
128 extern void __attribute__((overloadable)) \
129 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x, \
130 uint32_t y) { \
131 rsSetElementAtImpl_##T(a, val, x, y, 0); \
132 } \
133 \
134 extern void __attribute__((overloadable)) \
135 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x, uint32_t y, \
136 uint32_t z) { \
137 rsSetElementAtImpl_##T(a, val, x, y, z); \
138 } \
139 \
140 T \
141 rsGetElementAtImpl_##T(rs_allocation a, uint32_t x, uint32_t y, \
142 uint32_t z); \
143 \
144 extern T __attribute__((overloadable)) \
145 rsGetElementAt_##T(rs_allocation a, uint32_t x) { \
146 return rsGetElementAtImpl_##T(a, x, 0, 0); \
147 } \
148 \
149 extern T __attribute__((overloadable)) \
150 rsGetElementAt_##T(rs_allocation a, uint32_t x, uint32_t y) { \
151 return rsGetElementAtImpl_##T(a, x, y, 0); \
152 } \
153 \
154 extern T __attribute__((overloadable)) \
155 rsGetElementAt_##T(rs_allocation a, uint32_t x, uint32_t y, \
156 uint32_t z) { \
157 return rsGetElementAtImpl_##T(a, x, y, z); \
158 }
159
160
161
162 extern const void * __attribute__((overloadable))
rsGetElementAt(rs_allocation a,uint32_t x)163 rsGetElementAt(rs_allocation a, uint32_t x) {
164 Allocation_t *alloc = (Allocation_t *)a.p;
165 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
166 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
167 return &p[eSize * x];
168 }
169
170 extern const void * __attribute__((overloadable))
rsGetElementAt(rs_allocation a,uint32_t x,uint32_t y)171 rsGetElementAt(rs_allocation a, uint32_t x, uint32_t y) {
172 Allocation_t *alloc = (Allocation_t *)a.p;
173 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
174 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
175 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
176 return &p[(eSize * x) + (y * stride)];
177 }
178
179 extern const void * __attribute__((overloadable))
rsGetElementAt(rs_allocation a,uint32_t x,uint32_t y,uint32_t z)180 rsGetElementAt(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) {
181 Allocation_t *alloc = (Allocation_t *)a.p;
182 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
183 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
184 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
185 const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
186 return &p[(eSize * x) + (y * stride) + (z * stride * dimY)];
187 }
188 extern void __attribute__((overloadable))
rsSetElementAt(rs_allocation a,void * ptr,uint32_t x)189 rsSetElementAt(rs_allocation a, void* ptr, uint32_t x) {
190 Allocation_t *alloc = (Allocation_t *)a.p;
191 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
192 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
193 memcpy((void*)&p[eSize * x], ptr, eSize);
194 }
195
196 extern void __attribute__((overloadable))
rsSetElementAt(rs_allocation a,void * ptr,uint32_t x,uint32_t y)197 rsSetElementAt(rs_allocation a, void* ptr, uint32_t x, uint32_t y) {
198 Allocation_t *alloc = (Allocation_t *)a.p;
199 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
200 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
201 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
202 memcpy((void*)&p[(eSize * x) + (y * stride)], ptr, eSize);
203 }
204
205 extern void __attribute__((overloadable))
rsSetElementAt(rs_allocation a,void * ptr,uint32_t x,uint32_t y,uint32_t z)206 rsSetElementAt(rs_allocation a, void* ptr, uint32_t x, uint32_t y, uint32_t z) {
207 Allocation_t *alloc = (Allocation_t *)a.p;
208 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
209 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
210 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
211 const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
212 memcpy((void*)&p[(eSize * x) + (y * stride) + (z * stride * dimY)], ptr, eSize);
213 }
214 #endif
215
216 ELEMENT_AT(char)
ELEMENT_AT(char2)217 ELEMENT_AT(char2)
218 ELEMENT_AT(char3)
219 ELEMENT_AT(char4)
220 ELEMENT_AT(uchar)
221 ELEMENT_AT(uchar2)
222 ELEMENT_AT(uchar3)
223 ELEMENT_AT(uchar4)
224 ELEMENT_AT(short)
225 ELEMENT_AT(short2)
226 ELEMENT_AT(short3)
227 ELEMENT_AT(short4)
228 ELEMENT_AT(ushort)
229 ELEMENT_AT(ushort2)
230 ELEMENT_AT(ushort3)
231 ELEMENT_AT(ushort4)
232 ELEMENT_AT(int)
233 ELEMENT_AT(int2)
234 ELEMENT_AT(int3)
235 ELEMENT_AT(int4)
236 ELEMENT_AT(uint)
237 ELEMENT_AT(uint2)
238 ELEMENT_AT(uint3)
239 ELEMENT_AT(uint4)
240 ELEMENT_AT(long)
241 ELEMENT_AT(long2)
242 ELEMENT_AT(long3)
243 ELEMENT_AT(long4)
244 ELEMENT_AT(ulong)
245 ELEMENT_AT(ulong2)
246 ELEMENT_AT(ulong3)
247 ELEMENT_AT(ulong4)
248 ELEMENT_AT(float)
249 ELEMENT_AT(float2)
250 ELEMENT_AT(float3)
251 ELEMENT_AT(float4)
252 ELEMENT_AT(double)
253 ELEMENT_AT(double2)
254 ELEMENT_AT(double3)
255 ELEMENT_AT(double4)
256
257 #undef ELEMENT_AT
258
259
260 extern const uchar __attribute__((overloadable))
261 rsGetElementAtYuv_uchar_Y(rs_allocation a, uint32_t x, uint32_t y) {
262 return rsGetElementAt_uchar(a, x, y);
263 }
264
265 extern const uchar __attribute__((overloadable))
rsGetElementAtYuv_uchar_U(rs_allocation a,uint32_t x,uint32_t y)266 rsGetElementAtYuv_uchar_U(rs_allocation a, uint32_t x, uint32_t y) {
267
268 Allocation_t *alloc = (Allocation_t *)a.p;
269
270 const size_t cstep = alloc->mHal.drvState.yuv.step;
271 const size_t shift = alloc->mHal.drvState.yuv.shift;
272 const size_t stride = alloc->mHal.drvState.lod[1].stride;
273
274 const uchar *pin = (const uchar *)alloc->mHal.drvState.lod[1].mallocPtr;
275
276 return pin[((x >> shift) * cstep) + ((y >> shift) * stride)];
277 }
278
279 extern const uchar __attribute__((overloadable))
rsGetElementAtYuv_uchar_V(rs_allocation a,uint32_t x,uint32_t y)280 rsGetElementAtYuv_uchar_V(rs_allocation a, uint32_t x, uint32_t y) {
281
282 Allocation_t *alloc = (Allocation_t *)a.p;
283
284 const size_t cstep = alloc->mHal.drvState.yuv.step;
285 const size_t shift = alloc->mHal.drvState.yuv.shift;
286 const size_t stride = alloc->mHal.drvState.lod[2].stride;
287
288 const uchar *pin = (const uchar *)alloc->mHal.drvState.lod[2].mallocPtr;
289
290 return pin[((x >> shift) * cstep) + ((y >> shift) * stride)];
291 }
292
293