slang_rs_type_spec.h revision db6dfdfcb7e8183f1c796475e5098ee4be80b5b8 
1/*
2 * Copyright 2010, 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 _COMPILE_SLANG_SLANG_RS_TYPE_SPEC_H_  // NOLINT
18#define _COMPILE_SLANG_SLANG_RS_TYPE_SPEC_H_
19
20#define RS_DATA_TYPE_CLASS_ENUMS            \
21    ENUM_RS_DATA_TYPE_CLASS(Primitive)      \
22    ENUM_RS_DATA_TYPE_CLASS(Pointer)        \
23    ENUM_RS_DATA_TYPE_CLASS(Vector)         \
24    ENUM_RS_DATA_TYPE_CLASS(Matrix)         \
25    ENUM_RS_DATA_TYPE_CLASS(ConstantArray)  \
26    ENUM_RS_DATA_TYPE_CLASS(Record)
27
28#define PRIMITIVE_DATA_TYPE_ENUMS                         \
29    ENUM_PRIMITIVE_DATA_TYPE(Float16, NULL, 128)          \
30    ENUM_PRIMITIVE_DATA_TYPE(Float32, "float", 256)       \
31    ENUM_PRIMITIVE_DATA_TYPE(Float64, "double", 512)      \
32    ENUM_PRIMITIVE_DATA_TYPE(Signed8, "char", 64)         \
33    ENUM_PRIMITIVE_DATA_TYPE(Signed16, "short", 128)      \
34    ENUM_PRIMITIVE_DATA_TYPE(Signed32, "int", 256)        \
35    ENUM_PRIMITIVE_DATA_TYPE(Signed64, "long", 512)       \
36    ENUM_PRIMITIVE_DATA_TYPE(Unsigned8, "uchar", 64)      \
37    ENUM_PRIMITIVE_DATA_TYPE(Unsigned16, "ushort", 128)   \
38    ENUM_PRIMITIVE_DATA_TYPE(Unsigned32, "uint", 256)     \
39    ENUM_PRIMITIVE_DATA_TYPE(Unsigned64, "ulong", 512)    \
40    ENUM_PRIMITIVE_DATA_TYPE(Boolean, "bool", 8)          \
41    ENUM_PRIMITIVE_DATA_TYPE(Unsigned565, "u565", 128)    \
42    ENUM_PRIMITIVE_DATA_TYPE(Unsigned5551, "u5551", 128)  \
43    ENUM_PRIMITIVE_DATA_TYPE(Unsigned4444, "u4444", 128)  \
44    PRIMITIVE_DATA_TYPE_RANGE(Float16, Unsigned4444)
45
46#define RS_MATRIX_DATA_TYPE_ENUMS                             \
47    ENUM_RS_MATRIX_DATA_TYPE(RSMatrix2x2, "rs_matrix2x2", 2)  \
48    ENUM_RS_MATRIX_DATA_TYPE(RSMatrix3x3, "rs_matrix3x3", 3)  \
49    ENUM_RS_MATRIX_DATA_TYPE(RSMatrix4x4, "rs_matrix4x4", 4)  \
50    RS_MATRIX_DATA_TYPE_RANGE(RSMatrix2x2, RSMatrix4x4)
51
52#define RS_OBJECT_DATA_TYPE_ENUMS                                       \
53    ENUM_RS_OBJECT_DATA_TYPE(RSElement, "rs_element")                   \
54    ENUM_RS_OBJECT_DATA_TYPE(RSType, "rs_type")                         \
55    ENUM_RS_OBJECT_DATA_TYPE(RSAllocation, "rs_allocation")             \
56    ENUM_RS_OBJECT_DATA_TYPE(RSSampler, "rs_sampler")                   \
57    ENUM_RS_OBJECT_DATA_TYPE(RSScript, "rs_script")                     \
58    ENUM_RS_OBJECT_DATA_TYPE(RSMesh, "rs_mesh")                         \
59    ENUM_RS_OBJECT_DATA_TYPE(RSPath, "rs_path")                         \
60    ENUM_RS_OBJECT_DATA_TYPE(RSProgramFragment, "rs_program_fragment")  \
61    ENUM_RS_OBJECT_DATA_TYPE(RSProgramVertex, "rs_program_vertex")      \
62    ENUM_RS_OBJECT_DATA_TYPE(RSProgramRaster, "rs_program_raster")      \
63    ENUM_RS_OBJECT_DATA_TYPE(RSProgramStore, "rs_program_store")        \
64    ENUM_RS_OBJECT_DATA_TYPE(RSFont, "rs_font")                         \
65    RS_OBJECT_DATA_TYPE_RANGE(RSElement, RSFont)
66
67#define RS_DATA_KIND_ENUMS        \
68    ENUM_RS_DATA_KIND(User)       \
69    ENUM_RS_DATA_KIND(PixelL)     \
70    ENUM_RS_DATA_KIND(PixelA)     \
71    ENUM_RS_DATA_KIND(PixelLA)    \
72    ENUM_RS_DATA_KIND(PixelRGB)   \
73    ENUM_RS_DATA_KIND(PixelRGBA)
74
75enum RSTypeClass {
76#define ENUM_RS_DATA_TYPE_CLASS(x)  RS_TC_ ## x,
77  RS_DATA_TYPE_CLASS_ENUMS
78#undef ENUM_RS_DATA_TYPE_CLASS
79  RS_TC_Max
80};
81
82enum RSDataType {
83#define ENUM_PRIMITIVE_DATA_TYPE(x, name, bits) RS_DT_ ## x,
84#define PRIMITIVE_DATA_TYPE_RANGE(x, y) \
85    RS_DT_FirstPrimitiveType = RS_DT_ ## x, \
86    RS_DT_LastPrimitiveType = RS_DT_ ## y,
87  PRIMITIVE_DATA_TYPE_ENUMS
88#undef ENUM_PRIMITIVE_DATA_TYPE
89#undef PRIMITIVE_DATA_TYPE_RANGE
90
91#define ENUM_RS_MATRIX_DATA_TYPE(x, name, dim) RS_DT_ ## x,
92#define RS_MATRIX_DATA_TYPE_RANGE(x, y) \
93      RS_DT_FirstMatrixType = RS_DT_ ## x,  \
94      RS_DT_LastMatrixType = RS_DT_ ## y,
95  RS_MATRIX_DATA_TYPE_ENUMS
96#undef ENUM_RS_MATRIX_DATA_TYPE
97#undef RS_MATRIX_DATA_TYPE_RANGE
98
99#define ENUM_RS_OBJECT_DATA_TYPE(x, name) RS_DT_ ## x,
100#define RS_OBJECT_DATA_TYPE_RANGE(x, y) \
101    RS_DT_FirstRSObjectType = RS_DT_ ## x,  \
102    RS_DT_LastRSObjectType = RS_DT_ ## y,
103  RS_OBJECT_DATA_TYPE_ENUMS
104#undef ENUM_RS_OBJECT_DATA_TYPE
105#undef RS_OBJECT_DATA_TYPE_RANGE
106
107  RS_DT_USER_DEFINED
108};
109
110enum RSDataKind {
111#define ENUM_RS_DATA_KIND(x) RS_DK_ ## x,
112  RS_DATA_KIND_ENUMS
113#undef ENUM_RS_DATA_KIND
114  RS_DK_Max
115};
116
117// Forward declaration
118union RSType;
119
120// NOTE: Current design need to keep struct RSTypeBase as a 4-byte integer for
121//       efficient decoding process (see DecodeTypeMetadata).
122struct RSTypeBase {
123  /* enum RSTypeClass tc; */
124  // tc is encoded in b[0].
125  union {
126    // FIXME: handle big-endianess case
127    unsigned bits;  // NOTE: Little-endian is assumed.
128    unsigned char b[4];
129  };
130};
131
132struct RSPrimitiveType {
133  struct RSTypeBase base;
134  /* enum RSDataType dt; */
135  // dt is encoded in base.b[1]
136};
137
138struct RSPointerType {
139  struct RSTypeBase base;
140  const union RSType *pointee;
141};
142
143struct RSVectorType {
144  struct RSPrimitiveType base;  // base type of vec must be in primitive type
145  /* unsigned char vsize; */
146  // vsize is encoded in base.b[2]
147};
148
149// RSMatrixType is actually a specialize class of RSPrimitiveType whose value of
150// dt (data type) can only be RS_DT_RSMatrix2x2, RS_DT_RSMatrix3x3 and
151// RS_DT_RSMatrix4x4.
152struct RSMatrixType {
153  struct RSTypeBase base;
154};
155
156struct RSConstantArrayType {
157  struct RSTypeBase base;
158  const union RSType *element_type;
159  /* unsigned esize; */
160  // esize is encoded in base.bits{8-31} in little-endian way. This implicates
161  // the number of elements in any constant array type should never exceed 2^24.
162};
163
164struct RSRecordField {
165  const char *name;  // field name
166  const union RSType *type;
167  enum RSDataKind dk;
168};
169
170struct RSRecordType {
171  struct RSTypeBase base;
172  const char *name;  // type name
173  /* unsigned num_fields; */
174  // num_fields is encoded in base.bits{16-31} in little-endian way. This
175  // implicates the number of fields defined in any record type should never
176  // exceed 2^16.
177
178  struct RSRecordField field[1];
179};
180
181union RSType {
182  struct RSTypeBase base;
183  struct RSPrimitiveType prim;
184  struct RSPointerType pointer;
185  struct RSVectorType vec;
186  struct RSConstantArrayType ca;
187  struct RSRecordType rec;
188};
189
190#define RS_GET_TYPE_BASE(R)               (&((R)->base))
191#define RS_CAST_TO_PRIMITIVE_TYPE(R)      (&((R)->prim))
192#define RS_CAST_TO_POINTER_TYPE(R)        (&((R)->pointer))
193#define RS_CAST_TO_VECTOR_TYPE(R)         (&((R)->vec))
194#define RS_CAST_TO_CONSTANT_ARRAY_TYPE(R) (&((R)->ca))
195#define RS_CAST_TO_RECORD_TYPE(R)         (&((R)->rec))
196
197// RSType
198#define RS_TYPE_GET_CLASS(R)  RS_GET_TYPE_BASE(R)->b[0]
199#define RS_TYPE_SET_CLASS(R, V) RS_TYPE_GET_CLASS(R) = (V)
200
201// RSPrimitiveType
202#define RS_PRIMITIVE_TYPE_GET_DATA_TYPE(R)  \
203    RS_CAST_TO_PRIMITIVE_TYPE(R)->base.b[1]
204#define RS_PRIMITIVE_TYPE_SET_DATA_TYPE(R, V) \
205    RS_PRIMITIVE_TYPE_GET_DATA_TYPE(R) = (V)
206
207// RSPointerType
208#define RS_POINTER_TYPE_GET_POINTEE_TYPE(R) \
209    RS_CAST_TO_POINTER_TYPE(R)->pointee
210#define RS_POINTER_TYPE_SET_POINTEE_TYPE(R, V) \
211    RS_POINTER_TYPE_GET_POINTEE_TYPE(R) = (V)
212
213// RSVectorType
214#define RS_VECTOR_TYPE_GET_ELEMENT_TYPE(R) \
215    RS_PRIMITIVE_TYPE_GET_DATA_TYPE(R)
216#define RS_VECTOR_TYPE_SET_ELEMENT_TYPE(R, V) \
217    RS_VECTOR_TYPE_GET_ELEMENT_TYPE(R) = (V)
218
219#define RS_VECTOR_TYPE_GET_VECTOR_SIZE(R) \
220    RS_CAST_TO_VECTOR_TYPE(R)->base.base.b[2]
221#define RS_VECTOR_TYPE_SET_VECTOR_SIZE(R, V) \
222    RS_VECTOR_TYPE_GET_VECTOR_SIZE(R) = (V)
223
224// RSMatrixType
225#define RS_MATRIX_TYPE_GET_DATA_TYPE(R) RS_PRIMITIVE_TYPE_GET_DATA_TYPE(R)
226#define RS_MATRIX_TYPE_SET_DATA_TYPE(R, V)  \
227    RS_MATRIX_TYPE_GET_DATA_TYPE(R) = (V)
228
229// RSConstantArrayType
230#define RS_CONSTANT_ARRAY_TYPE_GET_ELEMENT_TYPE(R) \
231    RS_CAST_TO_CONSTANT_ARRAY_TYPE(R)->element_type
232#define RS_CONSTANT_ARRAY_TYPE_SET_ELEMENT_TYPE(R, V) \
233    RS_CONSTANT_ARRAY_TYPE_GET_ELEMENT_TYPE(R) = (V)
234
235#define RS_CONSTANT_ARRAY_TYPE_GET_ELEMENT_SIZE(R)  \
236    (RS_CAST_TO_CONSTANT_ARRAY_TYPE(R)->base.bits & 0x00ffffff)
237#define RS_CONSTANT_ARRAY_TYPE_SET_ELEMENT_SIZE(R, V) \
238    RS_CAST_TO_CONSTANT_ARRAY_TYPE(R)->base.bits =  \
239    ((RS_CAST_TO_CONSTANT_ARRAY_TYPE(R)->base.bits & 0x000000ff) |  \
240     ((V & 0xffffff) << 8))
241
242// RSRecordType
243#define RS_RECORD_TYPE_GET_NAME(R)  RS_CAST_TO_RECORD_TYPE(R)->name
244#define RS_RECORD_TYPE_SET_NAME(R, V) RS_RECORD_TYPE_GET_NAME(R) = (V)
245
246#define RS_RECORD_TYPE_GET_NUM_FIELDS(R)  \
247    ((RS_CAST_TO_RECORD_TYPE(R)->base.bits & 0xffff0000) >> 16)
248#define RS_RECORD_TYPE_SET_NUM_FIELDS(R, V) \
249    RS_CAST_TO_RECORD_TYPE(R)->base.bits =  \
250    ((RS_CAST_TO_RECORD_TYPE(R)->base.bits & 0x0000ffff) | ((V & 0xffff) << 16))
251
252#define RS_RECORD_TYPE_GET_FIELD_NAME(R, I) \
253    RS_CAST_TO_RECORD_TYPE(R)->field[(I)].name
254#define RS_RECORD_TYPE_SET_FIELD_NAME(R, I, V) \
255    RS_RECORD_TYPE_GET_FIELD_NAME(R, I) = (V)
256
257#define RS_RECORD_TYPE_GET_FIELD_TYPE(R, I) \
258    RS_CAST_TO_RECORD_TYPE(R)->field[(I)].type
259#define RS_RECORD_TYPE_SET_FIELD_TYPE(R, I, V) \
260    RS_RECORD_TYPE_GET_FIELD_TYPE(R, I) = (V)
261
262#define RS_RECORD_TYPE_GET_FIELD_DATA_KIND(R, I)  \
263    RS_CAST_TO_RECORD_TYPE(R)->field[(I)].dk
264#define RS_RECORD_TYPE_SET_FIELD_DATA_KIND(R, I, V) \
265    RS_RECORD_TYPE_GET_FIELD_DATA_KIND(R, I) = (V)
266
267#endif  // _COMPILE_SLANG_SLANG_RS_TYPE_SPEC_H_  NOLINT
268