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