Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2009 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 | #ifndef ANDROID_STRUCTURED_ELEMENT_H |
| 18 | #define ANDROID_STRUCTURED_ELEMENT_H |
| 19 | |
Jason Sams | d01d970 | 2009-12-23 14:35:29 -0800 | [diff] [blame] | 20 | #include "rsComponent.h" |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 21 | #include "rsUtils.h" |
Jason Sams | 66f0a16 | 2014-11-11 13:46:38 -0800 | [diff] [blame] | 22 | #include "rsInternalDefines.h" |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 23 | #include "rsObjectBase.h" |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 24 | |
| 25 | // --------------------------------------------------------------------------- |
| 26 | namespace android { |
| 27 | namespace renderscript { |
Alex Sakhartchouk | 4a43e3e | 2011-12-28 13:47:05 -0800 | [diff] [blame] | 28 | /***************************************************************************** |
| 29 | * CAUTION |
| 30 | * |
| 31 | * Any layout changes for this class may require a corresponding change to be |
| 32 | * made to frameworks/compile/libbcc/lib/ScriptCRT/rs_core.c, which contains |
| 33 | * a partial copy of the information below. |
| 34 | * |
| 35 | *****************************************************************************/ |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 36 | // An element is a group of Components that occupies one cell in a structure. |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 37 | class Element : public ObjectBase { |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 38 | public: |
Alex Sakhartchouk | 253325d | 2011-12-15 09:56:10 -0800 | [diff] [blame] | 39 | struct Hal { |
| 40 | mutable void *drv; |
| 41 | |
| 42 | struct State { |
| 43 | RsDataType dataType; |
| 44 | RsDataKind dataKind; |
| 45 | uint32_t vectorSize; |
| 46 | uint32_t elementSizeBytes; |
| 47 | |
| 48 | // Subelements |
| 49 | const Element **fields; |
| 50 | uint32_t *fieldArraySizes; |
| 51 | const char **fieldNames; |
| 52 | uint32_t *fieldNameLengths; |
| 53 | uint32_t *fieldOffsetBytes; |
| 54 | uint32_t fieldsCount; |
| 55 | }; |
| 56 | State state; |
| 57 | }; |
| 58 | Hal mHal; |
| 59 | |
Tim Murray | 49a8777 | 2014-07-10 10:00:00 -0700 | [diff] [blame] | 60 | void operator delete(void* ptr); |
| 61 | |
Jason Sams | 565ac36 | 2009-06-03 16:04:54 -0700 | [diff] [blame] | 62 | uint32_t getGLType() const; |
| 63 | uint32_t getGLFormat() const; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 64 | |
Alex Sakhartchouk | 2d1220c | 2011-11-15 15:15:21 -0800 | [diff] [blame] | 65 | size_t getSizeBitsUnpadded() const; |
| 66 | size_t getSizeBytesUnpadded() const { |
| 67 | return (getSizeBitsUnpadded() + 7) >> 3; |
| 68 | } |
| 69 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 70 | size_t getSizeBits() const; |
Jason Sams | e5ffb87 | 2009-08-09 17:01:55 -0700 | [diff] [blame] | 71 | size_t getSizeBytes() const { |
| 72 | return (getSizeBits() + 7) >> 3; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 73 | } |
| 74 | |
Jason Sams | e3929c9 | 2010-08-09 18:13:33 -0700 | [diff] [blame] | 75 | size_t getFieldOffsetBits(uint32_t componentNumber) const { |
| 76 | return mFields[componentNumber].offsetBits; |
| 77 | } |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 78 | size_t getFieldOffsetBytes(uint32_t componentNumber) const { |
Jason Sams | e3929c9 | 2010-08-09 18:13:33 -0700 | [diff] [blame] | 79 | return mFields[componentNumber].offsetBits >> 3; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 80 | } |
| 81 | |
Alex Sakhartchouk | 2d1220c | 2011-11-15 15:15:21 -0800 | [diff] [blame] | 82 | size_t getFieldOffsetBytesUnpadded(uint32_t componentNumber) const { |
| 83 | return mFields[componentNumber].offsetBitsUnpadded >> 3; |
| 84 | } |
| 85 | |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 86 | uint32_t getFieldCount() const {return mFieldCount;} |
| 87 | const Element * getField(uint32_t idx) const {return mFields[idx].e.get();} |
Jason Sams | 48ecf6a | 2013-07-09 15:35:29 -0700 | [diff] [blame] | 88 | const char * getFieldName(uint32_t idx) const {return mFields[idx].name;} |
Alex Sakhartchouk | 39f2ef6 | 2010-10-11 12:35:15 -0700 | [diff] [blame] | 89 | uint32_t getFieldArraySize(uint32_t idx) const {return mFields[idx].arraySize;} |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 90 | |
Jason Sams | d01d970 | 2009-12-23 14:35:29 -0800 | [diff] [blame] | 91 | const Component & getComponent() const {return mComponent;} |
| 92 | RsDataType getType() const {return mComponent.getType();} |
Jason Sams | d01d970 | 2009-12-23 14:35:29 -0800 | [diff] [blame] | 93 | RsDataKind getKind() const {return mComponent.getKind();} |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 94 | uint32_t getBits() const {return mBits;} |
Alex Sakhartchouk | 2d1220c | 2011-11-15 15:15:21 -0800 | [diff] [blame] | 95 | uint32_t getBitsUnpadded() const {return mBitsUnpadded;} |
Jason Sams | c905efd | 2012-11-26 15:20:18 -0800 | [diff] [blame] | 96 | uint32_t getVectorSize() const {return mComponent.getVectorSize();} |
Jason Sams | d01d970 | 2009-12-23 14:35:29 -0800 | [diff] [blame] | 97 | |
Jason Sams | e12c1c5 | 2009-09-27 17:50:38 -0700 | [diff] [blame] | 98 | void dumpLOGV(const char *prefix) const; |
Jason Sams | e3150cf | 2012-07-24 18:10:20 -0700 | [diff] [blame] | 99 | virtual void serialize(Context *rsc, OStream *stream) const; |
Alex Sakhartchouk | b825f67 | 2010-06-04 10:06:50 -0700 | [diff] [blame] | 100 | virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ELEMENT; } |
Alex Sakhartchouk | fb6b614 | 2010-05-21 12:53:13 -0700 | [diff] [blame] | 101 | static Element *createFromStream(Context *rsc, IStream *stream); |
Jason Sams | e12c1c5 | 2009-09-27 17:50:38 -0700 | [diff] [blame] | 102 | |
Alex Sakhartchouk | c700e64 | 2011-08-16 13:09:46 -0700 | [diff] [blame] | 103 | static ObjectBaseRef<const Element> createRef(Context *rsc, |
| 104 | RsDataType dt, |
| 105 | RsDataKind dk, |
| 106 | bool isNorm, |
| 107 | uint32_t vecSize); |
| 108 | static ObjectBaseRef<const Element> createRef(Context *rsc, size_t count, |
| 109 | const Element **, |
| 110 | const char **, |
| 111 | const size_t * lengths, |
| 112 | const uint32_t *asin); |
| 113 | |
| 114 | static const Element* create(Context *rsc, |
| 115 | RsDataType dt, |
| 116 | RsDataKind dk, |
| 117 | bool isNorm, |
| 118 | uint32_t vecSize) { |
| 119 | ObjectBaseRef<const Element> elem = createRef(rsc, dt, dk, isNorm, vecSize); |
| 120 | elem->incUserRef(); |
| 121 | return elem.get(); |
| 122 | } |
| 123 | static const Element* create(Context *rsc, size_t count, |
| 124 | const Element **ein, |
| 125 | const char **nin, |
Chris Wailes | 44bef6f | 2014-08-12 13:51:10 -0700 | [diff] [blame] | 126 | const size_t * lengths = nullptr, |
| 127 | const uint32_t *asin = nullptr) { |
Alex Sakhartchouk | c700e64 | 2011-08-16 13:09:46 -0700 | [diff] [blame] | 128 | ObjectBaseRef<const Element> elem = createRef(rsc, count, ein, nin, lengths, asin); |
| 129 | elem->incUserRef(); |
| 130 | return elem.get(); |
| 131 | } |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 132 | |
Jason Sams | e3929c9 | 2010-08-09 18:13:33 -0700 | [diff] [blame] | 133 | void incRefs(const void *) const; |
| 134 | void decRefs(const void *) const; |
Jason Sams | a36c50a | 2014-06-17 12:06:06 -0700 | [diff] [blame] | 135 | virtual void callUpdateCacheObject(const Context *rsc, void *dstObj) const; |
Jason Sams | e3929c9 | 2010-08-09 18:13:33 -0700 | [diff] [blame] | 136 | bool getHasReferences() const {return mHasReference;} |
| 137 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 138 | protected: |
| 139 | // deallocate any components that are part of this element. |
| 140 | void clear(); |
| 141 | |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 142 | typedef struct { |
Jason Sams | 48ecf6a | 2013-07-09 15:35:29 -0700 | [diff] [blame] | 143 | const char *name; |
Jason Sams | d01d970 | 2009-12-23 14:35:29 -0800 | [diff] [blame] | 144 | ObjectBaseRef<const Element> e; |
Jason Sams | e3929c9 | 2010-08-09 18:13:33 -0700 | [diff] [blame] | 145 | uint32_t offsetBits; |
Alex Sakhartchouk | 2d1220c | 2011-11-15 15:15:21 -0800 | [diff] [blame] | 146 | uint32_t offsetBitsUnpadded; |
Jason Sams | 46e4554 | 2010-09-02 17:35:23 -0700 | [diff] [blame] | 147 | uint32_t arraySize; |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 148 | } ElementField_t; |
| 149 | ElementField_t *mFields; |
| 150 | size_t mFieldCount; |
Jason Sams | e3929c9 | 2010-08-09 18:13:33 -0700 | [diff] [blame] | 151 | bool mHasReference; |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 152 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 153 | |
Alex Sakhartchouk | c700e64 | 2011-08-16 13:09:46 -0700 | [diff] [blame] | 154 | virtual ~Element(); |
Jason Sams | e514b45 | 2009-09-25 14:51:22 -0700 | [diff] [blame] | 155 | Element(Context *); |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 156 | |
Jason Sams | d01d970 | 2009-12-23 14:35:29 -0800 | [diff] [blame] | 157 | Component mComponent; |
Alex Sakhartchouk | 2d1220c | 2011-11-15 15:15:21 -0800 | [diff] [blame] | 158 | uint32_t mBitsUnpadded; |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 159 | uint32_t mBits; |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 160 | |
| 161 | void compute(); |
Alex Sakhartchouk | c700e64 | 2011-08-16 13:09:46 -0700 | [diff] [blame] | 162 | |
| 163 | virtual void preDestroy() const; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 164 | }; |
| 165 | |
| 166 | |
| 167 | class ElementState { |
| 168 | public: |
| 169 | ElementState(); |
| 170 | ~ElementState(); |
| 171 | |
Jason Sams | 8154954 | 2010-02-17 15:38:10 -0800 | [diff] [blame] | 172 | // Cache of all existing elements. |
Yang Ni | b8353c5 | 2015-02-14 18:00:59 -0800 | [diff] [blame] | 173 | Vector<Element *> mElements; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 174 | }; |
| 175 | |
| 176 | |
| 177 | } |
| 178 | } |
| 179 | #endif //ANDROID_STRUCTURED_ELEMENT_H |