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 android::RSC::Element;
24 
getSubElement(uint32_t index)25 android::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 
getSubElementName(uint32_t index)37 const 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 
getSubElementArraySize(uint32_t index)49 size_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 
getSubElementOffsetBytes(uint32_t index)61 uint32_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 
81 CREATE_USER(BOOLEAN, BOOLEAN);
82 CREATE_USER(U8, UNSIGNED_8);
83 CREATE_USER(I8, SIGNED_8);
84 CREATE_USER(U16, UNSIGNED_16);
85 CREATE_USER(I16, SIGNED_16);
86 CREATE_USER(U32, UNSIGNED_32);
87 CREATE_USER(I32, SIGNED_32);
88 CREATE_USER(U64, UNSIGNED_64);
89 CREATE_USER(I64, SIGNED_64);
90 CREATE_USER(F16, FLOAT_16);
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(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 
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(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 }                                                                         \
123 android::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 } \
129 android::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 }
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(F16, FLOAT_16);
144 CREATE_VECTOR(F32, FLOAT_32);
145 CREATE_VECTOR(F64, FLOAT_64);
146 
147 
updateVisibleSubElements()148 void 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 
Element(void * id,android::RSC::sp<RS> rs,android::RSC::sp<const Element> * elements,size_t elementCount,const char ** elementNames,size_t * elementNameLengths,uint32_t * arraySizes)177 Element::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<const 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 
Element(void * id,android::RSC::sp<RS> rs)216 Element::Element(void *id, android::RSC::sp<RS> rs) :
217     BaseObj(id, rs) {
218 }
219 
GetSizeInBytesForType(RsDataType dt)220 static 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 
Element(void * id,android::RSC::sp<RS> rs,RsDataType dt,RsDataKind dk,bool norm,uint32_t size)273 Element::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 
~Element()297 Element::~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 
updateFromNative()313 void Element::updateFromNative() {
314     BaseObj::updateFromNative();
315     updateVisibleSubElements();
316 }
317 
createUser(const android::RSC::sp<RS> & rs,RsDataType dt)318 android::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 
createVector(const android::RSC::sp<RS> & rs,RsDataType dt,uint32_t size)323 android::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 
createPixel(const android::RSC::sp<RS> & rs,RsDataType dt,RsDataKind dk)332 android::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 
isCompatible(const android::RSC::sp<const Element> & e) const390 bool 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 
Builder(android::RSC::sp<RS> rs)408 Element::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<const 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 
~Builder()420 Element::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 
add(const android::RSC::sp<const Element> & e,const char * name,uint32_t arraySize)431 void 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<const 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 
create()488 android::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