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