blob: 07231ab44e0bf33a3e777f675515edacd029856b [file] [log] [blame]
Tim Murray84bf2b82012-10-31 16:03:16 -07001/*
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#ifndef ANDROID_RSCPPSTRUCTS_H
18#define ANDROID_RSCPPSTRUCTS_H
19
20#include <utils/String8.h>
21#include <utils/Vector.h>
22#include "utils/RefBase.h"
23
24#include <rs.h>
25
26namespace android {
Tim Murray9eb7f4b2012-11-16 14:02:18 -080027namespace RSC {
Tim Murray84bf2b82012-10-31 16:03:16 -070028
29typedef void (*ErrorHandlerFunc_t)(uint32_t errorNum, const char *errorText);
30typedef void (*MessageHandlerFunc_t)(uint32_t msgNum, const void *msgData, size_t msgLen);
31
32class RS;
33class BaseObj;
34class Element;
35class Type;
36class Allocation;
37class Script;
38class ScriptC;
39
40class RS : public android::LightRefBase<RS> {
41
42 public:
43 RS();
44 virtual ~RS();
45
Tim Murray7e0acab2012-11-06 14:37:19 -080046 bool init() { return init(false); }
47 bool init(bool forceCpu);
Tim Murray84bf2b82012-10-31 16:03:16 -070048
49 void setErrorHandler(ErrorHandlerFunc_t func);
50 ErrorHandlerFunc_t getErrorHandler() { return mErrorFunc; }
51
52 void setMessageHandler(MessageHandlerFunc_t func);
53 MessageHandlerFunc_t getMessageHandler() { return mMessageFunc; }
54
55 void throwError(const char *err) const;
56
57 RsContext getContext() { return mContext; }
58
Tim Murraybaca6c32012-11-14 16:51:46 -080059 void finish();
60
Tim Murray84bf2b82012-10-31 16:03:16 -070061 private:
Tim Murray7e0acab2012-11-06 14:37:19 -080062 bool init(int targetApi, bool forceCpu);
Tim Murray84bf2b82012-10-31 16:03:16 -070063 static void * threadProc(void *);
64
65 static bool gInitialized;
66 static pthread_mutex_t gInitMutex;
67
68 pthread_t mMessageThreadId;
69 pid_t mNativeMessageThreadId;
70 bool mMessageRun;
71
72 RsDevice mDev;
73 RsContext mContext;
74
75 ErrorHandlerFunc_t mErrorFunc;
76 MessageHandlerFunc_t mMessageFunc;
77
78 struct {
79 Element *U8;
80 Element *I8;
81 Element *U16;
82 Element *I16;
83 Element *U32;
84 Element *I32;
85 Element *U64;
86 Element *I64;
87 Element *F32;
88 Element *F64;
89 Element *BOOLEAN;
90
91 Element *ELEMENT;
92 Element *TYPE;
93 Element *ALLOCATION;
94 Element *SAMPLER;
95 Element *SCRIPT;
96 Element *MESH;
97 Element *PROGRAM_FRAGMENT;
98 Element *PROGRAM_VERTEX;
99 Element *PROGRAM_RASTER;
100 Element *PROGRAM_STORE;
101
102 Element *A_8;
103 Element *RGB_565;
104 Element *RGB_888;
105 Element *RGBA_5551;
106 Element *RGBA_4444;
107 Element *RGBA_8888;
108
109 Element *FLOAT_2;
110 Element *FLOAT_3;
111 Element *FLOAT_4;
112
113 Element *DOUBLE_2;
114 Element *DOUBLE_3;
115 Element *DOUBLE_4;
116
117 Element *UCHAR_2;
118 Element *UCHAR_3;
119 Element *UCHAR_4;
120
121 Element *CHAR_2;
122 Element *CHAR_3;
123 Element *CHAR_4;
124
125 Element *USHORT_2;
126 Element *USHORT_3;
127 Element *USHORT_4;
128
129 Element *SHORT_2;
130 Element *SHORT_3;
131 Element *SHORT_4;
132
133 Element *UINT_2;
134 Element *UINT_3;
135 Element *UINT_4;
136
137 Element *INT_2;
138 Element *INT_3;
139 Element *INT_4;
140
141 Element *ULONG_2;
142 Element *ULONG_3;
143 Element *ULONG_4;
144
145 Element *LONG_2;
146 Element *LONG_3;
147 Element *LONG_4;
148
149 Element *MATRIX_4X4;
150 Element *MATRIX_3X3;
151 Element *MATRIX_2X2;
152 } mElements;
153
154};
155
156class BaseObj : public android::LightRefBase<BaseObj> {
157protected:
158 void *mID;
159 sp<RS> mRS;
160 String8 mName;
161
162 BaseObj(void *id, sp<RS> rs);
163 void checkValid();
164
165 static void * getObjID(sp<const BaseObj> o);
166
167public:
168
169 void * getID() const;
170 virtual ~BaseObj();
171 virtual void updateFromNative();
172 virtual bool equals(const BaseObj *obj);
173};
174
175
176class Allocation : public BaseObj {
177protected:
178 android::sp<const Type> mType;
179 uint32_t mUsage;
180 android::sp<Allocation> mAdaptedAllocation;
181
182 bool mConstrainedLOD;
183 bool mConstrainedFace;
184 bool mConstrainedY;
185 bool mConstrainedZ;
186 bool mReadAllowed;
187 bool mWriteAllowed;
188 uint32_t mSelectedY;
189 uint32_t mSelectedZ;
190 uint32_t mSelectedLOD;
191 RsAllocationCubemapFace mSelectedFace;
192
193 uint32_t mCurrentDimX;
194 uint32_t mCurrentDimY;
195 uint32_t mCurrentDimZ;
196 uint32_t mCurrentCount;
197
198 void * getIDSafe() const;
199 void updateCacheInfo(sp<const Type> t);
200
201 Allocation(void *id, sp<RS> rs, sp<const Type> t, uint32_t usage);
202
203 void validateIsInt32();
204 void validateIsInt16();
205 void validateIsInt8();
206 void validateIsFloat32();
207 void validateIsObject();
208
209 virtual void updateFromNative();
210
211 void validate2DRange(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h);
212
213public:
214 android::sp<const Type> getType() {
215 return mType;
216 }
217
218 void syncAll(RsAllocationUsageType srcLocation);
219 void ioSendOutput();
220 void ioGetInput();
221
222 void generateMipmaps();
Tim Murray509ea5c2012-11-13 11:56:40 -0800223
Tim Murray0b93e302012-11-15 14:56:54 -0800224 void copy1DRangeFrom(uint32_t off, size_t count, const void *data);
Tim Murraya4cbc2b2012-11-14 17:18:08 -0800225 void copy1DRangeFrom(uint32_t off, size_t count, sp<const Allocation> data, uint32_t dataOff);
Tim Murray84bf2b82012-10-31 16:03:16 -0700226
Tim Murray0b93e302012-11-15 14:56:54 -0800227 void copy1DRangeTo(uint32_t off, size_t count, void *data);
228
229 void copy1DFrom(const void* data);
230 void copy1DTo(void* data);
Tim Murraya4cbc2b2012-11-14 17:18:08 -0800231
Tim Murray84bf2b82012-10-31 16:03:16 -0700232 void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
Tim Murray0b93e302012-11-15 14:56:54 -0800233 const void *data);
Tim Murray7b3e3092012-11-16 13:32:24 -0800234
235 void copy2DRangeTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
236 void *data);
237
Tim Murray0b93e302012-11-15 14:56:54 -0800238 void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
239 sp<const Allocation> data, uint32_t dataXoff, uint32_t dataYoff);
Tim Murray84bf2b82012-10-31 16:03:16 -0700240
241 void resize(int dimX);
242 void resize(int dimX, int dimY);
243
244 static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
245 RsAllocationMipmapControl mips, uint32_t usage);
246 static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
247 RsAllocationMipmapControl mips, uint32_t usage, void * pointer);
248
249 static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
250 uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
251 static sp<Allocation> createSized(sp<RS> rs, sp<const Element> e, size_t count,
252 uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
Tim Murray684726c2012-11-14 11:57:42 -0800253 static sp<Allocation> createSized2D(sp<RS> rs, sp<const Element> e,
254 size_t x, size_t y,
255 uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
256
Tim Murray84bf2b82012-10-31 16:03:16 -0700257
258};
259
260class Element : public BaseObj {
261public:
262 bool isComplex();
263 size_t getSubElementCount() {
264 return mVisibleElementMap.size();
265 }
266
267 sp<const Element> getSubElement(uint32_t index);
268 const char * getSubElementName(uint32_t index);
269 size_t getSubElementArraySize(uint32_t index);
270 uint32_t getSubElementOffsetBytes(uint32_t index);
271 RsDataType getDataType() const {
272 return mType;
273 }
274
275 RsDataKind getDataKind() const {
276 return mKind;
277 }
278
279 size_t getSizeBytes() const {
280 return mSizeBytes;
281 }
282
283 static sp<const Element> BOOLEAN(sp<RS> rs);
284 static sp<const Element> U8(sp<RS> rs);
285 static sp<const Element> I8(sp<RS> rs);
286 static sp<const Element> U16(sp<RS> rs);
287 static sp<const Element> I16(sp<RS> rs);
288 static sp<const Element> U32(sp<RS> rs);
289 static sp<const Element> I32(sp<RS> rs);
290 static sp<const Element> U64(sp<RS> rs);
291 static sp<const Element> I64(sp<RS> rs);
292 static sp<const Element> F32(sp<RS> rs);
293 static sp<const Element> F64(sp<RS> rs);
294 static sp<const Element> ELEMENT(sp<RS> rs);
295 static sp<const Element> TYPE(sp<RS> rs);
296 static sp<const Element> ALLOCATION(sp<RS> rs);
297 static sp<const Element> SAMPLER(sp<RS> rs);
298 static sp<const Element> SCRIPT(sp<RS> rs);
299 static sp<const Element> MESH(sp<RS> rs);
300 static sp<const Element> PROGRAM_FRAGMENT(sp<RS> rs);
301 static sp<const Element> PROGRAM_VERTEX(sp<RS> rs);
302 static sp<const Element> PROGRAM_RASTER(sp<RS> rs);
303 static sp<const Element> PROGRAM_STORE(sp<RS> rs);
304
305 static sp<const Element> A_8(sp<RS> rs);
306 static sp<const Element> RGB_565(sp<RS> rs);
307 static sp<const Element> RGB_888(sp<RS> rs);
308 static sp<const Element> RGBA_5551(sp<RS> rs);
309 static sp<const Element> RGBA_4444(sp<RS> rs);
310 static sp<const Element> RGBA_8888(sp<RS> rs);
311
312 static sp<const Element> F32_2(sp<RS> rs);
313 static sp<const Element> F32_3(sp<RS> rs);
314 static sp<const Element> F32_4(sp<RS> rs);
315 static sp<const Element> F64_2(sp<RS> rs);
316 static sp<const Element> F64_3(sp<RS> rs);
317 static sp<const Element> F64_4(sp<RS> rs);
318 static sp<const Element> U8_2(sp<RS> rs);
319 static sp<const Element> U8_3(sp<RS> rs);
320 static sp<const Element> U8_4(sp<RS> rs);
321 static sp<const Element> I8_2(sp<RS> rs);
322 static sp<const Element> I8_3(sp<RS> rs);
323 static sp<const Element> I8_4(sp<RS> rs);
324 static sp<const Element> U16_2(sp<RS> rs);
325 static sp<const Element> U16_3(sp<RS> rs);
326 static sp<const Element> U16_4(sp<RS> rs);
327 static sp<const Element> I16_2(sp<RS> rs);
328 static sp<const Element> I16_3(sp<RS> rs);
329 static sp<const Element> I16_4(sp<RS> rs);
330 static sp<const Element> U32_2(sp<RS> rs);
331 static sp<const Element> U32_3(sp<RS> rs);
332 static sp<const Element> U32_4(sp<RS> rs);
333 static sp<const Element> I32_2(sp<RS> rs);
334 static sp<const Element> I32_3(sp<RS> rs);
335 static sp<const Element> I32_4(sp<RS> rs);
336 static sp<const Element> U64_2(sp<RS> rs);
337 static sp<const Element> U64_3(sp<RS> rs);
338 static sp<const Element> U64_4(sp<RS> rs);
339 static sp<const Element> I64_2(sp<RS> rs);
340 static sp<const Element> I64_3(sp<RS> rs);
341 static sp<const Element> I64_4(sp<RS> rs);
342 static sp<const Element> MATRIX_4X4(sp<RS> rs);
343 static sp<const Element> MATRIX_3X3(sp<RS> rs);
344 static sp<const Element> MATRIX_2X2(sp<RS> rs);
345
346 Element(void *id, sp<RS> rs,
347 android::Vector<sp<Element> > &elements,
348 android::Vector<android::String8> &elementNames,
349 android::Vector<uint32_t> &arraySizes);
350 Element(void *id, sp<RS> rs, RsDataType dt, RsDataKind dk, bool norm, uint32_t size);
351 Element(sp<RS> rs);
352 virtual ~Element();
353
354 void updateFromNative();
355 static sp<const Element> createUser(sp<RS> rs, RsDataType dt);
356 static sp<const Element> createVector(sp<RS> rs, RsDataType dt, uint32_t size);
357 static sp<const Element> createPixel(sp<RS> rs, RsDataType dt, RsDataKind dk);
358 bool isCompatible(sp<const Element>e);
359
360 class Builder {
361 private:
362 sp<RS> mRS;
363 android::Vector<sp<Element> > mElements;
364 android::Vector<android::String8> mElementNames;
365 android::Vector<uint32_t> mArraySizes;
366 bool mSkipPadding;
367
368 public:
369 Builder(sp<RS> rs);
370 ~Builder();
371 void add(sp<Element>, android::String8 &name, uint32_t arraySize = 1);
372 sp<const Element> create();
373 };
374
375private:
376 void updateVisibleSubElements();
377
378 android::Vector<sp</*const*/ Element> > mElements;
379 android::Vector<android::String8> mElementNames;
380 android::Vector<uint32_t> mArraySizes;
381 android::Vector<uint32_t> mVisibleElementMap;
382 android::Vector<uint32_t> mOffsetInBytes;
383
384 RsDataType mType;
385 RsDataKind mKind;
386 bool mNormalized;
387 size_t mSizeBytes;
388 size_t mVectorSize;
389};
390
Stephen Hines2c7206e2012-11-14 19:47:01 -0800391class FieldPacker {
392protected:
393 unsigned char* mData;
394 size_t mPos;
395 size_t mLen;
396
397public:
398 FieldPacker(size_t len)
399 : mPos(0),
400 mLen(len) {
401 mData = new unsigned char[len];
402 }
403
404 virtual ~FieldPacker() {
405 delete [] mData;
406 }
407
408 void align(size_t v) {
409 if ((v & (v - 1)) != 0) {
410 ALOGE("Non-power-of-two alignment: %zu", v);
411 return;
412 }
413
414 while ((mPos & (v - 1)) != 0) {
415 mData[mPos++] = 0;
416 }
417 }
418
419 void reset() {
420 mPos = 0;
421 }
422
423 void reset(size_t i) {
424 if (i >= mLen) {
425 ALOGE("Out of bounds: i (%zu) >= len (%zu)", i, mLen);
426 return;
427 }
428 mPos = i;
429 }
430
431 void skip(size_t i) {
432 size_t res = mPos + i;
433 if (res > mLen) {
434 ALOGE("Exceeded buffer length: i (%zu) > len (%zu)", i, mLen);
435 return;
436 }
437 mPos = res;
438 }
439
440 void* getData() const {
441 return mData;
442 }
443
444 size_t getLength() const {
445 return mLen;
446 }
447
448 template <typename T>
449 void add(T t) {
450 align(sizeof(t));
451 if (mPos + sizeof(t) <= mLen) {
452 memcpy(&mData[mPos], &t, sizeof(t));
453 mPos += sizeof(t);
454 }
455 }
Stephen Hines43514cd2012-11-16 14:33:47 -0800456
457 /*
458 void add(rs_matrix4x4 m) {
459 for (size_t i = 0; i < 16; i++) {
460 add(m.m[i]);
461 }
462 }
463
464 void add(rs_matrix3x3 m) {
465 for (size_t i = 0; i < 9; i++) {
466 add(m.m[i]);
467 }
468 }
469
470 void add(rs_matrix2x2 m) {
471 for (size_t i = 0; i < 4; i++) {
472 add(m.m[i]);
473 }
474 }
475 */
476
477 void add(BaseObj* obj) {
478 if (obj != NULL) {
479 add((uint32_t) (uintptr_t) obj->getID());
480 } else {
481 add((uint32_t) 0);
482 }
483 }
Stephen Hines2c7206e2012-11-14 19:47:01 -0800484};
485
Tim Murray84bf2b82012-10-31 16:03:16 -0700486class Type : public BaseObj {
487protected:
488 friend class Allocation;
489
490 uint32_t mDimX;
491 uint32_t mDimY;
492 uint32_t mDimZ;
493 bool mDimMipmaps;
494 bool mDimFaces;
495 size_t mElementCount;
496 sp<const Element> mElement;
497
498 void calcElementCount();
499 virtual void updateFromNative();
500
501public:
502
503 sp<const Element> getElement() const {
504 return mElement;
505 }
506
507 uint32_t getX() const {
508 return mDimX;
509 }
510
511 uint32_t getY() const {
512 return mDimY;
513 }
514
515 uint32_t getZ() const {
516 return mDimZ;
517 }
518
519 bool hasMipmaps() const {
520 return mDimMipmaps;
521 }
522
523 bool hasFaces() const {
524 return mDimFaces;
525 }
526
527 size_t getCount() const {
528 return mElementCount;
529 }
530
531 size_t getSizeBytes() const {
532 return mElementCount * mElement->getSizeBytes();
533 }
534
535 Type(void *id, sp<RS> rs);
536
537
538 class Builder {
539 protected:
540 sp<RS> mRS;
541 uint32_t mDimX;
542 uint32_t mDimY;
543 uint32_t mDimZ;
544 bool mDimMipmaps;
545 bool mDimFaces;
546 sp<const Element> mElement;
547
548 public:
549 Builder(sp<RS> rs, sp<const Element> e);
550
551 void setX(uint32_t value);
552 void setY(int value);
553 void setMipmaps(bool value);
554 void setFaces(bool value);
555 sp<const Type> create();
556 };
557
558};
559
560class Script : public BaseObj {
561private:
562
563protected:
564 Script(void *id, sp<RS> rs);
565 void forEach(uint32_t slot, sp<const Allocation> in, sp<const Allocation> out,
566 const void *v, size_t) const;
567 void bindAllocation(sp<Allocation> va, uint32_t slot) const;
568 void setVar(uint32_t index, const void *, size_t len) const;
569 void setVar(uint32_t index, sp<const BaseObj> o) const;
570 void invoke(uint32_t slot, const void *v, size_t len) const;
571
572
573 void invoke(uint32_t slot) const {
574 invoke(slot, NULL, 0);
575 }
576 void setVar(uint32_t index, float v) const {
577 setVar(index, &v, sizeof(v));
578 }
579 void setVar(uint32_t index, double v) const {
580 setVar(index, &v, sizeof(v));
581 }
582 void setVar(uint32_t index, int32_t v) const {
583 setVar(index, &v, sizeof(v));
584 }
585 void setVar(uint32_t index, int64_t v) const {
586 setVar(index, &v, sizeof(v));
587 }
588 void setVar(uint32_t index, bool v) const {
589 setVar(index, &v, sizeof(v));
590 }
591
592public:
593 class FieldBase {
594 protected:
595 sp<const Element> mElement;
596 sp<Allocation> mAllocation;
597
598 void init(sp<RS> rs, uint32_t dimx, uint32_t usages = 0);
599
600 public:
601 sp<const Element> getElement() {
602 return mElement;
603 }
604
605 sp<const Type> getType() {
606 return mAllocation->getType();
607 }
608
609 sp<const Allocation> getAllocation() {
610 return mAllocation;
611 }
612
613 //void updateAllocation();
614 };
615};
616
617class ScriptC : public Script {
618protected:
619 ScriptC(sp<RS> rs,
620 const void *codeTxt, size_t codeLength,
621 const char *cachedName, size_t cachedNameLength,
622 const char *cacheDir, size_t cacheDirLength);
623
624};
625
Tim Murray7f0d5682012-11-08 16:35:24 -0800626class ScriptIntrinsic : public Script {
627 protected:
Tim Murray3cd44af2012-11-14 11:25:27 -0800628 ScriptIntrinsic(sp<RS> rs, int id, sp<const Element> e);
Tim Murray7f0d5682012-11-08 16:35:24 -0800629};
630
631class ScriptIntrinsicBlend : public ScriptIntrinsic {
632 public:
Tim Murray3cd44af2012-11-14 11:25:27 -0800633 ScriptIntrinsicBlend(sp<RS> rs, sp <const Element> e);
Tim Murray7f0d5682012-11-08 16:35:24 -0800634 void blendClear(sp<Allocation> in, sp<Allocation> out);
635 void blendSrc(sp<Allocation> in, sp<Allocation> out);
636 void blendDst(sp<Allocation> in, sp<Allocation> out);
637 void blendSrcOver(sp<Allocation> in, sp<Allocation> out);
638 void blendDstOver(sp<Allocation> in, sp<Allocation> out);
639 void blendSrcIn(sp<Allocation> in, sp<Allocation> out);
640 void blendDstIn(sp<Allocation> in, sp<Allocation> out);
641 void blendSrcOut(sp<Allocation> in, sp<Allocation> out);
642 void blendDstOut(sp<Allocation> in, sp<Allocation> out);
643 void blendSrcAtop(sp<Allocation> in, sp<Allocation> out);
644 void blendDstAtop(sp<Allocation> in, sp<Allocation> out);
645 void blendXor(sp<Allocation> in, sp<Allocation> out);
646 void blendMultiply(sp<Allocation> in, sp<Allocation> out);
647 void blendAdd(sp<Allocation> in, sp<Allocation> out);
648 void blendSubtract(sp<Allocation> in, sp<Allocation> out);
649};
Tim Murray84bf2b82012-10-31 16:03:16 -0700650
Tim Murray8f1e60c2012-11-13 12:25:11 -0800651class ScriptIntrinsicBlur : public ScriptIntrinsic {
652 public:
Tim Murray3cd44af2012-11-14 11:25:27 -0800653 ScriptIntrinsicBlur(sp<RS> rs, sp <const Element> e);
Tim Murray8f1e60c2012-11-13 12:25:11 -0800654 void blur(sp<Allocation> in, sp<Allocation> out);
655 void setRadius(float radius);
656};
657
Tim Murray84bf2b82012-10-31 16:03:16 -0700658}
Tim Murray7f0d5682012-11-08 16:35:24 -0800659
Tim Murray84bf2b82012-10-31 16:03:16 -0700660}
661
662#endif