rsComponent.cpp revision 77d9f4bd05b2d2a161f30c12a2248f9c97eaac42 
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#include "rsComponent.h"
18
19#ifndef ANDROID_RS_SERIALIZE
20#include <GLES/gl.h>
21#endif
22
23using namespace android;
24using namespace android::renderscript;
25
26Component::Component() {
27    set(RS_TYPE_NONE, RS_KIND_USER, false, 1);
28}
29
30Component::~Component() {
31}
32
33void Component::set(RsDataType dt, RsDataKind dk, bool norm, uint32_t vecSize) {
34    mType = dt;
35    mKind = dk;
36    mNormalized = norm;
37    mVectorSize = vecSize;
38    rsAssert(vecSize <= 4);
39
40    mBits = 0;
41    mTypeBits = 0;
42    mIsFloat = false;
43    mIsSigned = false;
44    mIsPixel = false;
45
46    switch (mKind) {
47    case RS_KIND_PIXEL_L:
48    case RS_KIND_PIXEL_A:
49        mIsPixel = true;
50        rsAssert(mVectorSize == 1);
51        rsAssert(mNormalized == true);
52        break;
53    case RS_KIND_PIXEL_LA:
54        mIsPixel = true;
55        rsAssert(mVectorSize == 2);
56        rsAssert(mNormalized == true);
57        break;
58    case RS_KIND_PIXEL_RGB:
59        mIsPixel = true;
60        rsAssert(mVectorSize == 3);
61        rsAssert(mNormalized == true);
62        break;
63    case RS_KIND_PIXEL_RGBA:
64        mIsPixel = true;
65        rsAssert(mVectorSize == 4);
66        rsAssert(mNormalized == true);
67        break;
68    default:
69        break;
70    }
71
72    switch (mType) {
73    case RS_TYPE_NONE:
74        return;
75    case RS_TYPE_UNSIGNED_5_6_5:
76        mVectorSize = 3;
77        mBits = 16;
78        mNormalized = true;
79        rsAssert(mKind == RS_KIND_PIXEL_RGB);
80        return;
81    case RS_TYPE_UNSIGNED_5_5_5_1:
82        mVectorSize = 4;
83        mBits = 16;
84        mNormalized = true;
85        rsAssert(mKind == RS_KIND_PIXEL_RGBA);
86        return;
87    case RS_TYPE_UNSIGNED_4_4_4_4:
88        mVectorSize = 4;
89        mBits = 16;
90        mNormalized = true;
91        rsAssert(mKind == RS_KIND_PIXEL_RGBA);
92        return;
93
94    case RS_TYPE_MATRIX_4X4:
95        mTypeBits = 16 * 32;
96        rsAssert(mVectorSize == 1);
97        rsAssert(mNormalized == false);
98        rsAssert(mKind == RS_KIND_USER);
99        break;
100    case RS_TYPE_MATRIX_3X3:
101        mTypeBits = 9 * 32;
102        rsAssert(mVectorSize == 1);
103        rsAssert(mNormalized == false);
104        rsAssert(mKind == RS_KIND_USER);
105        break;
106    case RS_TYPE_MATRIX_2X2:
107        mTypeBits = 4 * 32;
108        rsAssert(mVectorSize == 1);
109        rsAssert(mNormalized == false);
110        rsAssert(mKind == RS_KIND_USER);
111        break;
112
113    case RS_TYPE_ELEMENT:
114    case RS_TYPE_TYPE:
115    case RS_TYPE_ALLOCATION:
116    case RS_TYPE_SAMPLER:
117    case RS_TYPE_SCRIPT:
118    case RS_TYPE_MESH:
119    case RS_TYPE_PROGRAM_FRAGMENT:
120    case RS_TYPE_PROGRAM_VERTEX:
121    case RS_TYPE_PROGRAM_RASTER:
122    case RS_TYPE_PROGRAM_STORE:
123        rsAssert(mVectorSize == 1);
124        rsAssert(mNormalized == false);
125        rsAssert(mKind == RS_KIND_USER);
126        mBits = 32;
127        mTypeBits = 32;
128        return;
129
130    case RS_TYPE_FLOAT_16:
131        mTypeBits = 16;
132        mIsFloat = true;
133        break;
134    case RS_TYPE_FLOAT_32:
135        mTypeBits = 32;
136        mIsFloat = true;
137        break;
138    case RS_TYPE_FLOAT_64:
139        mTypeBits = 64;
140        mIsFloat = true;
141        break;
142    case RS_TYPE_SIGNED_8:
143        mTypeBits = 8;
144        mIsSigned = true;
145        break;
146    case RS_TYPE_SIGNED_16:
147        mTypeBits = 16;
148        mIsSigned = true;
149        break;
150    case RS_TYPE_SIGNED_32:
151        mTypeBits = 32;
152        mIsSigned = true;
153        break;
154    case RS_TYPE_SIGNED_64:
155        mTypeBits = 64;
156        mIsSigned = true;
157        break;
158    case RS_TYPE_UNSIGNED_8:
159        mTypeBits = 8;
160        break;
161    case RS_TYPE_UNSIGNED_16:
162        mTypeBits = 16;
163        break;
164    case RS_TYPE_UNSIGNED_32:
165        mTypeBits = 32;
166        break;
167    case RS_TYPE_UNSIGNED_64:
168        mTypeBits = 64;
169        break;
170
171    case RS_TYPE_BOOLEAN:
172        mTypeBits = 8;
173        break;
174    }
175
176    mBits = mTypeBits * mVectorSize;
177}
178
179bool Component::isReference() const {
180    return (mType >= RS_TYPE_ELEMENT);
181}
182
183uint32_t Component::getGLType() const {
184#ifndef ANDROID_RS_SERIALIZE
185    switch (mType) {
186    case RS_TYPE_UNSIGNED_5_6_5:    return GL_UNSIGNED_SHORT_5_6_5;
187    case RS_TYPE_UNSIGNED_5_5_5_1:  return GL_UNSIGNED_SHORT_5_5_5_1;
188    case RS_TYPE_UNSIGNED_4_4_4_4:  return GL_UNSIGNED_SHORT_4_4_4_4;
189
190    //case RS_TYPE_FLOAT_16:      return GL_HALF_FLOAT;
191    case RS_TYPE_FLOAT_32:      return GL_FLOAT;
192    case RS_TYPE_UNSIGNED_8:    return GL_UNSIGNED_BYTE;
193    case RS_TYPE_UNSIGNED_16:   return GL_UNSIGNED_SHORT;
194    case RS_TYPE_SIGNED_8:      return GL_BYTE;
195    case RS_TYPE_SIGNED_16:     return GL_SHORT;
196    default:    break;
197    }
198#endif //ANDROID_RS_SERIALIZE
199    return 0;
200}
201
202uint32_t Component::getGLFormat() const {
203#ifndef ANDROID_RS_SERIALIZE
204    switch (mKind) {
205    case RS_KIND_PIXEL_L: return GL_LUMINANCE;
206    case RS_KIND_PIXEL_A: return GL_ALPHA;
207    case RS_KIND_PIXEL_LA: return GL_LUMINANCE_ALPHA;
208    case RS_KIND_PIXEL_RGB: return GL_RGB;
209    case RS_KIND_PIXEL_RGBA: return GL_RGBA;
210    default: break;
211    }
212#endif //ANDROID_RS_SERIALIZE
213    return 0;
214}
215
216String8 Component::getGLSLType() const {
217    if (mType == RS_TYPE_SIGNED_32) {
218        switch (mVectorSize) {
219        case 1: return String8("int");
220        case 2: return String8("ivec2");
221        case 3: return String8("ivec3");
222        case 4: return String8("ivec4");
223        }
224    }
225    if (mType == RS_TYPE_FLOAT_32) {
226        switch (mVectorSize) {
227        case 1: return String8("float");
228        case 2: return String8("vec2");
229        case 3: return String8("vec3");
230        case 4: return String8("vec4");
231        }
232    }
233    if ((mType == RS_TYPE_MATRIX_4X4) && (mVectorSize == 1)) {
234        return String8("mat4");
235    }
236    if ((mType == RS_TYPE_MATRIX_3X3) && (mVectorSize == 1)) {
237        return String8("mat3");
238    }
239    if ((mType == RS_TYPE_MATRIX_2X2) && (mVectorSize == 1)) {
240        return String8("mat2");
241    }
242    return String8();
243}
244
245static const char * gTypeBasicStrings[] = {
246    "NONE",
247    "F16",
248    "F32",
249    "F64",
250    "S8",
251    "S16",
252    "S32",
253    "S64",
254    "U8",
255    "U16",
256    "U32",
257    "U64",
258    "BOOLEAN",
259    "UP_565",
260    "UP_5551",
261    "UP_4444",
262    "MATRIX_4X4",
263    "MATRIX_3X3",
264    "MATRIX_2X2",
265};
266
267static const char * gTypeObjStrings[] = {
268    "ELEMENT",
269    "TYPE",
270    "ALLOCATION",
271    "SAMPLER",
272    "SCRIPT",
273    "MESH",
274    "PROGRAM_FRAGMENT",
275    "PROGRAM_VERTEX",
276    "PROGRAM_RASTER",
277    "PROGRAM_STORE",
278};
279
280static const char * gKindStrings[] = {
281    "USER",
282    "COLOR",
283    "POSITION",
284    "TEXTURE",
285    "NORMAL",
286    "INDEX",
287    "POINT_SIZE",
288    "PIXEL_L",
289    "PIXEL_A",
290    "PIXEL_LA",
291    "PIXEL_RGB",
292    "PIXEL_RGBA",
293};
294
295void Component::dumpLOGV(const char *prefix) const {
296    if (mType >= RS_TYPE_ELEMENT) {
297        LOGV("%s   Component: %s, %s, vectorSize=%i, bits=%i",
298             prefix, gTypeObjStrings[mType - RS_TYPE_ELEMENT], gKindStrings[mKind], mVectorSize, mBits);
299    } else {
300        LOGV("%s   Component: %s, %s, vectorSize=%i, bits=%i",
301             prefix, gTypeBasicStrings[mType], gKindStrings[mKind], mVectorSize, mBits);
302    }
303}
304
305void Component::serialize(OStream *stream) const {
306    stream->addU8((uint8_t)mType);
307    stream->addU8((uint8_t)mKind);
308    stream->addU8((uint8_t)(mNormalized ? 1 : 0));
309    stream->addU32(mVectorSize);
310}
311
312void Component::loadFromStream(IStream *stream) {
313    mType = (RsDataType)stream->loadU8();
314    mKind = (RsDataKind)stream->loadU8();
315    uint8_t temp = stream->loadU8();
316    mNormalized = temp != 0;
317    mVectorSize = stream->loadU32();
318
319    set(mType, mKind, mNormalized, mVectorSize);
320}
321
322
323
324
325