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