rsCppStructs.h revision a180b7d58ac6da9d6da866e43aa8c1fa83923dc5 
1/*
2 * Copyright (C) 2013 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 "rsDefines.h"
21#include "rsCppUtils.h"
22#include "util/RefBase.h"
23#include "rsDispatch.h"
24
25#include <vector>
26#include <string>
27
28// Every row in an RS allocation is guaranteed to be aligned by this amount
29// Every row in a user-backed allocation must be aligned by this amount
30#define RS_CPU_ALLOCATION_ALIGNMENT 16
31
32namespace android {
33namespace RSC {
34
35typedef void (*ErrorHandlerFunc_t)(uint32_t errorNum, const char *errorText);
36typedef void (*MessageHandlerFunc_t)(uint32_t msgNum, const void *msgData, size_t msgLen);
37
38class RS;
39class BaseObj;
40class Element;
41class Type;
42class Allocation;
43class Script;
44class ScriptC;
45class Sampler;
46
47 enum RSError {
48     RS_SUCCESS = 0,
49     RS_ERROR_INVALID_PARAMETER = 1,
50     RS_ERROR_RUNTIME_ERROR = 2,
51     RS_ERROR_INVALID_ELEMENT = 3,
52     RS_ERROR_MAX = 9999
53
54 };
55
56 class RS : public android::RSC::LightRefBase<RS> {
57
58 public:
59    RS();
60    virtual ~RS();
61
62    bool init(bool forceCpu = false, bool synchronous = false);
63
64    void setErrorHandler(ErrorHandlerFunc_t func);
65    ErrorHandlerFunc_t getErrorHandler() { return mErrorFunc; }
66
67    void setMessageHandler(MessageHandlerFunc_t func);
68    MessageHandlerFunc_t getMessageHandler() { return mMessageFunc; }
69
70    void throwError(RSError error, const char *errMsg);
71    RSError getError();
72
73    RsContext getContext() { return mContext; }
74
75    void finish();
76
77    static dispatchTable* dispatch;
78
79 private:
80    static bool usingNative;
81    static bool initDispatch(int targetApi);
82
83    bool init(int targetApi, bool forceCpu, bool synchronous);
84    static void * threadProc(void *);
85
86    static bool gInitialized;
87    static pthread_mutex_t gInitMutex;
88
89    pthread_t mMessageThreadId;
90    pid_t mNativeMessageThreadId;
91    bool mMessageRun;
92
93    RsDevice mDev;
94    RsContext mContext;
95    RSError mCurrentError;
96
97    ErrorHandlerFunc_t mErrorFunc;
98    MessageHandlerFunc_t mMessageFunc;
99    bool mInit;
100
101    struct {
102        sp<const Element> U8;
103        sp<const Element> I8;
104        sp<const Element> U16;
105        sp<const Element> I16;
106        sp<const Element> U32;
107        sp<const Element> I32;
108        sp<const Element> U64;
109        sp<const Element> I64;
110        sp<const Element> F32;
111        sp<const Element> F64;
112        sp<const Element> BOOLEAN;
113
114        sp<const Element> ELEMENT;
115        sp<const Element> TYPE;
116        sp<const Element> ALLOCATION;
117        sp<const Element> SAMPLER;
118        sp<const Element> SCRIPT;
119        sp<const Element> MESH;
120        sp<const Element> PROGRAM_FRAGMENT;
121        sp<const Element> PROGRAM_VERTEX;
122        sp<const Element> PROGRAM_RASTER;
123        sp<const Element> PROGRAM_STORE;
124
125        sp<const Element> A_8;
126        sp<const Element> RGB_565;
127        sp<const Element> RGB_888;
128        sp<const Element> RGBA_5551;
129        sp<const Element> RGBA_4444;
130        sp<const Element> RGBA_8888;
131
132        sp<const Element> FLOAT_2;
133        sp<const Element> FLOAT_3;
134        sp<const Element> FLOAT_4;
135
136        sp<const Element> DOUBLE_2;
137        sp<const Element> DOUBLE_3;
138        sp<const Element> DOUBLE_4;
139
140        sp<const Element> UCHAR_2;
141        sp<const Element> UCHAR_3;
142        sp<const Element> UCHAR_4;
143
144        sp<const Element> CHAR_2;
145        sp<const Element> CHAR_3;
146        sp<const Element> CHAR_4;
147
148        sp<const Element> USHORT_2;
149        sp<const Element> USHORT_3;
150        sp<const Element> USHORT_4;
151
152        sp<const Element> SHORT_2;
153        sp<const Element> SHORT_3;
154        sp<const Element> SHORT_4;
155
156        sp<const Element> UINT_2;
157        sp<const Element> UINT_3;
158        sp<const Element> UINT_4;
159
160        sp<const Element> INT_2;
161        sp<const Element> INT_3;
162        sp<const Element> INT_4;
163
164        sp<const Element> ULONG_2;
165        sp<const Element> ULONG_3;
166        sp<const Element> ULONG_4;
167
168        sp<const Element> LONG_2;
169        sp<const Element> LONG_3;
170        sp<const Element> LONG_4;
171
172        sp<const Element> MATRIX_4X4;
173        sp<const Element> MATRIX_3X3;
174        sp<const Element> MATRIX_2X2;
175    } mElements;
176
177    struct {
178        sp<const Sampler> CLAMP_NEAREST;
179        sp<const Sampler> CLAMP_LINEAR;
180        sp<const Sampler> CLAMP_LINEAR_MIP_LINEAR;
181        sp<const Sampler> WRAP_NEAREST;
182        sp<const Sampler> WRAP_LINEAR;
183        sp<const Sampler> WRAP_LINEAR_MIP_LINEAR;
184        sp<const Sampler> MIRRORED_REPEAT_NEAREST;
185        sp<const Sampler> MIRRORED_REPEAT_LINEAR;
186        sp<const Sampler> MIRRORED_REPEAT_LINEAR_MIP_LINEAR;
187    } mSamplers;
188    friend class Sampler;
189    friend class Element;
190};
191
192class BaseObj : public android::RSC::LightRefBase<BaseObj> {
193public:
194    void * getID() const;
195    virtual ~BaseObj();
196    virtual void updateFromNative();
197    virtual bool equals(sp<const BaseObj> obj);
198
199protected:
200    void *mID;
201    sp<RS> mRS;
202    std::string mName;
203
204    BaseObj(void *id, sp<RS> rs);
205    void checkValid();
206
207    static void * getObjID(sp<const BaseObj> o);
208
209};
210
211
212class Allocation : public BaseObj {
213protected:
214    sp<const Type> mType;
215    uint32_t mUsage;
216    sp<Allocation> mAdaptedAllocation;
217
218    bool mConstrainedLOD;
219    bool mConstrainedFace;
220    bool mConstrainedY;
221    bool mConstrainedZ;
222    bool mReadAllowed;
223    bool mWriteAllowed;
224    uint32_t mSelectedY;
225    uint32_t mSelectedZ;
226    uint32_t mSelectedLOD;
227    RsAllocationCubemapFace mSelectedFace;
228
229    uint32_t mCurrentDimX;
230    uint32_t mCurrentDimY;
231    uint32_t mCurrentDimZ;
232    uint32_t mCurrentCount;
233
234    void * getIDSafe() const;
235    void updateCacheInfo(sp<const Type> t);
236
237    Allocation(void *id, sp<RS> rs, sp<const Type> t, uint32_t usage);
238
239    void validateIsInt32();
240    void validateIsInt16();
241    void validateIsInt8();
242    void validateIsFloat32();
243    void validateIsObject();
244
245    virtual void updateFromNative();
246
247    void validate2DRange(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h);
248
249public:
250    sp<const Type> getType() const {
251        return mType;
252    }
253
254    void syncAll(RsAllocationUsageType srcLocation);
255    void ioSendOutput();
256    void ioGetInput();
257
258    void generateMipmaps();
259
260    void copy1DRangeFrom(uint32_t off, size_t count, const void *data);
261    void copy1DRangeFrom(uint32_t off, size_t count, sp<const Allocation> data, uint32_t dataOff);
262
263    void copy1DRangeTo(uint32_t off, size_t count, void *data);
264
265    void copy1DFrom(const void* data);
266    void copy1DTo(void* data);
267
268    void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
269                         const void *data);
270
271    void copy2DRangeTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
272                       void *data);
273
274    void copy2DRangeFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
275                         sp<const Allocation> data, uint32_t dataXoff, uint32_t dataYoff);
276
277    void copy2DStridedFrom(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
278                           const void *data, size_t stride);
279    void copy2DStridedFrom(const void *data, size_t stride);
280
281    void copy2DStridedTo(uint32_t xoff, uint32_t yoff, uint32_t w, uint32_t h,
282                         void *data, size_t stride);
283    void copy2DStridedTo(void *data, size_t stride);
284
285    void resize(int dimX);
286    void resize(int dimX, int dimY);
287
288    static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
289                                   RsAllocationMipmapControl mips, uint32_t usage);
290    static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
291                                   RsAllocationMipmapControl mips, uint32_t usage, void * pointer);
292
293    static sp<Allocation> createTyped(sp<RS> rs, sp<const Type> type,
294                                   uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
295    static sp<Allocation> createSized(sp<RS> rs, sp<const Element> e, size_t count,
296                                   uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
297    static sp<Allocation> createSized2D(sp<RS> rs, sp<const Element> e,
298                                        size_t x, size_t y,
299                                        uint32_t usage = RS_ALLOCATION_USAGE_SCRIPT);
300
301
302};
303
304class Element : public BaseObj {
305public:
306    bool isComplex();
307    size_t getSubElementCount() {
308        return mVisibleElementMap.size();
309    }
310
311    sp<const Element> getSubElement(uint32_t index);
312    const char * getSubElementName(uint32_t index);
313    size_t getSubElementArraySize(uint32_t index);
314    uint32_t getSubElementOffsetBytes(uint32_t index);
315    RsDataType getDataType() const {
316        return mType;
317    }
318
319    RsDataKind getDataKind() const {
320        return mKind;
321    }
322
323    size_t getSizeBytes() const {
324        return mSizeBytes;
325    }
326
327    uint32_t getVectorSize() const {
328        return mVectorSize;
329    }
330
331    static sp<const Element> BOOLEAN(sp<RS> rs);
332    static sp<const Element> U8(sp<RS> rs);
333    static sp<const Element> I8(sp<RS> rs);
334    static sp<const Element> U16(sp<RS> rs);
335    static sp<const Element> I16(sp<RS> rs);
336    static sp<const Element> U32(sp<RS> rs);
337    static sp<const Element> I32(sp<RS> rs);
338    static sp<const Element> U64(sp<RS> rs);
339    static sp<const Element> I64(sp<RS> rs);
340    static sp<const Element> F32(sp<RS> rs);
341    static sp<const Element> F64(sp<RS> rs);
342    static sp<const Element> ELEMENT(sp<RS> rs);
343    static sp<const Element> TYPE(sp<RS> rs);
344    static sp<const Element> ALLOCATION(sp<RS> rs);
345    static sp<const Element> SAMPLER(sp<RS> rs);
346    static sp<const Element> SCRIPT(sp<RS> rs);
347    static sp<const Element> MESH(sp<RS> rs);
348    static sp<const Element> PROGRAM_FRAGMENT(sp<RS> rs);
349    static sp<const Element> PROGRAM_VERTEX(sp<RS> rs);
350    static sp<const Element> PROGRAM_RASTER(sp<RS> rs);
351    static sp<const Element> PROGRAM_STORE(sp<RS> rs);
352
353    static sp<const Element> A_8(sp<RS> rs);
354    static sp<const Element> RGB_565(sp<RS> rs);
355    static sp<const Element> RGB_888(sp<RS> rs);
356    static sp<const Element> RGBA_5551(sp<RS> rs);
357    static sp<const Element> RGBA_4444(sp<RS> rs);
358    static sp<const Element> RGBA_8888(sp<RS> rs);
359
360    static sp<const Element> F32_2(sp<RS> rs);
361    static sp<const Element> F32_3(sp<RS> rs);
362    static sp<const Element> F32_4(sp<RS> rs);
363    static sp<const Element> F64_2(sp<RS> rs);
364    static sp<const Element> F64_3(sp<RS> rs);
365    static sp<const Element> F64_4(sp<RS> rs);
366    static sp<const Element> U8_2(sp<RS> rs);
367    static sp<const Element> U8_3(sp<RS> rs);
368    static sp<const Element> U8_4(sp<RS> rs);
369    static sp<const Element> I8_2(sp<RS> rs);
370    static sp<const Element> I8_3(sp<RS> rs);
371    static sp<const Element> I8_4(sp<RS> rs);
372    static sp<const Element> U16_2(sp<RS> rs);
373    static sp<const Element> U16_3(sp<RS> rs);
374    static sp<const Element> U16_4(sp<RS> rs);
375    static sp<const Element> I16_2(sp<RS> rs);
376    static sp<const Element> I16_3(sp<RS> rs);
377    static sp<const Element> I16_4(sp<RS> rs);
378    static sp<const Element> U32_2(sp<RS> rs);
379    static sp<const Element> U32_3(sp<RS> rs);
380    static sp<const Element> U32_4(sp<RS> rs);
381    static sp<const Element> I32_2(sp<RS> rs);
382    static sp<const Element> I32_3(sp<RS> rs);
383    static sp<const Element> I32_4(sp<RS> rs);
384    static sp<const Element> U64_2(sp<RS> rs);
385    static sp<const Element> U64_3(sp<RS> rs);
386    static sp<const Element> U64_4(sp<RS> rs);
387    static sp<const Element> I64_2(sp<RS> rs);
388    static sp<const Element> I64_3(sp<RS> rs);
389    static sp<const Element> I64_4(sp<RS> rs);
390    static sp<const Element> MATRIX_4X4(sp<RS> rs);
391    static sp<const Element> MATRIX_3X3(sp<RS> rs);
392    static sp<const Element> MATRIX_2X2(sp<RS> rs);
393
394    void updateFromNative();
395    static sp<const Element> createUser(sp<RS> rs, RsDataType dt);
396    static sp<const Element> createVector(sp<RS> rs, RsDataType dt, uint32_t size);
397    static sp<const Element> createPixel(sp<RS> rs, RsDataType dt, RsDataKind dk);
398    bool isCompatible(sp<const Element>e) const;
399
400    Element(void *id, sp<RS> rs,
401            std::vector<sp<Element> > &elements,
402            std::vector<std::string> &elementNames,
403            std::vector<uint32_t> &arraySizes);
404    Element(void *id, sp<RS> rs, RsDataType dt, RsDataKind dk, bool norm, uint32_t size);
405    Element(sp<RS> rs);
406    virtual ~Element();
407
408 protected:
409    class Builder {
410    private:
411        sp<RS> mRS;
412        std::vector<sp<Element> > mElements;
413        std::vector<std::string> mElementNames;
414        std::vector<uint32_t> mArraySizes;
415        bool mSkipPadding;
416
417    public:
418        Builder(sp<RS> rs);
419        ~Builder();
420        void add(sp<Element> e, std::string &name, uint32_t arraySize = 1);
421        sp<const Element> create();
422    };
423
424private:
425    void updateVisibleSubElements();
426
427    std::vector<sp<Element> > mElements;
428    std::vector<std::string> mElementNames;
429    std::vector<uint32_t> mArraySizes;
430    std::vector<uint32_t> mVisibleElementMap;
431    std::vector<uint32_t> mOffsetInBytes;
432
433    RsDataType mType;
434    RsDataKind mKind;
435    bool mNormalized;
436    size_t mSizeBytes;
437    size_t mVectorSize;
438};
439
440class FieldPacker {
441protected:
442    unsigned char* mData;
443    size_t mPos;
444    size_t mLen;
445
446public:
447    FieldPacker(size_t len)
448        : mPos(0), mLen(len) {
449            mData = new unsigned char[len];
450        }
451
452    virtual ~FieldPacker() {
453        delete [] mData;
454    }
455
456    void align(size_t v) {
457        if ((v & (v - 1)) != 0) {
458            //            ALOGE("Non-power-of-two alignment: %zu", v);
459            return;
460        }
461
462        while ((mPos & (v - 1)) != 0) {
463            mData[mPos++] = 0;
464        }
465    }
466
467    void reset() {
468        mPos = 0;
469    }
470
471    void reset(size_t i) {
472        if (i >= mLen) {
473            //            ALOGE("Out of bounds: i (%zu) >= len (%zu)", i, mLen);
474            return;
475        }
476        mPos = i;
477    }
478
479    void skip(size_t i) {
480        size_t res = mPos + i;
481        if (res > mLen) {
482            //            ALOGE("Exceeded buffer length: i (%zu) > len (%zu)", i, mLen);
483            return;
484        }
485        mPos = res;
486    }
487
488    void* getData() const {
489        return mData;
490    }
491
492    size_t getLength() const {
493        return mLen;
494    }
495
496    template <typename T>
497        void add(T t) {
498        align(sizeof(t));
499        if (mPos + sizeof(t) <= mLen) {
500            memcpy(&mData[mPos], &t, sizeof(t));
501            mPos += sizeof(t);
502        }
503    }
504
505    /*
506      void add(rs_matrix4x4 m) {
507      for (size_t i = 0; i < 16; i++) {
508      add(m.m[i]);
509      }
510      }
511
512      void add(rs_matrix3x3 m) {
513      for (size_t i = 0; i < 9; i++) {
514      add(m.m[i]);
515      }
516      }
517
518      void add(rs_matrix2x2 m) {
519      for (size_t i = 0; i < 4; i++) {
520      add(m.m[i]);
521      }
522      }
523    */
524
525    void add(sp<BaseObj> obj) {
526        if (obj != NULL) {
527            add((uint32_t) (uintptr_t) obj->getID());
528        } else {
529            add((uint32_t) 0);
530        }
531    }
532};
533
534
535class Type : public BaseObj {
536protected:
537    friend class Allocation;
538
539    uint32_t mDimX;
540    uint32_t mDimY;
541    uint32_t mDimZ;
542    bool mDimMipmaps;
543    bool mDimFaces;
544    size_t mElementCount;
545    sp<const Element> mElement;
546
547    void calcElementCount();
548    virtual void updateFromNative();
549
550public:
551
552    sp<const Element> getElement() const {
553        return mElement;
554    }
555
556    uint32_t getX() const {
557        return mDimX;
558    }
559
560    uint32_t getY() const {
561        return mDimY;
562    }
563
564    uint32_t getZ() const {
565        return mDimZ;
566    }
567
568    bool hasMipmaps() const {
569        return mDimMipmaps;
570    }
571
572    bool hasFaces() const {
573        return mDimFaces;
574    }
575
576    size_t getCount() const {
577        return mElementCount;
578    }
579
580    size_t getSizeBytes() const {
581        return mElementCount * mElement->getSizeBytes();
582    }
583
584    Type(void *id, sp<RS> rs);
585
586    static sp<const Type> create(sp<RS> rs, sp<const Element> e, uint32_t dimX, uint32_t dimY, uint32_t dimZ);
587
588    class Builder {
589    protected:
590        sp<RS> mRS;
591        uint32_t mDimX;
592        uint32_t mDimY;
593        uint32_t mDimZ;
594        bool mDimMipmaps;
595        bool mDimFaces;
596        sp<const Element> mElement;
597
598    public:
599        Builder(sp<RS> rs, sp<const Element> e);
600
601        void setX(uint32_t value);
602        void setY(int value);
603        void setMipmaps(bool value);
604        void setFaces(bool value);
605        sp<const Type> create();
606    };
607
608};
609
610class Script : public BaseObj {
611private:
612
613protected:
614    Script(void *id, sp<RS> rs);
615    void forEach(uint32_t slot, sp<const Allocation> in, sp<const Allocation> out,
616            const void *v, size_t) const;
617    void bindAllocation(sp<Allocation> va, uint32_t slot) const;
618    void setVar(uint32_t index, const void *, size_t len) const;
619    void setVar(uint32_t index, sp<const BaseObj> o) const;
620    void invoke(uint32_t slot, const void *v, size_t len) const;
621
622
623    void invoke(uint32_t slot) const {
624        invoke(slot, NULL, 0);
625    }
626    void setVar(uint32_t index, float v) const {
627        setVar(index, &v, sizeof(v));
628    }
629    void setVar(uint32_t index, double v) const {
630        setVar(index, &v, sizeof(v));
631    }
632    void setVar(uint32_t index, int32_t v) const {
633        setVar(index, &v, sizeof(v));
634    }
635    void setVar(uint32_t index, int64_t v) const {
636        setVar(index, &v, sizeof(v));
637    }
638    void setVar(uint32_t index, bool v) const {
639        setVar(index, &v, sizeof(v));
640    }
641
642public:
643    class FieldBase {
644    protected:
645        sp<const Element> mElement;
646        sp<Allocation> mAllocation;
647
648        void init(sp<RS> rs, uint32_t dimx, uint32_t usages = 0);
649
650    public:
651        sp<const Element> getElement() {
652            return mElement;
653        }
654
655        sp<const Type> getType() {
656            return mAllocation->getType();
657        }
658
659        sp<const Allocation> getAllocation() {
660            return mAllocation;
661        }
662
663        //void updateAllocation();
664    };
665};
666
667class ScriptC : public Script {
668protected:
669    ScriptC(sp<RS> rs,
670            const void *codeTxt, size_t codeLength,
671            const char *cachedName, size_t cachedNameLength,
672            const char *cacheDir, size_t cacheDirLength);
673
674};
675
676class ScriptIntrinsic : public Script {
677 protected:
678    sp<const Element> mElement;
679    ScriptIntrinsic(sp<RS> rs, int id, sp<const Element> e);
680    virtual ~ScriptIntrinsic();
681};
682
683class ScriptIntrinsic3DLUT : public ScriptIntrinsic {
684 private:
685    ScriptIntrinsic3DLUT(sp<RS> rs, sp<const Element> e);
686 public:
687    static sp<ScriptIntrinsic3DLUT> create(sp<RS> rs, sp<const Element> e);
688    void forEach(sp<Allocation> ain, sp<Allocation> aout);
689    void setLUT(sp<Allocation> lut);
690};
691
692class ScriptIntrinsicBlend : public ScriptIntrinsic {
693 private:
694    ScriptIntrinsicBlend(sp<RS> rs, sp<const Element> e);
695 public:
696    static sp<ScriptIntrinsicBlend> create(sp<RS> rs, sp<const Element> e);
697    void blendClear(sp<Allocation> in, sp<Allocation> out);
698    void blendSrc(sp<Allocation> in, sp<Allocation> out);
699    void blendDst(sp<Allocation> in, sp<Allocation> out);
700    void blendSrcOver(sp<Allocation> in, sp<Allocation> out);
701    void blendDstOver(sp<Allocation> in, sp<Allocation> out);
702    void blendSrcIn(sp<Allocation> in, sp<Allocation> out);
703    void blendDstIn(sp<Allocation> in, sp<Allocation> out);
704    void blendSrcOut(sp<Allocation> in, sp<Allocation> out);
705    void blendDstOut(sp<Allocation> in, sp<Allocation> out);
706    void blendSrcAtop(sp<Allocation> in, sp<Allocation> out);
707    void blendDstAtop(sp<Allocation> in, sp<Allocation> out);
708    void blendXor(sp<Allocation> in, sp<Allocation> out);
709    void blendMultiply(sp<Allocation> in, sp<Allocation> out);
710    void blendAdd(sp<Allocation> in, sp<Allocation> out);
711    void blendSubtract(sp<Allocation> in, sp<Allocation> out);
712};
713
714class ScriptIntrinsicBlur : public ScriptIntrinsic {
715 private:
716    ScriptIntrinsicBlur(sp<RS> rs, sp<const Element> e);
717 public:
718    static sp<ScriptIntrinsicBlur> create(sp<RS> rs, sp<const Element> e);
719    void setInput(sp<Allocation> in);
720    void forEach(sp<Allocation> out);
721    void setRadius(float radius);
722};
723
724class ScriptIntrinsicColorMatrix : public ScriptIntrinsic {
725 private:
726    ScriptIntrinsicColorMatrix(sp<RS> rs, sp<const Element> e);
727 public:
728    static sp<ScriptIntrinsicColorMatrix> create(sp<RS> rs, sp<const Element> e);
729    void forEach(sp<Allocation> in, sp<Allocation> out);
730    void setAdd(float* add);
731    void setColorMatrix3(float* m);
732    void setColorMatrix4(float* m);
733    void setGreyscale();
734    void setRGBtoYUV();
735    void setYUVtoRGB();
736};
737
738class ScriptIntrinsicConvolve3x3 : public ScriptIntrinsic {
739 private:
740    ScriptIntrinsicConvolve3x3(sp<RS> rs, sp<const Element> e);
741 public:
742    static sp<ScriptIntrinsicConvolve3x3> create(sp<RS> rs, sp<const Element> e);
743    void setInput(sp<Allocation> in);
744    void forEach(sp<Allocation> out);
745    void setCoefficients(float* v);
746};
747
748class ScriptIntrinsicConvolve5x5 : public ScriptIntrinsic {
749 private:
750    ScriptIntrinsicConvolve5x5(sp<RS> rs, sp<const Element> e);
751 public:
752    static sp<ScriptIntrinsicConvolve5x5> create(sp<RS> rs, sp<const Element> e);
753    void setInput(sp<Allocation> in);
754    void forEach(sp<Allocation> out);
755    void setCoefficients(float* v);
756};
757
758class ScriptIntrinsicHistogram : public ScriptIntrinsic {
759 private:
760    ScriptIntrinsicHistogram(sp<RS> rs, sp<const Element> e);
761    sp<Allocation> mOut;
762 public:
763    static sp<ScriptIntrinsicHistogram> create(sp<RS> rs);
764    void setOutput(sp<Allocation> aout);
765    void setDotCoefficients(float r, float g, float b, float a);
766    void forEach(sp<Allocation> ain);
767    void forEach_dot(sp<Allocation> ain);
768};
769
770class ScriptIntrinsicLUT : public ScriptIntrinsic {
771 private:
772    sp<Allocation> LUT;
773    bool mDirty;
774    unsigned char mCache[1024];
775    void setTable(unsigned int offset, unsigned char base, unsigned char length, unsigned char* lutValues);
776    ScriptIntrinsicLUT(sp<RS> rs, sp<const Element> e);
777
778 public:
779    static sp<ScriptIntrinsicLUT> create(sp<RS> rs, sp<const Element> e);
780    void forEach(sp<Allocation> ain, sp<Allocation> aout);
781    void setRed(unsigned char base, unsigned char length, unsigned char* lutValues);
782    void setGreen(unsigned char base, unsigned char length, unsigned char* lutValues);
783    void setBlue(unsigned char base, unsigned char length, unsigned char* lutValues);
784    void setAlpha(unsigned char base, unsigned char length, unsigned char* lutValues);
785    virtual ~ScriptIntrinsicLUT();
786};
787
788class ScriptIntrinsicYuvToRGB : public ScriptIntrinsic {
789 private:
790    ScriptIntrinsicYuvToRGB(sp<RS> rs, sp<const Element> e);
791 public:
792    static sp<ScriptIntrinsicYuvToRGB> create(sp<RS> rs, sp<const Element> e);
793    void setInput(sp<Allocation> in);
794    void forEach(sp<Allocation> out);
795
796};
797
798
799 class Sampler : public BaseObj {
800 private:
801    Sampler(sp<RS> rs, void* id);
802    RsSamplerValue mMin;
803    RsSamplerValue mMag;
804    RsSamplerValue mWrapS;
805    RsSamplerValue mWrapT;
806    RsSamplerValue mWrapR;
807    float mAniso;
808
809 public:
810    static sp<Sampler> create(sp<RS> rs, RsSamplerValue min, RsSamplerValue mag, RsSamplerValue wrapS, RsSamplerValue wrapT, float anisotropy);
811
812    RsSamplerValue getMinification();
813    RsSamplerValue getMagnification();
814    RsSamplerValue getWrapS();
815    RsSamplerValue getWrapT();
816    float getAnisotropy();
817
818    sp<const Sampler> CLAMP_NEAREST(sp<RS> rs);
819    sp<const Sampler> CLAMP_LINEAR(sp<RS> rs);
820    sp<const Sampler> CLAMP_LINEAR_MIP_LINEAR(sp<RS> rs);
821    sp<const Sampler> WRAP_NEAREST(sp<RS> rs);
822    sp<const Sampler> WRAP_LINEAR(sp<RS> rs);
823    sp<const Sampler> WRAP_LINEAR_MIP_LINEAR(sp<RS> rs);
824    sp<const Sampler> MIRRORED_REPEAT_NEAREST(sp<RS> rs);
825    sp<const Sampler> MIRRORED_REPEAT_LINEAR(sp<RS> rs);
826    sp<const Sampler> MIRRORED_REPEAT_LINEAR_MIP_LINEAR(sp<RS> rs);
827
828};
829
830}
831
832}
833
834#endif
835