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