rsCppStructs.h revision f558dab60d6131e22413d5c15d0f9b85bff8fb36 
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#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 {
27namespace RSC {
28
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
46    bool init() { return init(false); }
47    bool init(bool forceCpu);
48
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
59    void finish();
60
61 private:
62    bool init(int targetApi, bool forceCpu);
63    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();
223
224    void copy1DRangeFrom(uint32_t off, size_t count, const void *data);
225    void copy1DRangeFrom(uint32_t off, size_t count, sp<const Allocation> data, uint32_t dataOff);
226
227    void copy1DRangeTo(uint32_t off, size_t count, void *data);
228
229    void copy1DFrom(const void* data);
230    void copy1DTo(void* data);
231
232    void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
233                         const void *data);
234
235    void copy2DRangeTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
236                       void *data);
237
238    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);
240
241    void copy2DStridedFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
242                           const void *data, size_t stride);
243    void copy2DStridedFrom(const void *data, size_t stride);
244
245    void copy2DStridedTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
246                         void *data, size_t stride);
247    void copy2DStridedTo(void *data, size_t stride);
248
249    void resize(int dimX);
250    void resize(int dimX, int dimY);
251
252    static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
253                                   RsAllocationMipmapControl mips, uint32_t usage);
254    static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
255                                   RsAllocationMipmapControl mips, uint32_t usage, void * pointer);
256
257    static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
258                                   uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
259    static sp<Allocation> createSized(sp<RS> rs, sp<const Element> e, size_t count,
260                                   uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
261    static sp<Allocation> createSized2D(sp<RS> rs, sp<const Element> e,
262                                        size_t x, size_t y,
263                                        uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
264
265
266};
267
268class Element : public BaseObj {
269public:
270    bool isComplex();
271    size_t getSubElementCount() {
272        return mVisibleElementMap.size();
273    }
274
275    sp<const Element> getSubElement(uint32_t index);
276    const char * getSubElementName(uint32_t index);
277    size_t getSubElementArraySize(uint32_t index);
278    uint32_t getSubElementOffsetBytes(uint32_t index);
279    RsDataType getDataType() const {
280        return mType;
281    }
282
283    RsDataKind getDataKind() const {
284        return mKind;
285    }
286
287    size_t getSizeBytes() const {
288        return mSizeBytes;
289    }
290
291    static sp<const Element> BOOLEAN(sp<RS> rs);
292    static sp<const Element> U8(sp<RS> rs);
293    static sp<const Element> I8(sp<RS> rs);
294    static sp<const Element> U16(sp<RS> rs);
295    static sp<const Element> I16(sp<RS> rs);
296    static sp<const Element> U32(sp<RS> rs);
297    static sp<const Element> I32(sp<RS> rs);
298    static sp<const Element> U64(sp<RS> rs);
299    static sp<const Element> I64(sp<RS> rs);
300    static sp<const Element> F32(sp<RS> rs);
301    static sp<const Element> F64(sp<RS> rs);
302    static sp<const Element> ELEMENT(sp<RS> rs);
303    static sp<const Element> TYPE(sp<RS> rs);
304    static sp<const Element> ALLOCATION(sp<RS> rs);
305    static sp<const Element> SAMPLER(sp<RS> rs);
306    static sp<const Element> SCRIPT(sp<RS> rs);
307    static sp<const Element> MESH(sp<RS> rs);
308    static sp<const Element> PROGRAM_FRAGMENT(sp<RS> rs);
309    static sp<const Element> PROGRAM_VERTEX(sp<RS> rs);
310    static sp<const Element> PROGRAM_RASTER(sp<RS> rs);
311    static sp<const Element> PROGRAM_STORE(sp<RS> rs);
312
313    static sp<const Element> A_8(sp<RS> rs);
314    static sp<const Element> RGB_565(sp<RS> rs);
315    static sp<const Element> RGB_888(sp<RS> rs);
316    static sp<const Element> RGBA_5551(sp<RS> rs);
317    static sp<const Element> RGBA_4444(sp<RS> rs);
318    static sp<const Element> RGBA_8888(sp<RS> rs);
319
320    static sp<const Element> F32_2(sp<RS> rs);
321    static sp<const Element> F32_3(sp<RS> rs);
322    static sp<const Element> F32_4(sp<RS> rs);
323    static sp<const Element> F64_2(sp<RS> rs);
324    static sp<const Element> F64_3(sp<RS> rs);
325    static sp<const Element> F64_4(sp<RS> rs);
326    static sp<const Element> U8_2(sp<RS> rs);
327    static sp<const Element> U8_3(sp<RS> rs);
328    static sp<const Element> U8_4(sp<RS> rs);
329    static sp<const Element> I8_2(sp<RS> rs);
330    static sp<const Element> I8_3(sp<RS> rs);
331    static sp<const Element> I8_4(sp<RS> rs);
332    static sp<const Element> U16_2(sp<RS> rs);
333    static sp<const Element> U16_3(sp<RS> rs);
334    static sp<const Element> U16_4(sp<RS> rs);
335    static sp<const Element> I16_2(sp<RS> rs);
336    static sp<const Element> I16_3(sp<RS> rs);
337    static sp<const Element> I16_4(sp<RS> rs);
338    static sp<const Element> U32_2(sp<RS> rs);
339    static sp<const Element> U32_3(sp<RS> rs);
340    static sp<const Element> U32_4(sp<RS> rs);
341    static sp<const Element> I32_2(sp<RS> rs);
342    static sp<const Element> I32_3(sp<RS> rs);
343    static sp<const Element> I32_4(sp<RS> rs);
344    static sp<const Element> U64_2(sp<RS> rs);
345    static sp<const Element> U64_3(sp<RS> rs);
346    static sp<const Element> U64_4(sp<RS> rs);
347    static sp<const Element> I64_2(sp<RS> rs);
348    static sp<const Element> I64_3(sp<RS> rs);
349    static sp<const Element> I64_4(sp<RS> rs);
350    static sp<const Element> MATRIX_4X4(sp<RS> rs);
351    static sp<const Element> MATRIX_3X3(sp<RS> rs);
352    static sp<const Element> MATRIX_2X2(sp<RS> rs);
353
354    Element(void *id, sp<RS> rs,
355            android::Vector<sp<Element> > &elements,
356            android::Vector<android::String8> &elementNames,
357            android::Vector<uint32_t> &arraySizes);
358    Element(void *id, sp<RS> rs, RsDataType dt, RsDataKind dk, bool norm, uint32_t size);
359    Element(sp<RS> rs);
360    virtual ~Element();
361
362    void updateFromNative();
363    static sp<const Element> createUser(sp<RS> rs, RsDataType dt);
364    static sp<const Element> createVector(sp<RS> rs, RsDataType dt, uint32_t size);
365    static sp<const Element> createPixel(sp<RS> rs, RsDataType dt, RsDataKind dk);
366    bool isCompatible(sp<const Element>e);
367
368    class Builder {
369    private:
370        sp<RS> mRS;
371        android::Vector<sp<Element> > mElements;
372        android::Vector<android::String8> mElementNames;
373        android::Vector<uint32_t> mArraySizes;
374        bool mSkipPadding;
375
376    public:
377        Builder(sp<RS> rs);
378        ~Builder();
379        void add(sp<Element>, android::String8 &name, uint32_t arraySize = 1);
380        sp<const Element> create();
381    };
382
383private:
384    void updateVisibleSubElements();
385
386    android::Vector<sp</*const*/ Element> > mElements;
387    android::Vector<android::String8> mElementNames;
388    android::Vector<uint32_t> mArraySizes;
389    android::Vector<uint32_t> mVisibleElementMap;
390    android::Vector<uint32_t> mOffsetInBytes;
391
392    RsDataType mType;
393    RsDataKind mKind;
394    bool mNormalized;
395    size_t mSizeBytes;
396    size_t mVectorSize;
397};
398
399class FieldPacker {
400protected:
401    unsigned char* mData;
402    size_t mPos;
403    size_t mLen;
404
405public:
406    FieldPacker(size_t len)
407        : mPos(0),
408          mLen(len) {
409        mData = new unsigned char[len];
410    }
411
412    virtual ~FieldPacker() {
413        delete [] mData;
414    }
415
416    void align(size_t v) {
417        if ((v & (v - 1)) != 0) {
418            ALOGE("Non-power-of-two alignment: %zu", v);
419            return;
420        }
421
422        while ((mPos & (v - 1)) != 0) {
423            mData[mPos++] = 0;
424        }
425    }
426
427    void reset() {
428        mPos = 0;
429    }
430
431    void reset(size_t i) {
432        if (i >= mLen) {
433            ALOGE("Out of bounds: i (%zu) >= len (%zu)", i, mLen);
434            return;
435        }
436        mPos = i;
437    }
438
439    void skip(size_t i) {
440        size_t res = mPos + i;
441        if (res > mLen) {
442            ALOGE("Exceeded buffer length: i (%zu) > len (%zu)", i, mLen);
443            return;
444        }
445        mPos = res;
446    }
447
448    void* getData() const {
449        return mData;
450    }
451
452    size_t getLength() const {
453        return mLen;
454    }
455
456    template <typename T>
457    void add(T t) {
458        align(sizeof(t));
459        if (mPos + sizeof(t) <= mLen) {
460            memcpy(&mData[mPos], &t, sizeof(t));
461            mPos += sizeof(t);
462        }
463    }
464
465    /*
466    void add(rs_matrix4x4 m) {
467        for (size_t i = 0; i < 16; i++) {
468            add(m.m[i]);
469        }
470    }
471
472    void add(rs_matrix3x3 m) {
473        for (size_t i = 0; i < 9; i++) {
474            add(m.m[i]);
475        }
476    }
477
478    void add(rs_matrix2x2 m) {
479        for (size_t i = 0; i < 4; i++) {
480            add(m.m[i]);
481        }
482    }
483    */
484
485    void add(BaseObj* obj) {
486        if (obj != NULL) {
487            add((uint32_t) (uintptr_t) obj->getID());
488        } else {
489            add((uint32_t) 0);
490        }
491    }
492};
493
494class Type : public BaseObj {
495protected:
496    friend class Allocation;
497
498    uint32_t mDimX;
499    uint32_t mDimY;
500    uint32_t mDimZ;
501    bool mDimMipmaps;
502    bool mDimFaces;
503    size_t mElementCount;
504    sp<const Element> mElement;
505
506    void calcElementCount();
507    virtual void updateFromNative();
508
509public:
510
511    sp<const Element> getElement() const {
512        return mElement;
513    }
514
515    uint32_t getX() const {
516        return mDimX;
517    }
518
519    uint32_t getY() const {
520        return mDimY;
521    }
522
523    uint32_t getZ() const {
524        return mDimZ;
525    }
526
527    bool hasMipmaps() const {
528        return mDimMipmaps;
529    }
530
531    bool hasFaces() const {
532        return mDimFaces;
533    }
534
535    size_t getCount() const {
536        return mElementCount;
537    }
538
539    size_t getSizeBytes() const {
540        return mElementCount * mElement->getSizeBytes();
541    }
542
543    Type(void *id, sp<RS> rs);
544
545
546    class Builder {
547    protected:
548        sp<RS> mRS;
549        uint32_t mDimX;
550        uint32_t mDimY;
551        uint32_t mDimZ;
552        bool mDimMipmaps;
553        bool mDimFaces;
554        sp<const Element> mElement;
555
556    public:
557        Builder(sp<RS> rs, sp<const Element> e);
558
559        void setX(uint32_t value);
560        void setY(int value);
561        void setMipmaps(bool value);
562        void setFaces(bool value);
563        sp<const Type> create();
564    };
565
566};
567
568class Script : public BaseObj {
569private:
570
571protected:
572    Script(void *id, sp<RS> rs);
573    void forEach(uint32_t slot, sp<const Allocation> in, sp<const Allocation> out,
574            const void *v, size_t) const;
575    void bindAllocation(sp<Allocation> va, uint32_t slot) const;
576    void setVar(uint32_t index, const void *, size_t len) const;
577    void setVar(uint32_t index, sp<const BaseObj> o) const;
578    void invoke(uint32_t slot, const void *v, size_t len) const;
579
580
581    void invoke(uint32_t slot) const {
582        invoke(slot, NULL, 0);
583    }
584    void setVar(uint32_t index, float v) const {
585        setVar(index, &v, sizeof(v));
586    }
587    void setVar(uint32_t index, double v) const {
588        setVar(index, &v, sizeof(v));
589    }
590    void setVar(uint32_t index, int32_t v) const {
591        setVar(index, &v, sizeof(v));
592    }
593    void setVar(uint32_t index, int64_t v) const {
594        setVar(index, &v, sizeof(v));
595    }
596    void setVar(uint32_t index, bool v) const {
597        setVar(index, &v, sizeof(v));
598    }
599
600public:
601    class FieldBase {
602    protected:
603        sp<const Element> mElement;
604        sp<Allocation> mAllocation;
605
606        void init(sp<RS> rs, uint32_t dimx, uint32_t usages = 0);
607
608    public:
609        sp<const Element> getElement() {
610            return mElement;
611        }
612
613        sp<const Type> getType() {
614            return mAllocation->getType();
615        }
616
617        sp<const Allocation> getAllocation() {
618            return mAllocation;
619        }
620
621        //void updateAllocation();
622    };
623};
624
625class ScriptC : public Script {
626protected:
627    ScriptC(sp<RS> rs,
628            const void *codeTxt, size_t codeLength,
629            const char *cachedName, size_t cachedNameLength,
630            const char *cacheDir, size_t cacheDirLength);
631
632};
633
634class ScriptIntrinsic : public Script {
635 protected:
636    ScriptIntrinsic(sp<RS> rs, int id, sp<const Element> e);
637};
638
639class ScriptIntrinsicBlend : public ScriptIntrinsic {
640 public:
641    ScriptIntrinsicBlend(sp<RS> rs, sp <const Element> e);
642    void blendClear(sp<Allocation> in, sp<Allocation> out);
643    void blendSrc(sp<Allocation> in, sp<Allocation> out);
644    void blendDst(sp<Allocation> in, sp<Allocation> out);
645    void blendSrcOver(sp<Allocation> in, sp<Allocation> out);
646    void blendDstOver(sp<Allocation> in, sp<Allocation> out);
647    void blendSrcIn(sp<Allocation> in, sp<Allocation> out);
648    void blendDstIn(sp<Allocation> in, sp<Allocation> out);
649    void blendSrcOut(sp<Allocation> in, sp<Allocation> out);
650    void blendDstOut(sp<Allocation> in, sp<Allocation> out);
651    void blendSrcAtop(sp<Allocation> in, sp<Allocation> out);
652    void blendDstAtop(sp<Allocation> in, sp<Allocation> out);
653    void blendXor(sp<Allocation> in, sp<Allocation> out);
654    void blendMultiply(sp<Allocation> in, sp<Allocation> out);
655    void blendAdd(sp<Allocation> in, sp<Allocation> out);
656    void blendSubtract(sp<Allocation> in, sp<Allocation> out);
657};
658
659class ScriptIntrinsicBlur : public ScriptIntrinsic {
660 public:
661    ScriptIntrinsicBlur(sp<RS> rs, sp <const Element> e);
662    void blur(sp<Allocation> in, sp<Allocation> out);
663    void setRadius(float radius);
664};
665
666}
667
668}
669
670#endif
671