rs_allocation.c revision 1aa9dfc002f6b763d34d75d9f47abb4aa70584a2 
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    //#ifdef __LP64__
108    //    uint8_t *p = (uint8_t *)a.r;
109    //#else
110    uint8_t *p = (uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
111    //#endif
112    const uint32_t stride = (uint32_t)alloc->mHal.drvState.lod[0].stride;
113    const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
114    uint8_t *dp = &p[(sizeOf * x) + (y * stride) +
115                     (z * stride * dimY)];
116    return dp;
117}
118
119uint8_t*
120rsOffsetNs(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) {
121    Allocation_t *alloc = (Allocation_t *)a.p;
122#ifdef __LP64__
123    uint8_t *p = (uint8_t *)a.r;
124#else
125    uint8_t *p = (uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
126#endif
127    const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
128    const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
129    const uint32_t sizeOf = alloc->mHal.state.elementSizeBytes;;
130    uint8_t *dp = &p[(sizeOf * x) + (y * stride) +
131                     (z * stride * dimY)];
132    return dp;
133}
134
135#define ELEMENT_AT(T)                                                   \
136                                                                        \
137    void                                                                \
138    rsSetElementAtImpl_##T(rs_allocation a, T val, uint32_t x,          \
139                           uint32_t y, uint32_t z);                     \
140                                                                        \
141    extern void __attribute__((overloadable))                           \
142    rsSetElementAt_##T(rs_allocation a, T val, uint32_t x) {            \
143        rsSetElementAtImpl_##T(a, val, x, 0, 0);                        \
144    }                                                                   \
145                                                                        \
146    extern void __attribute__((overloadable))                           \
147    rsSetElementAt_##T(rs_allocation a, T val, uint32_t x,              \
148                       uint32_t y) {                                    \
149        rsSetElementAtImpl_##T(a, val, x, y, 0);                        \
150    }                                                                   \
151                                                                        \
152    extern void __attribute__((overloadable))                           \
153    rsSetElementAt_##T(rs_allocation a, T val, uint32_t x, uint32_t y,  \
154                       uint32_t z) {                                    \
155        rsSetElementAtImpl_##T(a, val, x, y, z);                        \
156    }                                                                   \
157                                                                        \
158    T                                                                   \
159    rsGetElementAtImpl_##T(rs_allocation a, uint32_t x, uint32_t y,     \
160                       uint32_t z);                                     \
161                                                                        \
162    extern T __attribute__((overloadable))                              \
163    rsGetElementAt_##T(rs_allocation a, uint32_t x) {                   \
164        return rsGetElementAtImpl_##T(a, x, 0, 0);                      \
165    }                                                                   \
166                                                                        \
167    extern T __attribute__((overloadable))                              \
168    rsGetElementAt_##T(rs_allocation a, uint32_t x, uint32_t y) {       \
169        return rsGetElementAtImpl_##T(a, x, y, 0);                      \
170    }                                                                   \
171                                                                        \
172    extern T __attribute__((overloadable))                              \
173    rsGetElementAt_##T(rs_allocation a, uint32_t x, uint32_t y,         \
174                       uint32_t z) {                                    \
175        return rsGetElementAtImpl_##T(a, x, y, z);                      \
176    }
177
178
179
180extern const void * __attribute__((overloadable))
181        rsGetElementAt(rs_allocation a, uint32_t x) {
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    return &p[eSize * x];
186}
187
188extern const void * __attribute__((overloadable))
189        rsGetElementAt(rs_allocation a, uint32_t x, uint32_t y) {
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    const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
194    return &p[(eSize * x) + (y * stride)];
195}
196
197extern const void * __attribute__((overloadable))
198        rsGetElementAt(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) {
199    Allocation_t *alloc = (Allocation_t *)a.p;
200    const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
201    const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
202    const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
203    const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
204    return &p[(eSize * x) + (y * stride) + (z * stride * dimY)];
205}
206extern void __attribute__((overloadable))
207        rsSetElementAt(rs_allocation a, void* ptr, uint32_t x) {
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    memcpy((void*)&p[eSize * x], ptr, eSize);
212}
213
214extern void __attribute__((overloadable))
215        rsSetElementAt(rs_allocation a, void* ptr, uint32_t x, uint32_t y) {
216    Allocation_t *alloc = (Allocation_t *)a.p;
217    const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
218    const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
219    const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
220    memcpy((void*)&p[(eSize * x) + (y * stride)], ptr, eSize);
221}
222
223extern void __attribute__((overloadable))
224        rsSetElementAt(rs_allocation a, void* ptr, uint32_t x, uint32_t y, uint32_t z) {
225    Allocation_t *alloc = (Allocation_t *)a.p;
226    const uint8_t *p = (const uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr;
227    const uint32_t eSize = alloc->mHal.state.elementSizeBytes;
228    const uint32_t stride = alloc->mHal.drvState.lod[0].stride;
229    const uint32_t dimY = alloc->mHal.drvState.lod[0].dimY;
230    memcpy((void*)&p[(eSize * x) + (y * stride) + (z * stride * dimY)], ptr, eSize);
231}
232#endif
233
234ELEMENT_AT(char)
235ELEMENT_AT(char2)
236ELEMENT_AT(char3)
237ELEMENT_AT(char4)
238ELEMENT_AT(uchar)
239ELEMENT_AT(uchar2)
240ELEMENT_AT(uchar3)
241ELEMENT_AT(uchar4)
242ELEMENT_AT(short)
243ELEMENT_AT(short2)
244ELEMENT_AT(short3)
245ELEMENT_AT(short4)
246ELEMENT_AT(ushort)
247ELEMENT_AT(ushort2)
248ELEMENT_AT(ushort3)
249ELEMENT_AT(ushort4)
250ELEMENT_AT(int)
251ELEMENT_AT(int2)
252ELEMENT_AT(int3)
253ELEMENT_AT(int4)
254ELEMENT_AT(uint)
255ELEMENT_AT(uint2)
256ELEMENT_AT(uint3)
257ELEMENT_AT(uint4)
258ELEMENT_AT(long)
259ELEMENT_AT(long2)
260ELEMENT_AT(long3)
261ELEMENT_AT(long4)
262ELEMENT_AT(ulong)
263ELEMENT_AT(ulong2)
264ELEMENT_AT(ulong3)
265ELEMENT_AT(ulong4)
266ELEMENT_AT(float)
267ELEMENT_AT(float2)
268ELEMENT_AT(float3)
269ELEMENT_AT(float4)
270ELEMENT_AT(double)
271ELEMENT_AT(double2)
272ELEMENT_AT(double3)
273ELEMENT_AT(double4)
274
275#undef ELEMENT_AT
276
277
278extern const uchar __attribute__((overloadable))
279        rsGetElementAtYuv_uchar_Y(rs_allocation a, uint32_t x, uint32_t y) {
280    return rsGetElementAt_uchar(a, x, y);
281}
282
283extern const uchar __attribute__((overloadable))
284        rsGetElementAtYuv_uchar_U(rs_allocation a, uint32_t x, uint32_t y) {
285
286    Allocation_t *alloc = (Allocation_t *)a.p;
287
288    const size_t cstep = alloc->mHal.drvState.yuv.step;
289    const size_t shift = alloc->mHal.drvState.yuv.shift;
290    const size_t stride = alloc->mHal.drvState.lod[1].stride;
291
292    const uchar *pin = (const uchar *)alloc->mHal.drvState.lod[1].mallocPtr;
293
294    return pin[((x >> shift) * cstep) + ((y >> shift) * stride)];
295}
296
297extern const uchar __attribute__((overloadable))
298        rsGetElementAtYuv_uchar_V(rs_allocation a, uint32_t x, uint32_t y) {
299
300    Allocation_t *alloc = (Allocation_t *)a.p;
301
302    const size_t cstep = alloc->mHal.drvState.yuv.step;
303    const size_t shift = alloc->mHal.drvState.yuv.shift;
304    const size_t stride = alloc->mHal.drvState.lod[2].stride;
305
306    const uchar *pin = (const uchar *)alloc->mHal.drvState.lod[2].mallocPtr;
307
308    return pin[((x >> shift) * cstep) + ((y >> shift) * stride)];
309}
310
311
312#define VOP(T)                                                          \
313    extern void __rsAllocationVStoreXImpl_##T(rs_allocation a, const T val, uint32_t x, uint32_t y, uint32_t z); \
314    extern T __rsAllocationVLoadXImpl_##T(rs_allocation a, uint32_t x, uint32_t y, uint32_t z); \
315                                                                        \
316    extern void __attribute__((overloadable))                           \
317    rsAllocationVStoreX_##T(rs_allocation a, T val, uint32_t x) {       \
318        __rsAllocationVStoreXImpl_##T(a, val, x, 0, 0);                 \
319    }                                                                   \
320    extern void __attribute__((overloadable))                           \
321    rsAllocationVStoreX_##T(rs_allocation a, T val, uint32_t x, uint32_t y) { \
322        __rsAllocationVStoreXImpl_##T(a, val, x, y, 0);                 \
323    }                                                                   \
324    extern void __attribute__((overloadable))                           \
325    rsAllocationVStoreX_##T(rs_allocation a, T val, uint32_t x, uint32_t y, uint32_t z) { \
326        __rsAllocationVStoreXImpl_##T(a, val, x, y, z);                 \
327    }                                                                   \
328    extern T __attribute__((overloadable))                              \
329    rsAllocationVLoadX_##T(rs_allocation a, uint32_t x) {               \
330        return __rsAllocationVLoadXImpl_##T(a, x, 0, 0);                \
331    }                                                                   \
332    extern T __attribute__((overloadable))                              \
333    rsAllocationVLoadX_##T(rs_allocation a, uint32_t x, uint32_t y) {   \
334        return __rsAllocationVLoadXImpl_##T(a, x, y, 0);                \
335    }                                                                   \
336    extern T __attribute__((overloadable))                              \
337    rsAllocationVLoadX_##T(rs_allocation a, uint32_t x, uint32_t y, uint32_t z) { \
338        return __rsAllocationVLoadXImpl_##T(a, x, y, z);                \
339    }
340
341VOP(char2)
342VOP(char3)
343VOP(char4)
344VOP(uchar2)
345VOP(uchar3)
346VOP(uchar4)
347VOP(short2)
348VOP(short3)
349VOP(short4)
350VOP(ushort2)
351VOP(ushort3)
352VOP(ushort4)
353VOP(int2)
354VOP(int3)
355VOP(int4)
356VOP(uint2)
357VOP(uint3)
358VOP(uint4)
359VOP(long2)
360VOP(long3)
361VOP(long4)
362VOP(ulong2)
363VOP(ulong3)
364VOP(ulong4)
365VOP(float2)
366VOP(float3)
367VOP(float4)
368VOP(double2)
369VOP(double3)
370VOP(double4)
371
372#undef VOP
373