Element.cpp revision dfcfabfccad8a8f2f42f83081638c7e5c9bfb4b9 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <malloc.h>
18#include <string.h>
19
20#include "RenderScript.h"
21#include "rsCppInternal.h"
22
23using android::RSC::Element;
24
25android::RSC::sp<const Element> Element::getSubElement(uint32_t index) {
26    if (!mVisibleElementMapSize) {
27        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements");
28        return nullptr;
29    }
30    if (index >= mVisibleElementMapSize) {
31        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index");
32        return nullptr;
33    }
34    return mElements[mVisibleElementMap[index]];
35}
36
37const char * Element::getSubElementName(uint32_t index) {
38    if (!mVisibleElementMapSize) {
39        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements");
40        return nullptr;
41    }
42    if (index >= mVisibleElementMapSize) {
43        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index");
44        return nullptr;
45    }
46    return mElementNames[mVisibleElementMap[index]];
47}
48
49size_t Element::getSubElementArraySize(uint32_t index) {
50    if (!mVisibleElementMapSize) {
51        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements");
52        return 0;
53    }
54    if (index >= mVisibleElementMapSize) {
55        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index");
56        return 0;
57    }
58    return mArraySizes[mVisibleElementMap[index]];
59}
60
61uint32_t Element::getSubElementOffsetBytes(uint32_t index) {
62    if (!mVisibleElementMapSize) {
63        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements");
64        return 0;
65    }
66    if (index >= mVisibleElementMapSize) {
67        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index");
68        return 0;
69    }
70    return mOffsetInBytes[mVisibleElementMap[index]];
71}
72
73
74#define CREATE_USER(N, T) android::RSC::sp<const Element> Element::N(const android::RSC::sp<RS>& rs) { \
75    if (rs->mElements.N == nullptr) {                               \
76        rs->mElements.N = (createUser(rs, RS_TYPE_##T));            \
77    }                                                               \
78    return rs->mElements.N;                                         \
79    }
80
81CREATE_USER(BOOLEAN, BOOLEAN);
82CREATE_USER(U8, UNSIGNED_8);
83CREATE_USER(I8, SIGNED_8);
84CREATE_USER(U16, UNSIGNED_16);
85CREATE_USER(I16, SIGNED_16);
86CREATE_USER(U32, UNSIGNED_32);
87CREATE_USER(I32, SIGNED_32);
88CREATE_USER(U64, UNSIGNED_64);
89CREATE_USER(I64, SIGNED_64);
90CREATE_USER(F16, FLOAT_16);
91CREATE_USER(F32, FLOAT_32);
92CREATE_USER(F64, FLOAT_64);
93CREATE_USER(ELEMENT, ELEMENT);
94CREATE_USER(TYPE, TYPE);
95CREATE_USER(ALLOCATION, ALLOCATION);
96CREATE_USER(SAMPLER, SAMPLER);
97CREATE_USER(SCRIPT, SCRIPT);
98CREATE_USER(MATRIX_4X4, MATRIX_4X4);
99CREATE_USER(MATRIX_3X3, MATRIX_3X3);
100CREATE_USER(MATRIX_2X2, MATRIX_2X2);
101
102#define CREATE_PIXEL(N, T, K) android::RSC::sp<const Element> Element::N(const android::RSC::sp<RS> &rs) { \
103    if (rs->mElements.N == nullptr) {                                \
104        rs->mElements.N = createPixel(rs, RS_TYPE_##T, RS_KIND_##K); \
105    }                                                                \
106    return rs->mElements.N;                                          \
107}
108
109CREATE_PIXEL(A_8, UNSIGNED_8, PIXEL_A);
110CREATE_PIXEL(RGB_565, UNSIGNED_5_6_5, PIXEL_RGB);
111CREATE_PIXEL(RGB_888, UNSIGNED_8, PIXEL_RGB);
112CREATE_PIXEL(RGBA_4444, UNSIGNED_4_4_4_4, PIXEL_RGBA);
113CREATE_PIXEL(RGBA_8888, UNSIGNED_8, PIXEL_RGBA);
114CREATE_PIXEL(YUV, UNSIGNED_8, PIXEL_YUV);
115CREATE_PIXEL(RGBA_5551, UNSIGNED_5_5_5_1, PIXEL_RGBA);
116
117#define CREATE_VECTOR(N, T) android::RSC::sp<const Element> Element::N##_2(const android::RSC::sp<RS> &rs) { \
118    if (rs->mElements.N##_2 == nullptr) {                                 \
119        rs->mElements.N##_2 = createVector(rs, RS_TYPE_##T, 2);           \
120    }                                                                     \
121    return rs->mElements.N##_2;                                           \
122}                                                                         \
123android::RSC::sp<const Element> Element::N##_3(const android::RSC::sp<RS> &rs) { \
124    if (rs->mElements.N##_3 == nullptr) {                                 \
125        rs->mElements.N##_3 = createVector(rs, RS_TYPE_##T, 3);           \
126    }                                                                     \
127    return rs->mElements.N##_3;                                           \
128} \
129android::RSC::sp<const Element> Element::N##_4(const android::RSC::sp<RS> &rs) { \
130    if (rs->mElements.N##_4 == nullptr) {                                 \
131        rs->mElements.N##_4 = createVector(rs, RS_TYPE_##T, 4);           \
132    }                                                                     \
133    return rs->mElements.N##_4;                                           \
134}
135CREATE_VECTOR(U8, UNSIGNED_8);
136CREATE_VECTOR(I8, SIGNED_8);
137CREATE_VECTOR(U16, UNSIGNED_16);
138CREATE_VECTOR(I16, SIGNED_16);
139CREATE_VECTOR(U32, UNSIGNED_32);
140CREATE_VECTOR(I32, SIGNED_32);
141CREATE_VECTOR(U64, UNSIGNED_64);
142CREATE_VECTOR(I64, SIGNED_64);
143CREATE_VECTOR(F16, FLOAT_16);
144CREATE_VECTOR(F32, FLOAT_32);
145CREATE_VECTOR(F64, FLOAT_64);
146
147
148void Element::updateVisibleSubElements() {
149    if (!mElementsCount) {
150        return;
151    }
152    if (mVisibleElementMapSize) {
153        free(mVisibleElementMap);
154        mVisibleElementMapSize = 0;
155    }
156    mVisibleElementMap = (uint32_t*)calloc(mElementsCount, sizeof(uint32_t));
157
158    int noPaddingFieldCount = 0;
159    size_t fieldCount = mElementsCount;
160    // Find out how many elements are not padding.
161    for (size_t ct = 0; ct < fieldCount; ct ++) {
162        if (mElementNames[ct][0] != '#') {
163            noPaddingFieldCount ++;
164        }
165    }
166
167    // Make a map that points us at non-padding elements.
168    size_t i = 0;
169    for (size_t ct = 0; ct < fieldCount; ct ++) {
170        if (mElementNames[ct][0] != '#') {
171            mVisibleElementMap[i++] = (uint32_t)ct;
172        }
173    }
174    mVisibleElementMapSize = i;
175}
176
177Element::Element(void *id, android::RSC::sp<RS> rs,
178                 android::RSC::sp<const Element> * elements,
179                 size_t elementCount,
180                 const char ** elementNames,
181                 size_t * elementNameLengths,
182                 uint32_t * arraySizes) : BaseObj(id, rs) {
183    mSizeBytes = 0;
184    mVectorSize = 1;
185    mElementsCount = elementCount;
186    mVisibleElementMap = nullptr;
187    mVisibleElementMapSize = 0;
188
189    mElements = (android::RSC::sp<const Element> *)calloc(mElementsCount, sizeof(android::RSC::sp<Element>));
190    mElementNames = (char **)calloc(mElementsCount, sizeof(char *));
191    mElementNameLengths = (size_t*)calloc(mElementsCount, sizeof(size_t));
192    mArraySizes = (uint32_t*)calloc(mElementsCount, sizeof(uint32_t));
193    mOffsetInBytes = (uint32_t*)calloc(mElementsCount, sizeof(uint32_t));
194
195    memcpy(mElements, elements, mElementsCount * sizeof(android::RSC::sp<Element>));
196    memcpy(mArraySizes, arraySizes, mElementsCount * sizeof(uint32_t));
197
198    // Copy strings (char array).
199    memcpy(mElementNameLengths, elementNameLengths, mElementsCount * sizeof(size_t));
200    for (size_t ct = 0; ct < mElementsCount; ct++ ) {
201        size_t elemNameLen = mElementNameLengths[ct];
202        mElementNames[ct] = (char *)calloc(elemNameLen, sizeof(char));
203        memcpy(mElementNames[ct], elementNames[ct], elemNameLen);
204    }
205
206    mType = RS_TYPE_NONE;
207    mKind = RS_KIND_USER;
208
209    for (size_t ct = 0; ct < mElementsCount; ct++ ) {
210        mOffsetInBytes[ct] = mSizeBytes;
211        mSizeBytes += mElements[ct]->mSizeBytes * mArraySizes[ct];
212    }
213    updateVisibleSubElements();
214}
215
216Element::Element(void *id, android::RSC::sp<RS> rs) :
217    BaseObj(id, rs) {
218}
219
220static uint32_t GetSizeInBytesForType(RsDataType dt) {
221    switch(dt) {
222    case RS_TYPE_NONE:
223        return 0;
224    case RS_TYPE_SIGNED_8:
225    case RS_TYPE_UNSIGNED_8:
226    case RS_TYPE_BOOLEAN:
227        return 1;
228
229    case RS_TYPE_FLOAT_16:
230    case RS_TYPE_SIGNED_16:
231    case RS_TYPE_UNSIGNED_16:
232    case RS_TYPE_UNSIGNED_5_6_5:
233    case RS_TYPE_UNSIGNED_5_5_5_1:
234    case RS_TYPE_UNSIGNED_4_4_4_4:
235        return 2;
236
237    case RS_TYPE_FLOAT_32:
238    case RS_TYPE_SIGNED_32:
239    case RS_TYPE_UNSIGNED_32:
240        return 4;
241
242    case RS_TYPE_FLOAT_64:
243    case RS_TYPE_SIGNED_64:
244    case RS_TYPE_UNSIGNED_64:
245        return 8;
246
247    case RS_TYPE_MATRIX_4X4:
248        return 16 * 4;
249    case RS_TYPE_MATRIX_3X3:
250        return 9 * 4;
251    case RS_TYPE_MATRIX_2X2:
252        return 4 * 4;
253
254    case RS_TYPE_TYPE:
255    case RS_TYPE_ALLOCATION:
256    case RS_TYPE_SAMPLER:
257    case RS_TYPE_SCRIPT:
258    case RS_TYPE_MESH:
259    case RS_TYPE_PROGRAM_FRAGMENT:
260    case RS_TYPE_PROGRAM_VERTEX:
261    case RS_TYPE_PROGRAM_RASTER:
262    case RS_TYPE_PROGRAM_STORE:
263        return 4;
264
265    default:
266        break;
267    }
268
269    ALOGE("Missing type %i", dt);
270    return 0;
271}
272
273Element::Element(void *id, android::RSC::sp<RS> rs,
274                 RsDataType dt, RsDataKind dk, bool norm, uint32_t size) :
275    BaseObj(id, rs)
276{
277    uint32_t tsize = GetSizeInBytesForType(dt);
278    if ((dt != RS_TYPE_UNSIGNED_5_6_5) &&
279        (dt != RS_TYPE_UNSIGNED_4_4_4_4) &&
280        (dt != RS_TYPE_UNSIGNED_5_5_5_1)) {
281        if (size == 3) {
282            mSizeBytes = tsize * 4;
283        } else {
284            mSizeBytes = tsize * size;
285        }
286    } else {
287        mSizeBytes = tsize;
288    }
289    mType = dt;
290    mKind = dk;
291    mNormalized = norm;
292    mVectorSize = size;
293    mElementsCount = 0;
294    mVisibleElementMap = 0;
295}
296
297Element::~Element() {
298    if (mElementsCount) {
299        free(mElements);
300        for (size_t ct = 0; ct < mElementsCount; ct++ ) {
301            free(mElementNames[ct]);
302        }
303        free(mElementNames);
304        free(mElementNameLengths);
305        free(mArraySizes);
306        free(mOffsetInBytes);
307    }
308    if (mVisibleElementMapSize) {
309        free(mVisibleElementMap);
310    }
311}
312
313void Element::updateFromNative() {
314    BaseObj::updateFromNative();
315    updateVisibleSubElements();
316}
317
318android::RSC::sp<const Element> Element::createUser(const android::RSC::sp<RS>& rs, RsDataType dt) {
319    void * id = RS::dispatch->ElementCreate(rs->getContext(), dt, RS_KIND_USER, false, 1);
320    return new Element(id, rs, dt, RS_KIND_USER, false, 1);
321}
322
323android::RSC::sp<const Element> Element::createVector(const android::RSC::sp<RS>& rs, RsDataType dt, uint32_t size) {
324    if (size < 2 || size > 4) {
325        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Vector size out of range 2-4.");
326        return nullptr;
327    }
328    void *id = RS::dispatch->ElementCreate(rs->getContext(), dt, RS_KIND_USER, false, size);
329    return new Element(id, rs, dt, RS_KIND_USER, false, size);
330}
331
332android::RSC::sp<const Element> Element::createPixel(const android::RSC::sp<RS>& rs, RsDataType dt, RsDataKind dk) {
333    if (!(dk == RS_KIND_PIXEL_L ||
334          dk == RS_KIND_PIXEL_A ||
335          dk == RS_KIND_PIXEL_LA ||
336          dk == RS_KIND_PIXEL_RGB ||
337          dk == RS_KIND_PIXEL_RGBA ||
338          dk == RS_KIND_PIXEL_DEPTH ||
339          dk == RS_KIND_PIXEL_YUV)) {
340        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Unsupported DataKind");
341        return nullptr;
342    }
343    if (!(dt == RS_TYPE_UNSIGNED_8 ||
344          dt == RS_TYPE_UNSIGNED_16 ||
345          dt == RS_TYPE_UNSIGNED_5_6_5 ||
346          dt == RS_TYPE_UNSIGNED_4_4_4_4 ||
347          dt == RS_TYPE_UNSIGNED_5_5_5_1)) {
348        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Unsupported DataType");
349        return nullptr;
350    }
351    if (dt == RS_TYPE_UNSIGNED_5_6_5 && dk != RS_KIND_PIXEL_RGB) {
352        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo");
353        return nullptr;
354    }
355    if (dt == RS_TYPE_UNSIGNED_5_5_5_1 && dk != RS_KIND_PIXEL_RGBA) {
356        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo");
357        return nullptr;
358    }
359    if (dt == RS_TYPE_UNSIGNED_4_4_4_4 && dk != RS_KIND_PIXEL_RGBA) {
360        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo");
361        return nullptr;
362    }
363    if (dt == RS_TYPE_UNSIGNED_16 && dk != RS_KIND_PIXEL_DEPTH) {
364        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo");
365        return nullptr;
366    }
367
368    int size = 1;
369    switch (dk) {
370    case RS_KIND_PIXEL_LA:
371        size = 2;
372        break;
373    case RS_KIND_PIXEL_RGB:
374        size = 3;
375        break;
376    case RS_KIND_PIXEL_RGBA:
377        size = 4;
378        break;
379    case RS_KIND_PIXEL_DEPTH:
380        size = 2;
381        break;
382    default:
383        break;
384    }
385
386    void * id = RS::dispatch->ElementCreate(rs->getContext(), dt, dk, true, size);
387    return new Element(id, rs, dt, dk, true, size);
388}
389
390bool Element::isCompatible(const android::RSC::sp<const Element>&e) const {
391    // Try strict BaseObj equality to start with.
392    if (this == e.get()) {
393        return true;
394    }
395
396    /*
397     * Ignore mKind because it is allowed to be different (user vs. pixel).
398     * We also ignore mNormalized because it can be different. The mType
399     * field must be non-null since we require name equivalence for
400     * user-created Elements.
401     */
402    return ((mSizeBytes == e->mSizeBytes) &&
403            (mType != RS_TYPE_NONE) &&
404            (mType == e->mType) &&
405            (mVectorSize == e->mVectorSize));
406}
407
408Element::Builder::Builder(android::RSC::sp<RS> rs) {
409    mRS = rs.get();
410    mSkipPadding = false;
411    mElementsVecSize = 8;
412    mElementsCount = 0;
413    // Initialize space.
414    mElements = (android::RSC::sp<const Element> *)calloc(mElementsVecSize, sizeof(android::RSC::sp<Element>));
415    mElementNames = (char **)calloc(mElementsVecSize, sizeof(char *));
416    mElementNameLengths = (size_t*)calloc(mElementsVecSize, sizeof(size_t));
417    mArraySizes = (uint32_t*)calloc(mElementsVecSize, sizeof(uint32_t));
418}
419
420Element::Builder::~Builder() {
421    // Free allocated space.
422    free(mElements);
423    for (size_t ct = 0; ct < mElementsCount; ct++ ) {
424        free(mElementNames[ct]);
425    }
426    free(mElementNameLengths);
427    free(mElementNames);
428    free(mArraySizes);
429}
430
431void Element::Builder::add(const android::RSC::sp<const Element>&e, const char * name, uint32_t arraySize) {
432    // Skip padding fields after a vector 3 type.
433    if (mSkipPadding) {
434        const char *s1 = "#padding_";
435        const char *s2 = name;
436        size_t len = strlen(s1);
437        if (strlen(s2) >= len) {
438            if (!memcmp(s1, s2, len)) {
439                mSkipPadding = false;
440                return;
441            }
442        }
443    }
444
445    if (e->mVectorSize == 3) {
446        mSkipPadding = true;
447    } else {
448        mSkipPadding = false;
449    }
450
451    if (mElementsCount >= mElementsVecSize) {
452        // If pre-allocated space is full, allocate a larger one.
453        mElementsVecSize += 8;
454
455        android::RSC::sp<const Element> * newElements = (android::RSC::sp<const Element> *)calloc(mElementsVecSize, sizeof(android::RSC::sp<Element>));
456        char ** newElementNames = (char **)calloc(mElementsVecSize, sizeof(char *));
457        size_t * newElementNameLengths = (size_t*)calloc(mElementsVecSize, sizeof(size_t));
458        uint32_t * newArraySizes = (uint32_t*)calloc(mElementsVecSize, sizeof(uint32_t));
459
460        memcpy(newElements, mElements, mElementsCount * sizeof(android::RSC::sp<Element>));
461        memcpy(newElementNames, mElementNames, mElementsCount * sizeof(char *));
462        memcpy(newElementNameLengths, mElementNameLengths, mElementsCount * sizeof(size_t));
463        memcpy(newArraySizes, mArraySizes, mElementsCount * sizeof(uint32_t));
464
465        // Free the old arrays.
466        free(mElements);
467        free(mElementNames);
468        free(mArraySizes);
469        free(mElementNameLengths);
470
471        mElements = newElements;
472        mElementNames = newElementNames;
473        mArraySizes = newArraySizes;
474        mElementNameLengths = newElementNameLengths;
475    }
476    mElements[mElementsCount] = e;
477    mArraySizes[mElementsCount] = arraySize;
478
479    size_t nameLen = strlen(name);
480    mElementNameLengths[mElementsCount] = nameLen + 1;
481    mElementNames[mElementsCount] = (char *)calloc(nameLen + 1, sizeof(char));
482    memcpy(mElementNames[mElementsCount], name, nameLen);
483    mElementNames[mElementsCount][nameLen] = 0;
484
485    mElementsCount++;
486}
487
488android::RSC::sp<const Element> Element::Builder::create() {
489    size_t fieldCount = mElementsCount;
490    void ** elementArray = (void **)calloc(fieldCount, sizeof(void *));
491
492    for (size_t ct = 0; ct < fieldCount; ct++) {
493        elementArray[ct] = mElements[ct]->getID();
494    }
495
496    void *id = RS::dispatch->ElementCreate2(mRS->getContext(),
497                                            (RsElement *)elementArray, fieldCount,
498                                            (const char **)mElementNames, fieldCount, mElementNameLengths,
499                                            mArraySizes, fieldCount);
500    free(elementArray);
501    return new Element(id, mRS, mElements, mElementsCount, (const char **)mElementNames, mElementNameLengths, mArraySizes);
502}
503