1 #include "rs_core.rsh"
2 #include "rs_structs.h"
3
4 // Opaque Allocation type operations
5 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimX(rs_allocation a)6 rsAllocationGetDimX(rs_allocation a) {
7 Allocation_t *alloc = (Allocation_t *)a.p;
8 return alloc->mHal.drvState.lod[0].dimX;
9 }
10
11 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimY(rs_allocation a)12 rsAllocationGetDimY(rs_allocation a) {
13 Allocation_t *alloc = (Allocation_t *)a.p;
14 return alloc->mHal.drvState.lod[0].dimY;
15 }
16
17 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimZ(rs_allocation a)18 rsAllocationGetDimZ(rs_allocation a) {
19 Allocation_t *alloc = (Allocation_t *)a.p;
20 return alloc->mHal.drvState.lod[0].dimZ;
21 }
22
23 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimLOD(rs_allocation a)24 rsAllocationGetDimLOD(rs_allocation a) {
25 Allocation_t *alloc = (Allocation_t *)a.p;
26 return alloc->mHal.state.hasMipmaps;
27 }
28
29 extern uint32_t __attribute__((overloadable))
rsAllocationGetDimFaces(rs_allocation a)30 rsAllocationGetDimFaces(rs_allocation a) {
31 Allocation_t *alloc = (Allocation_t *)a.p;
32 return alloc->mHal.state.hasFaces;
33 }
34
35
36 extern rs_element __attribute__((overloadable))
rsAllocationGetElement(rs_allocation a)37 rsAllocationGetElement(rs_allocation a) {
38 Allocation_t *alloc = (Allocation_t *)a.p;
39 if (alloc == NULL) {
40 rs_element nullElem = {0};
41 return nullElem;
42 }
43 Type_t *type = (Type_t *)alloc->mHal.state.type;
44 rs_element returnElem = {type->mHal.state.element};
45 rs_element rs_retval = {0};
46 rsSetObject(&rs_retval, returnElem);
47 return rs_retval;
48 }
49
50 // TODO: this needs to be optimized, obviously
local_memcpy(void * dst,const void * src,size_t size)51 static void local_memcpy(void* dst, const void* src, size_t size) {
52 char* dst_c = (char*) dst;
53 const char* src_c = (const char*) src;
54 for (; size > 0; size--) {
55 *dst_c++ = *src_c++;
56 }
57 }
58
59 #ifdef RS_DEBUG_RUNTIME
60 #define ELEMENT_AT(T) \
61 extern void __attribute__((overloadable)) \
62 rsSetElementAt_##T(rs_allocation a, const T *val, uint32_t x); \
63 extern void __attribute__((overloadable)) \
64 rsSetElementAt_##T(rs_allocation a, const T *val, uint32_t x, uint32_t y); \
65 extern void __attribute__((overloadable)) \
66 rsSetElementAt_##T(rs_allocation a, const T *val, uint32_t x, uint32_t y, uint32_t z); \
67 extern void __attribute__((overloadable)) \
68 rsGetElementAt_##T(rs_allocation a, T *val, uint32_t x); \
69 extern void __attribute__((overloadable)) \
70 rsGetElementAt_##T(rs_allocation a, T *val, uint32_t x, uint32_t y); \
71 extern void __attribute__((overloadable)) \
72 rsGetElementAt_##T(rs_allocation a, T *val, uint32_t x, uint32_t y, uint32_t z); \
73 \
74 extern void __attribute__((overloadable)) \
75 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x) { \
76 rsSetElementAt_##T(a, &val, x); \
77 } \
78 extern void __attribute__((overloadable)) \
79 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x, uint32_t y) { \
80 rsSetElementAt_##T(a, &val, x, y); \
81 } \
82 extern void __attribute__((overloadable)) \
83 rsSetElementAt_##T(rs_allocation a, T val, uint32_t x, uint32_t y, uint32_t z) { \
84 rsSetElementAt_##T(a, &val, x, y, z); \
85 } \
86 extern T __attribute__((overloadable)) \
87 rsGetElementAt_##T(rs_allocation a, uint32_t x) { \
88 T tmp; \
89 rsGetElementAt_##T(a, &tmp, x); \
90 return tmp; \
91 } \
92 extern T __attribute__((overloadable)) \
93 rsGetElementAt_##T(rs_allocation a, uint32_t x, uint32_t y) { \
94 T tmp; \
95 rsGetElementAt_##T(a, &tmp, x, y); \
96 return tmp; \
97 } \
98 extern T __attribute__((overloadable)) \
99 rsGetElementAt_##T(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { \
100 T tmp; \
101 rsGetElementAt_##T(a, &tmp, x, y, z); \
102 return tmp; \
103 }
104 #else
105
106 uint8_t*
rsOffset(rs_allocation a,uint32_t sizeOf,uint32_t x,uint32_t y,uint32_t z)107 rsOffset(rs_allocation a, uint32_t sizeOf, uint32_t x, uint32_t y,
108 uint32_t z) {
109 Allocation_t *alloc = (Allocation_t *)a.p;
110 //#ifdef __LP64__
111 // uint8_t *p = (uint8_t *)a.r;
112 //#else
113 uint8_t *p = (uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
114 //#endif
115 const uint32_t stride = (uint32_t)alloc->mHal.drvState.lod[0].stride;
116 const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
117 uint8_t *dp = &p[(sizeOf * x) + (y * stride) +
118 (z * stride * dimY)];
119 return dp;
120 }
121
122 uint8_t*
rsOffsetNs(rs_allocation a,uint32_t x,uint32_t y,uint32_t z)123 rsOffsetNs(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) {
124 Allocation_t *alloc = (Allocation_t *)a.p;
125 //#ifdef __LP64__
126 // uint8_t *p = (uint8_t *)a.r;
127 //#else
128 uint8_t *p = (uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
129 //#endif
130 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
131 const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
132 const uint32_t sizeOf = alloc->mHal.state.elementSizeBytes;;
133 uint8_t *dp = &p[(sizeOf * x) + (y * stride) +
134 (z * stride * dimY)];
135 return dp;
136 }
137
138 // The functions rsSetElementAtImpl_T and rsGetElementAtImpl_T are implemented in bitcode
139 // in ll32/allocation.ll and ll64/allocation.ll. To be able to provide debug info for
140 // these functions define them here instead, if we are linking with the debug library.
141 #ifdef RS_G_RUNTIME
142
143 #define SET_ELEMENT_AT_IMPL_TYPE_SIZE(typename, size) \
144 void rsSetElementAtImpl_##typename \
145 (rs_allocation a, typename val, uint32_t x, uint32_t y, uint32_t z) { \
146 typename* val_ptr = (typename*)rsOffset(a, size, x, y, z); \
147 *val_ptr = val; \
148 }
149
150 #define GET_ELEMENT_AT_IMPL_TYPE_SIZE(typename, size) \
151 typename rsGetElementAtImpl_##typename \
152 (rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { \
153 typename *val_ptr = (typename*)rsOffset(a, size, x, y, z); \
154 return *val_ptr; \
155 }
156
157 #define SET_ELEMENT_AT_IMPL_TYPE(typename) \
158 SET_ELEMENT_AT_IMPL_TYPE_SIZE(typename, sizeof(typename)) \
159 SET_ELEMENT_AT_IMPL_TYPE_SIZE(typename##2, sizeof(typename)*2) \
160 SET_ELEMENT_AT_IMPL_TYPE_SIZE(typename##3, sizeof(typename)*4) \
161 SET_ELEMENT_AT_IMPL_TYPE_SIZE(typename##4, sizeof(typename)*4)
162
163 #define GET_ELEMENT_AT_IMPL_TYPE(typename) \
164 GET_ELEMENT_AT_IMPL_TYPE_SIZE(typename, sizeof(typename)) \
165 GET_ELEMENT_AT_IMPL_TYPE_SIZE(typename##2, sizeof(typename)*2) \
166 GET_ELEMENT_AT_IMPL_TYPE_SIZE(typename##3, sizeof(typename)*4) \
167 GET_ELEMENT_AT_IMPL_TYPE_SIZE(typename##4, sizeof(typename)*4)
168
169 #define ELEMENT_AT_IMPL_TYPE(typename) \
170 SET_ELEMENT_AT_IMPL_TYPE(typename) \
171 GET_ELEMENT_AT_IMPL_TYPE(typename)
172
173 ELEMENT_AT_IMPL_TYPE(char)
ELEMENT_AT_IMPL_TYPE(uchar)174 ELEMENT_AT_IMPL_TYPE(uchar)
175 ELEMENT_AT_IMPL_TYPE(short)
176 ELEMENT_AT_IMPL_TYPE(ushort)
177 ELEMENT_AT_IMPL_TYPE(int)
178 ELEMENT_AT_IMPL_TYPE(uint)
179 ELEMENT_AT_IMPL_TYPE(long)
180 ELEMENT_AT_IMPL_TYPE(ulong)
181 ELEMENT_AT_IMPL_TYPE(half)
182 ELEMENT_AT_IMPL_TYPE(float)
183 ELEMENT_AT_IMPL_TYPE(double)
184
185 #undef ELEMENT_AT_IMPL_TYPE
186 #undef GET_ELEMENT_AT_IMPL_TYPE
187 #undef SET_ELEMENT_AT_IMPL_TYPE
188 #undef GET_ELEMENT_AT_IMPL_TYPE_SIZE
189 #undef SET_ELEMENT_AT_IMPL_TYPE_SIZE
190
191 #define SET_ELEMENT_AT_TYPE_IMPL(T, typename) /* nothing */
192 #define GET_ELEMENT_AT_TYPE_IMPL(T, typename) /* nothing */
193
194 #else
195
196 #define SET_ELEMENT_AT_TYPE_IMPL(T, typename) \
197 void \
198 rsSetElementAtImpl_##typename(rs_allocation a, typename val, uint32_t x, \
199 uint32_t y, uint32_t z);
200
201 #define GET_ELEMENT_AT_TYPE_IMPL(T, typename) \
202 typename \
203 rsGetElementAtImpl_##typename(rs_allocation a, uint32_t x, uint32_t y, \
204 uint32_t z);
205
206 #endif //RS_G_RUNTIME
207
208 #define SET_ELEMENT_AT_TYPE_DEF(T, typename) \
209 extern void __attribute__((overloadable)) \
210 rsSetElementAt_##typename(rs_allocation a, T val, uint32_t x) { \
211 rsSetElementAtImpl_##typename(a, (typename)val, x, 0, 0); \
212 } \
213 \
214 extern void __attribute__((overloadable)) \
215 rsSetElementAt_##typename(rs_allocation a, T val, uint32_t x, \
216 uint32_t y) { \
217 rsSetElementAtImpl_##typename(a, (typename)val, x, y, 0); \
218 } \
219 \
220 extern void __attribute__((overloadable)) \
221 rsSetElementAt_##typename(rs_allocation a, T val, uint32_t x, uint32_t y, \
222 uint32_t z) { \
223 rsSetElementAtImpl_##typename(a, (typename)val, x, y, z); \
224 }
225
226 #define GET_ELEMENT_AT_TYPE_DEF(T, typename) \
227 extern typename __attribute__((overloadable)) \
228 rsGetElementAt_##typename(rs_allocation a, uint32_t x) { \
229 return (typename)rsGetElementAtImpl_##typename(a, x, 0, 0); \
230 } \
231 \
232 extern typename __attribute__((overloadable)) \
233 rsGetElementAt_##typename(rs_allocation a, uint32_t x, uint32_t y) { \
234 return (typename)rsGetElementAtImpl_##typename(a, x, y, 0); \
235 } \
236 \
237 extern typename __attribute__((overloadable)) \
238 rsGetElementAt_##typename(rs_allocation a, uint32_t x, uint32_t y, \
239 uint32_t z) { \
240 return (typename)rsGetElementAtImpl_##typename(a, x, y, z); \
241 }
242
243 #define SET_ELEMENT_AT(T) SET_ELEMENT_AT_TYPE_IMPL(T, T) \
244 SET_ELEMENT_AT_TYPE_DEF(T, T)
245 #define GET_ELEMENT_AT(T) GET_ELEMENT_AT_TYPE_IMPL(T, T) \
246 GET_ELEMENT_AT_TYPE_DEF(T, T)
247
248 #define ELEMENT_AT(T) \
249 SET_ELEMENT_AT(T) \
250 GET_ELEMENT_AT(T)
251
252
253 extern const void * __attribute__((overloadable))
254 rsGetElementAt(rs_allocation a, uint32_t x) {
255 Allocation_t *alloc = (Allocation_t *)a.p;
256 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
257 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
258 return &p[eSize * x];
259 }
260
261 extern const void * __attribute__((overloadable))
rsGetElementAt(rs_allocation a,uint32_t x,uint32_t y)262 rsGetElementAt(rs_allocation a, uint32_t x, uint32_t y) {
263 Allocation_t *alloc = (Allocation_t *)a.p;
264 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
265 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
266 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
267 return &p[(eSize * x) + (y * stride)];
268 }
269
270 extern const void * __attribute__((overloadable))
rsGetElementAt(rs_allocation a,uint32_t x,uint32_t y,uint32_t z)271 rsGetElementAt(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) {
272 Allocation_t *alloc = (Allocation_t *)a.p;
273 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
274 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
275 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
276 const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
277 return &p[(eSize * x) + (y * stride) + (z * stride * dimY)];
278 }
279 extern void __attribute__((overloadable))
rsSetElementAt(rs_allocation a,void * ptr,uint32_t x)280 rsSetElementAt(rs_allocation a, void* ptr, uint32_t x) {
281 Allocation_t *alloc = (Allocation_t *)a.p;
282 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
283 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
284 local_memcpy((void*)&p[eSize * x], ptr, eSize);
285 }
286
287 extern void __attribute__((overloadable))
rsSetElementAt(rs_allocation a,void * ptr,uint32_t x,uint32_t y)288 rsSetElementAt(rs_allocation a, void* ptr, uint32_t x, uint32_t y) {
289 Allocation_t *alloc = (Allocation_t *)a.p;
290 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
291 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
292 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
293 local_memcpy((void*)&p[(eSize * x) + (y * stride)], ptr, eSize);
294 }
295
296 extern void __attribute__((overloadable))
rsSetElementAt(rs_allocation a,void * ptr,uint32_t x,uint32_t y,uint32_t z)297 rsSetElementAt(rs_allocation a, void* ptr, uint32_t x, uint32_t y, uint32_t z) {
298 Allocation_t *alloc = (Allocation_t *)a.p;
299 const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
300 const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
301 const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
302 const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
303 local_memcpy((void*)&p[(eSize * x) + (y * stride) + (z * stride * dimY)], ptr, eSize);
304 }
305 #endif // RS_DEBUG_RUNTIME
306
307 ELEMENT_AT(char)
308 ELEMENT_AT(char2)
309 ELEMENT_AT(char3)
310 ELEMENT_AT(char4)
311 ELEMENT_AT(uchar)
312 ELEMENT_AT(uchar2)
313 ELEMENT_AT(uchar3)
314 ELEMENT_AT(uchar4)
315 ELEMENT_AT(short)
316 ELEMENT_AT(short2)
317 ELEMENT_AT(short3)
318 ELEMENT_AT(short4)
319 ELEMENT_AT(ushort)
320 ELEMENT_AT(ushort2)
321 ELEMENT_AT(ushort3)
322 ELEMENT_AT(ushort4)
323 ELEMENT_AT(int)
324 ELEMENT_AT(int2)
325 ELEMENT_AT(int3)
326 ELEMENT_AT(int4)
327 ELEMENT_AT(uint)
328 ELEMENT_AT(uint2)
329 ELEMENT_AT(uint3)
330 ELEMENT_AT(uint4)
331 ELEMENT_AT(long)
332 ELEMENT_AT(long2)
333 ELEMENT_AT(long3)
334 ELEMENT_AT(long4)
335 ELEMENT_AT(ulong)
336 ELEMENT_AT(ulong2)
337 ELEMENT_AT(ulong3)
338 ELEMENT_AT(ulong4)
339 ELEMENT_AT(half)
340 ELEMENT_AT(half2)
341 ELEMENT_AT(half3)
342 ELEMENT_AT(half4)
343 ELEMENT_AT(float)
344 ELEMENT_AT(float2)
345 ELEMENT_AT(float3)
346 ELEMENT_AT(float4)
347 ELEMENT_AT(double)
348 ELEMENT_AT(double2)
349 ELEMENT_AT(double3)
350 ELEMENT_AT(double4)
351
352 typedef unsigned long long ull;
353 typedef unsigned long long ull2 __attribute__((ext_vector_type(2)));
354 typedef unsigned long long ull3 __attribute__((ext_vector_type(3)));
355 typedef unsigned long long ull4 __attribute__((ext_vector_type(4)));
356
357 #ifndef RS_DEBUG_RUNTIME
SET_ELEMENT_AT_TYPE_IMPL(ull,ulong)358 SET_ELEMENT_AT_TYPE_IMPL(ull, ulong)
359 SET_ELEMENT_AT_TYPE_IMPL(ull2, ulong2)
360 SET_ELEMENT_AT_TYPE_IMPL(ull3, ulong3)
361 SET_ELEMENT_AT_TYPE_IMPL(ull4, ulong4)
362
363 #undef SET_ELEMENT_AT_TYPE_DEF
364 #undef GET_ELEMENT_AT_TYPE_DEF
365 #undef SET_ELEMENT_AT_TYPE_IMPL
366 #undef GET_ELEMENT_AT_TYPE_IMPL
367 #undef ELEMENT_AT_TYPE
368 #endif
369
370 #undef ELEMENT_AT
371
372
373 extern uchar __attribute__((overloadable))
374 rsGetElementAtYuv_uchar_Y(rs_allocation a, uint32_t x, uint32_t y) {
375 return rsGetElementAt_uchar(a, x, y);
376 }
377
378 extern uchar __attribute__((overloadable))
rsGetElementAtYuv_uchar_U(rs_allocation a,uint32_t x,uint32_t y)379 rsGetElementAtYuv_uchar_U(rs_allocation a, uint32_t x, uint32_t y) {
380
381 Allocation_t *alloc = (Allocation_t *)a.p;
382
383 const size_t cstep = alloc->mHal.drvState.yuv.step;
384 const size_t shift = alloc->mHal.drvState.yuv.shift;
385 const size_t stride = alloc->mHal.drvState.lod[1].stride;
386
387 const uchar *pin = (const uchar *)alloc->mHal.drvState.lod[1].mallocPtr;
388
389 return pin[((x >> shift) * cstep) + ((y >> shift) * stride)];
390 }
391
392 extern uchar __attribute__((overloadable))
rsGetElementAtYuv_uchar_V(rs_allocation a,uint32_t x,uint32_t y)393 rsGetElementAtYuv_uchar_V(rs_allocation a, uint32_t x, uint32_t y) {
394
395 Allocation_t *alloc = (Allocation_t *)a.p;
396
397 const size_t cstep = alloc->mHal.drvState.yuv.step;
398 const size_t shift = alloc->mHal.drvState.yuv.shift;
399 const size_t stride = alloc->mHal.drvState.lod[2].stride;
400
401 const uchar *pin = (const uchar *)alloc->mHal.drvState.lod[2].mallocPtr;
402
403 return pin[((x >> shift) * cstep) + ((y >> shift) * stride)];
404 }
405
406 // The functions rsAllocationVLoadXImpl_T and rsAllocationVStoreXImpl_T are implemented in
407 // bitcode in ll32/allocation.ll and ll64/allocation.ll. To be able to provide debug info
408 // for these functions define them here instead, if we are linking with the debug library.
409 #ifdef RS_G_RUNTIME
410
411 #define VOP_IMPL(T) \
412 void __rsAllocationVStoreXImpl_##T \
413 (rs_allocation a, const T val, uint32_t x, uint32_t y, uint32_t z) {\
414 T *val_ptr = (T*)rsOffsetNs(a, x, y, z); \
415 local_memcpy(val_ptr, &val, sizeof(T)); \
416 } \
417 T __rsAllocationVLoadXImpl_##T \
418 (rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { \
419 T result = {}; \
420 T* val_ptr = (T*)rsOffsetNs(a, x, y, z); \
421 local_memcpy(&result, val_ptr, sizeof(T)); \
422 return result; \
423 }
424
425 #else
426
427 #define VOP_IMPL(T) \
428 extern void __rsAllocationVStoreXImpl_##T(rs_allocation a, const T val, uint32_t x, uint32_t y, uint32_t z); \
429 extern T __rsAllocationVLoadXImpl_##T(rs_allocation a, uint32_t x, uint32_t y, uint32_t z);
430
431 #endif // RS_G_RUNTIME
432
433 #define VOP_DEF(T) \
434 extern void __attribute__((overloadable)) \
435 rsAllocationVStoreX_##T(rs_allocation a, T val, uint32_t x) { \
436 __rsAllocationVStoreXImpl_##T(a, val, x, 0, 0); \
437 } \
438 extern void __attribute__((overloadable)) \
439 rsAllocationVStoreX_##T(rs_allocation a, T val, uint32_t x, uint32_t y) { \
440 __rsAllocationVStoreXImpl_##T(a, val, x, y, 0); \
441 } \
442 extern void __attribute__((overloadable)) \
443 rsAllocationVStoreX_##T(rs_allocation a, T val, uint32_t x, uint32_t y, uint32_t z) { \
444 __rsAllocationVStoreXImpl_##T(a, val, x, y, z); \
445 } \
446 extern T __attribute__((overloadable)) \
447 rsAllocationVLoadX_##T(rs_allocation a, uint32_t x) { \
448 return __rsAllocationVLoadXImpl_##T(a, x, 0, 0); \
449 } \
450 extern T __attribute__((overloadable)) \
451 rsAllocationVLoadX_##T(rs_allocation a, uint32_t x, uint32_t y) { \
452 return __rsAllocationVLoadXImpl_##T(a, x, y, 0); \
453 } \
454 extern T __attribute__((overloadable)) \
455 rsAllocationVLoadX_##T(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { \
456 return __rsAllocationVLoadXImpl_##T(a, x, y, z); \
457 }
458
459 #define VOP(T) VOP_IMPL(T) \
460 VOP_DEF(T)
461
462 VOP(char2)
463 VOP(char3)
464 VOP(char4)
465 VOP(uchar2)
466 VOP(uchar3)
467 VOP(uchar4)
468 VOP(short2)
469 VOP(short3)
470 VOP(short4)
471 VOP(ushort2)
472 VOP(ushort3)
473 VOP(ushort4)
474 VOP(int2)
475 VOP(int3)
476 VOP(int4)
477 VOP(uint2)
478 VOP(uint3)
479 VOP(uint4)
480 VOP(long2)
481 VOP(long3)
482 VOP(long4)
483 VOP(ulong2)
484 VOP(ulong3)
485 VOP(ulong4)
486 VOP(float2)
487 VOP(float3)
488 VOP(float4)
489 VOP(double2)
490 VOP(double3)
491 VOP(double4)
492
493 #undef VOP_IMPL
494 #undef VOP_DEF
495 #undef VOP
496
497 static const rs_element kInvalidElement = {0};
498
499 extern rs_element __attribute__((overloadable)) rsCreateElement(
500 int32_t dt, int32_t dk, bool isNormalized, uint32_t vecSize);
501
502 extern rs_type __attribute__((overloadable)) rsCreateType(
503 rs_element element, uint32_t dimX, uint32_t dimY, uint32_t dimZ,
504 bool mipmaps, bool faces, rs_yuv_format yuv_format);
505
506 extern rs_allocation __attribute__((overloadable)) rsCreateAllocation(
507 rs_type type, rs_allocation_mipmap_control mipmaps, uint32_t usages,
508 void *ptr);
509
rsCreateElement(rs_data_type data_type)510 rs_element __attribute__((overloadable)) rsCreateElement(
511 rs_data_type data_type) {
512
513 switch (data_type) {
514 case RS_TYPE_BOOLEAN:
515 case RS_TYPE_FLOAT_16:
516 case RS_TYPE_FLOAT_32:
517 case RS_TYPE_FLOAT_64:
518 case RS_TYPE_SIGNED_8:
519 case RS_TYPE_SIGNED_16:
520 case RS_TYPE_SIGNED_32:
521 case RS_TYPE_SIGNED_64:
522 case RS_TYPE_UNSIGNED_8:
523 case RS_TYPE_UNSIGNED_16:
524 case RS_TYPE_UNSIGNED_32:
525 case RS_TYPE_UNSIGNED_64:
526 case RS_TYPE_MATRIX_4X4:
527 case RS_TYPE_MATRIX_3X3:
528 case RS_TYPE_MATRIX_2X2:
529 case RS_TYPE_ELEMENT:
530 case RS_TYPE_TYPE:
531 case RS_TYPE_ALLOCATION:
532 case RS_TYPE_SCRIPT:
533 return rsCreateElement(data_type, RS_KIND_USER, false, 1);
534 default:
535 rsDebug("Invalid data_type", data_type);
536 return kInvalidElement;
537 }
538 }
539
rsCreateVectorElement(rs_data_type data_type,uint32_t vector_width)540 rs_element __attribute__((overloadable)) rsCreateVectorElement(
541 rs_data_type data_type, uint32_t vector_width) {
542 if (vector_width < 2 || vector_width > 4) {
543 rsDebug("Invalid vector_width", vector_width);
544 return kInvalidElement;
545 }
546 switch (data_type) {
547 case RS_TYPE_BOOLEAN:
548 case RS_TYPE_FLOAT_16:
549 case RS_TYPE_FLOAT_32:
550 case RS_TYPE_FLOAT_64:
551 case RS_TYPE_SIGNED_8:
552 case RS_TYPE_SIGNED_16:
553 case RS_TYPE_SIGNED_32:
554 case RS_TYPE_SIGNED_64:
555 case RS_TYPE_UNSIGNED_8:
556 case RS_TYPE_UNSIGNED_16:
557 case RS_TYPE_UNSIGNED_32:
558 case RS_TYPE_UNSIGNED_64:
559 return rsCreateElement(data_type, RS_KIND_USER, false,
560 vector_width);
561 default:
562 rsDebug("Invalid data_type for vector element", data_type);
563 return kInvalidElement;
564 }
565 }
566
rsCreatePixelElement(rs_data_type data_type,rs_data_kind data_kind)567 rs_element __attribute__((overloadable)) rsCreatePixelElement(
568 rs_data_type data_type, rs_data_kind data_kind) {
569 if (data_type != RS_TYPE_UNSIGNED_8 &&
570 data_type != RS_TYPE_UNSIGNED_16 &&
571 data_type != RS_TYPE_UNSIGNED_5_6_5 &&
572 data_type != RS_TYPE_UNSIGNED_4_4_4_4 &&
573 data_type != RS_TYPE_UNSIGNED_5_5_5_1) {
574
575 rsDebug("Invalid data_type for pixel element", data_type);
576 return kInvalidElement;
577 }
578 if (data_kind != RS_KIND_PIXEL_L &&
579 data_kind != RS_KIND_PIXEL_A &&
580 data_kind != RS_KIND_PIXEL_LA &&
581 data_kind != RS_KIND_PIXEL_RGB &&
582 data_kind != RS_KIND_PIXEL_RGBA &&
583 data_kind != RS_KIND_PIXEL_DEPTH &&
584 data_kind != RS_KIND_PIXEL_YUV) {
585
586 rsDebug("Invalid data_kind for pixel element", data_type);
587 return kInvalidElement;
588 }
589 if (data_type == RS_TYPE_UNSIGNED_5_6_5 && data_kind != RS_KIND_PIXEL_RGB) {
590 rsDebug("Bad data_type and data_kind combo", data_type, data_kind);
591 return kInvalidElement;
592 }
593 if (data_type == RS_TYPE_UNSIGNED_5_5_5_1 &&
594 data_kind != RS_KIND_PIXEL_RGBA) {
595
596 rsDebug("Bad data_type and data_kind combo", data_type, data_kind);
597 return kInvalidElement;
598 }
599 if (data_type == RS_TYPE_UNSIGNED_4_4_4_4 &&
600 data_kind != RS_KIND_PIXEL_RGBA) {
601
602 rsDebug("Bad data_type and data_kind combo", data_type, data_kind);
603 return kInvalidElement;
604 }
605 if (data_type == RS_TYPE_UNSIGNED_16 && data_kind != RS_KIND_PIXEL_DEPTH) {
606 rsDebug("Bad data_type and data_kind combo", data_type, data_kind);
607 return kInvalidElement;
608 }
609
610 int vector_width = 1;
611 switch (data_kind) {
612 case RS_KIND_PIXEL_LA:
613 vector_width = 2;
614 break;
615 case RS_KIND_PIXEL_RGB:
616 vector_width = 3;
617 break;
618 case RS_KIND_PIXEL_RGBA:
619 vector_width = 4;
620 break;
621 case RS_KIND_PIXEL_DEPTH:
622 vector_width = 2;
623 break;
624 default:
625 break;
626 }
627
628 return rsCreateElement(data_type, data_kind, true, vector_width);
629 }
630
rsCreateType(rs_element element,uint32_t dimX,uint32_t dimY,uint32_t dimZ)631 rs_type __attribute__((overloadable)) rsCreateType(rs_element element,
632 uint32_t dimX, uint32_t dimY,
633 uint32_t dimZ) {
634 return rsCreateType(element, dimX, dimY, dimZ, false, false, RS_YUV_NONE);
635 }
636
rsCreateType(rs_element element,uint32_t dimX,uint32_t dimY)637 rs_type __attribute__((overloadable)) rsCreateType(rs_element element,
638 uint32_t dimX,
639 uint32_t dimY) {
640 return rsCreateType(element, dimX, dimY, 0, false, false, RS_YUV_NONE);
641 }
642
rsCreateType(rs_element element,uint32_t dimX)643 rs_type __attribute__((overloadable)) rsCreateType(rs_element element,
644 uint32_t dimX) {
645 return rsCreateType(element, dimX, 0, 0, false, false, RS_YUV_NONE);
646 }
647
rsCreateAllocation(rs_type type,uint32_t usage)648 rs_allocation __attribute__((overloadable)) rsCreateAllocation(rs_type type,
649 uint32_t usage) {
650 return rsCreateAllocation(type, RS_ALLOCATION_MIPMAP_NONE, usage, NULL);
651 }
652
rsCreateAllocation(rs_type type)653 rs_allocation __attribute__((overloadable)) rsCreateAllocation(rs_type type) {
654 return rsCreateAllocation(type, RS_ALLOCATION_MIPMAP_NONE,
655 RS_ALLOCATION_USAGE_SCRIPT, NULL);
656 }
657