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