Element.cpp revision eb4426dfb63983559cf903b2ea984569e990c4fd 
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
22using namespace android;
23using namespace RSC;
24
25android::RSC::sp<const Element> Element::getSubElement(uint32_t index) {
26    if (!mVisibleElementMap.size()) {
27        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements");
28        return NULL;
29    }
30    if (index >= mVisibleElementMap.size()) {
31        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index");
32        return NULL;
33    }
34    return mElements[mVisibleElementMap[index]];
35}
36
37const char * Element::getSubElementName(uint32_t index) {
38    if (!mVisibleElementMap.size()) {
39        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements");
40        return NULL;
41    }
42    if (index >= mVisibleElementMap.size()) {
43        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Illegal sub-element index");
44        return NULL;
45    }
46    return mElementNames[mVisibleElementMap[index]].c_str();
47}
48
49size_t Element::getSubElementArraySize(uint32_t index) {
50    if (!mVisibleElementMap.size()) {
51        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements");
52        return 0;
53    }
54    if (index >= mVisibleElementMap.size()) {
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 (mVisibleElementMap.size()) {
63        mRS->throwError(RS_ERROR_INVALID_PARAMETER, "Element contains no sub-elements");
64        return 0;
65    }
66    if (index >= mVisibleElementMap.size()) {
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(android::RSC::sp<RS> rs) { \
75    if (rs->mElements.N == NULL) {                                  \
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(F32, FLOAT_32);
91CREATE_USER(F64, FLOAT_64);
92CREATE_USER(ELEMENT, ELEMENT);
93CREATE_USER(TYPE, TYPE);
94CREATE_USER(ALLOCATION, ALLOCATION);
95CREATE_USER(SAMPLER, SAMPLER);
96CREATE_USER(SCRIPT, SCRIPT);
97CREATE_USER(MESH, MESH);
98CREATE_USER(PROGRAM_FRAGMENT, PROGRAM_FRAGMENT);
99CREATE_USER(PROGRAM_VERTEX, PROGRAM_VERTEX);
100CREATE_USER(PROGRAM_RASTER, PROGRAM_RASTER);
101CREATE_USER(PROGRAM_STORE, PROGRAM_STORE);
102CREATE_USER(MATRIX_4X4, MATRIX_4X4);
103CREATE_USER(MATRIX_3X3, MATRIX_3X3);
104CREATE_USER(MATRIX_2X2, MATRIX_2X2);
105
106#define CREATE_PIXEL(N, T, K) android::RSC::sp<const Element> Element::N(android::RSC::sp<RS> rs) { \
107    if (rs->mElements.N == NULL) {                                  \
108        rs->mElements.N = createPixel(rs, RS_TYPE_##T, RS_KIND_##K);    \
109    }                                                                   \
110    return rs->mElements.N;                                             \
111}
112
113CREATE_PIXEL(A_8, UNSIGNED_8, PIXEL_A);
114CREATE_PIXEL(RGB_565, UNSIGNED_5_6_5, PIXEL_RGB);
115CREATE_PIXEL(RGB_888, UNSIGNED_8, PIXEL_RGB);
116CREATE_PIXEL(RGBA_4444, UNSIGNED_4_4_4_4, PIXEL_RGBA);
117CREATE_PIXEL(RGBA_8888, UNSIGNED_8, PIXEL_RGBA);
118CREATE_PIXEL(YUV, UNSIGNED_8, PIXEL_YUV);
119
120#define CREATE_VECTOR(N, T) android::RSC::sp<const Element> Element::N##_2(android::RSC::sp<RS> rs) { \
121    if (rs->mElements.N##_2 == NULL) {                                  \
122        rs->mElements.N##_2 = createVector(rs, RS_TYPE_##T, 2);         \
123    }                                                                   \
124    return rs->mElements.N##_2;                                         \
125}                                                                       \
126android::RSC::sp<const Element> Element::N##_3(android::RSC::sp<RS> rs) { \
127    if (rs->mElements.N##_3 == NULL) {                                  \
128        rs->mElements.N##_3 = createVector(rs, RS_TYPE_##T, 3);         \
129    }                                                                   \
130    return rs->mElements.N##_3;                                         \
131} \
132android::RSC::sp<const Element> Element::N##_4(android::RSC::sp<RS> rs) { \
133    if (rs->mElements.N##_4 == NULL) {                                  \
134        rs->mElements.N##_4 = createVector(rs, RS_TYPE_##T, 4);         \
135    }                                                                   \
136    return rs->mElements.N##_4;                                         \
137}
138CREATE_VECTOR(U8, UNSIGNED_8);
139CREATE_VECTOR(I8, SIGNED_8);
140CREATE_VECTOR(U16, UNSIGNED_16);
141CREATE_VECTOR(I16, SIGNED_16);
142CREATE_VECTOR(U32, UNSIGNED_32);
143CREATE_VECTOR(I32, SIGNED_32);
144CREATE_VECTOR(U64, UNSIGNED_64);
145CREATE_VECTOR(I64, SIGNED_64);
146CREATE_VECTOR(F32, FLOAT_32);
147CREATE_VECTOR(F64, FLOAT_64);
148
149
150void Element::updateVisibleSubElements() {
151    if (!mElements.size()) {
152        return;
153    }
154    mVisibleElementMap.clear();
155
156    int noPaddingFieldCount = 0;
157    size_t fieldCount = mElementNames.size();
158    // Find out how many elements are not padding
159    for (size_t ct = 0; ct < fieldCount; ct ++) {
160        if (mElementNames[ct].c_str()[0] != '#') {
161            noPaddingFieldCount ++;
162        }
163    }
164
165    // Make a map that points us at non-padding elements
166    for (size_t ct = 0; ct < fieldCount; ct ++) {
167        if (mElementNames[ct].c_str()[0] != '#') {
168            mVisibleElementMap.push_back((uint32_t)ct);
169        }
170    }
171}
172
173Element::Element(void *id, android::RSC::sp<RS> rs,
174                 std::vector<android::RSC::sp<Element> > &elements,
175                 std::vector<std::string> &elementNames,
176                 std::vector<uint32_t> &arraySizes) : BaseObj(id, rs) {
177    mSizeBytes = 0;
178    mVectorSize = 1;
179    mElements = elements;
180    mArraySizes = arraySizes;
181    mElementNames = elementNames;
182
183    mType = RS_TYPE_NONE;
184    mKind = RS_KIND_USER;
185
186    for (size_t ct = 0; ct < mElements.size(); ct++ ) {
187        mOffsetInBytes.push_back(mSizeBytes);
188        mSizeBytes += mElements[ct]->mSizeBytes * mArraySizes[ct];
189    }
190    updateVisibleSubElements();
191}
192
193
194static uint32_t GetSizeInBytesForType(RsDataType dt) {
195    switch(dt) {
196    case RS_TYPE_NONE:
197        return 0;
198    case RS_TYPE_SIGNED_8:
199    case RS_TYPE_UNSIGNED_8:
200    case RS_TYPE_BOOLEAN:
201        return 1;
202
203    case RS_TYPE_FLOAT_16:
204    case RS_TYPE_SIGNED_16:
205    case RS_TYPE_UNSIGNED_16:
206    case RS_TYPE_UNSIGNED_5_6_5:
207    case RS_TYPE_UNSIGNED_5_5_5_1:
208    case RS_TYPE_UNSIGNED_4_4_4_4:
209        return 2;
210
211    case RS_TYPE_FLOAT_32:
212    case RS_TYPE_SIGNED_32:
213    case RS_TYPE_UNSIGNED_32:
214        return 4;
215
216    case RS_TYPE_FLOAT_64:
217    case RS_TYPE_SIGNED_64:
218    case RS_TYPE_UNSIGNED_64:
219        return 8;
220
221    case RS_TYPE_MATRIX_4X4:
222        return 16 * 4;
223    case RS_TYPE_MATRIX_3X3:
224        return 9 * 4;
225    case RS_TYPE_MATRIX_2X2:
226        return 4 * 4;
227
228    case RS_TYPE_TYPE:
229    case RS_TYPE_ALLOCATION:
230    case RS_TYPE_SAMPLER:
231    case RS_TYPE_SCRIPT:
232    case RS_TYPE_MESH:
233    case RS_TYPE_PROGRAM_FRAGMENT:
234    case RS_TYPE_PROGRAM_VERTEX:
235    case RS_TYPE_PROGRAM_RASTER:
236    case RS_TYPE_PROGRAM_STORE:
237        return 4;
238
239    default:
240        break;
241    }
242
243    ALOGE("Missing type %i", dt);
244    return 0;
245}
246
247Element::Element(void *id, android::RSC::sp<RS> rs,
248                 RsDataType dt, RsDataKind dk, bool norm, uint32_t size) :
249    BaseObj(id, rs)
250{
251    uint32_t tsize = GetSizeInBytesForType(dt);
252    if ((dt != RS_TYPE_UNSIGNED_5_6_5) &&
253        (dt != RS_TYPE_UNSIGNED_4_4_4_4) &&
254        (dt != RS_TYPE_UNSIGNED_5_5_5_1)) {
255        if (size == 3) {
256            mSizeBytes = tsize * 4;
257        } else {
258            mSizeBytes = tsize * size;
259        }
260    } else {
261        mSizeBytes = tsize;
262    }
263    mType = dt;
264    mKind = dk;
265    mNormalized = norm;
266    mVectorSize = size;
267}
268
269Element::~Element() {
270}
271
272void Element::updateFromNative() {
273    BaseObj::updateFromNative();
274    updateVisibleSubElements();
275}
276
277android::RSC::sp<const Element> Element::createUser(android::RSC::sp<RS> rs, RsDataType dt) {
278    void * id = RS::dispatch->ElementCreate(rs->getContext(), dt, RS_KIND_USER, false, 1);
279    return new Element(id, rs, dt, RS_KIND_USER, false, 1);
280}
281
282android::RSC::sp<const Element> Element::createVector(android::RSC::sp<RS> rs, RsDataType dt, uint32_t size) {
283    if (size < 2 || size > 4) {
284        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Vector size out of range 2-4.");
285        return NULL;
286    }
287    void *id = RS::dispatch->ElementCreate(rs->getContext(), dt, RS_KIND_USER, false, size);
288    return new Element(id, rs, dt, RS_KIND_USER, false, size);
289}
290
291android::RSC::sp<const Element> Element::createPixel(android::RSC::sp<RS> rs, RsDataType dt, RsDataKind dk) {
292    if (!(dk == RS_KIND_PIXEL_L ||
293          dk == RS_KIND_PIXEL_A ||
294          dk == RS_KIND_PIXEL_LA ||
295          dk == RS_KIND_PIXEL_RGB ||
296          dk == RS_KIND_PIXEL_RGBA ||
297          dk == RS_KIND_PIXEL_DEPTH)) {
298        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Unsupported DataKind");
299        return NULL;
300    }
301    if (!(dt == RS_TYPE_UNSIGNED_8 ||
302          dt == RS_TYPE_UNSIGNED_16 ||
303          dt == RS_TYPE_UNSIGNED_5_6_5 ||
304          dt == RS_TYPE_UNSIGNED_4_4_4_4 ||
305          dt == RS_TYPE_UNSIGNED_5_5_5_1)) {
306        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Unsupported DataType");
307        return NULL;
308    }
309    if (dt == RS_TYPE_UNSIGNED_5_6_5 && dk != RS_KIND_PIXEL_RGB) {
310        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo");
311        return NULL;
312    }
313    if (dt == RS_TYPE_UNSIGNED_5_5_5_1 && dk != RS_KIND_PIXEL_RGBA) {
314        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo");
315        return NULL;
316    }
317    if (dt == RS_TYPE_UNSIGNED_4_4_4_4 && dk != RS_KIND_PIXEL_RGBA) {
318        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo");
319        return NULL;
320    }
321    if (dt == RS_TYPE_UNSIGNED_16 && dk != RS_KIND_PIXEL_DEPTH) {
322        rs->throwError(RS_ERROR_INVALID_PARAMETER, "Bad kind and type combo");
323        return NULL;
324    }
325
326    int size = 1;
327    switch (dk) {
328    case RS_KIND_PIXEL_LA:
329        size = 2;
330        break;
331    case RS_KIND_PIXEL_RGB:
332        size = 3;
333        break;
334    case RS_KIND_PIXEL_RGBA:
335        size = 4;
336        break;
337    case RS_KIND_PIXEL_DEPTH:
338        size = 2;
339        break;
340    default:
341        break;
342    }
343
344    void * id = RS::dispatch->ElementCreate(rs->getContext(), dt, dk, true, size);
345    return new Element(id, rs, dt, dk, true, size);
346}
347
348bool Element::isCompatible(android::RSC::sp<const Element>e) const {
349    // Try strict BaseObj equality to start with.
350    if (this == e.get()) {
351        return true;
352    }
353
354    // Ignore mKind because it is allowed to be different (user vs. pixel).
355    // We also ignore mNormalized because it can be different. The mType
356    // field must be non-null since we require name equivalence for
357    // user-created Elements.
358    return ((mSizeBytes == e->mSizeBytes) &&
359            (mType != RS_TYPE_NONE) &&
360            (mType == e->mType) &&
361            (mVectorSize == e->mVectorSize));
362}
363
364Element::Builder::Builder(android::RSC::sp<RS> rs) {
365    mRS = rs;
366    mSkipPadding = false;
367}
368
369void Element::Builder::add(android::RSC::sp</*const*/ Element>e, std::string &name, uint32_t arraySize) {
370    // Skip padding fields after a vector 3 type.
371    if (mSkipPadding) {
372        const char *s1 = "#padding_";
373        const char *s2 = name.c_str();
374        size_t len = strlen(s1);
375        if (strlen(s2) >= len) {
376            if (!memcmp(s1, s2, len)) {
377                mSkipPadding = false;
378                return;
379            }
380        }
381    }
382
383    if (e->mVectorSize == 3) {
384        mSkipPadding = true;
385    } else {
386        mSkipPadding = false;
387    }
388
389    mElements.push_back(e);
390    mElementNames.push_back(name);
391    mArraySizes.push_back(arraySize);
392}
393
394android::RSC::sp<const Element> Element::Builder::create() {
395    size_t fieldCount = mElements.size();
396    const char ** nameArray = (const char **)calloc(fieldCount, sizeof(char *));
397    const Element ** elementArray = (const Element **)calloc(fieldCount, sizeof(Element *));
398    size_t* sizeArray = (size_t*)calloc(fieldCount, sizeof(size_t));
399
400    for (size_t ct = 0; ct < fieldCount; ct++) {
401        nameArray[ct] = mElementNames[ct].c_str();
402        elementArray[ct] = mElements[ct].get();
403        sizeArray[ct] = mElementNames[ct].length();
404    }
405
406    void *id = RS::dispatch->ElementCreate2(mRS->getContext(),
407                                (RsElement *)elementArray, fieldCount,
408                                nameArray, fieldCount * sizeof(size_t),  sizeArray,
409                                (const uint32_t *)&mArraySizes[0], fieldCount);
410
411
412    free(nameArray);
413    free(sizeArray);
414    free(elementArray);
415    return new Element(id, mRS, mElements, mElementNames, mArraySizes);
416}
417
418