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_STRUCTURED_ALLOCATION_H
18 #define ANDROID_STRUCTURED_ALLOCATION_H
19 
20 #include "rsType.h"
21 
22 #if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB)
23 #include <ui/GraphicBuffer.h>
24 #include "rsGrallocConsumer.h"
25 #include "gui/CpuConsumer.h"
26 #include "gui/GLConsumer.h"
27 #else
28 struct ANativeWindowBuffer;
29 #endif
30 
31 // ---------------------------------------------------------------------------
32 namespace android {
33 
34 namespace renderscript {
35 
36 class Program;
37 
38 /*****************************************************************************
39  * CAUTION
40  *
41  * Any layout changes for this class may require a corresponding change to be
42  * made to frameworks/compile/libbcc/lib/ScriptCRT/rs_core.c, which contains
43  * a partial copy of the information below.
44  *
45  *****************************************************************************/
46 class Allocation : public ObjectBase {
47     // The graphics equivalent of malloc.  The allocation contains a structure of elements.
48 
49 public:
50     const static int MAX_LOD = 16;
51 
52     struct Hal {
53         void * drv;
54 
55         struct State {
56             const Type * type;
57 
58             uint32_t usageFlags;
59             RsAllocationMipmapControl mipmapControl;
60 
61             // Cached fields from the Type and Element
62             // to prevent pointer chasing in critical loops.
63             uint32_t yuv;
64             uint32_t elementSizeBytes;
65             bool hasMipmaps;
66             bool hasFaces;
67             bool hasReferences;
68             void * userProvidedPtr;
69             int32_t surfaceTextureID;
70             ANativeWindowBuffer *nativeBuffer;
71             int64_t timestamp;
72 
73             // Allocation adapter state
74             const Allocation *baseAlloc;
75             uint32_t originX;
76             uint32_t originY;
77             uint32_t originZ;
78             uint32_t originLOD;
79             uint32_t originFace;
80             uint32_t originArray[Type::mMaxArrays];
81         };
82         State state;
83 
84         struct DrvState {
85             struct LodState {
86                 void * mallocPtr;
87                 size_t stride;
88                 uint32_t dimX;
89                 uint32_t dimY;
90                 uint32_t dimZ;
91             } lod[android::renderscript::Allocation::MAX_LOD];
92             size_t faceOffset;
93             uint32_t lodCount;
94             uint32_t faceCount;
95 
96             struct YuvState {
97                 uint32_t shift;
98                 uint32_t step;
99             } yuv;
100 
101             int grallocFlags;
102             uint32_t dimArray[Type::mMaxArrays];
103         };
104         mutable DrvState drvState;
105 
106     };
107     Hal mHal;
108 
109     void operator delete(void* ptr);
110 
111     static Allocation * createAllocation(Context *rsc, const Type *, uint32_t usages,
112                                          RsAllocationMipmapControl mc = RS_ALLOCATION_MIPMAP_NONE,
113                                          void *ptr = 0);
114     static Allocation * createAdapter(Context *rsc, const Allocation *alloc, const Type *type);
115 
116 
117     virtual ~Allocation();
118     void updateCache();
119 
getType()120     const Type * getType() const {return mHal.state.type;}
121 
122     void syncAll(Context *rsc, RsAllocationUsageType src);
123 
124     void copyRange1D(Context *rsc, const Allocation *src, int32_t srcOff, int32_t destOff, int32_t len);
125 
126     void resize1D(Context *rsc, uint32_t dimX);
127     void resize2D(Context *rsc, uint32_t dimX, uint32_t dimY);
128 
129     void data(Context *rsc, uint32_t xoff, uint32_t lod, uint32_t count, const void *data, size_t sizeBytes);
130     void data(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face,
131               uint32_t w, uint32_t h, const void *data, size_t sizeBytes, size_t stride);
132     void data(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod,
133               uint32_t w, uint32_t h, uint32_t d, const void *data, size_t sizeBytes, size_t stride);
134 
135     void read(Context *rsc, uint32_t xoff, uint32_t lod, uint32_t count, void *data, size_t sizeBytes);
136     void read(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face,
137               uint32_t w, uint32_t h, void *data, size_t sizeBytes, size_t stride);
138     void read(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod,
139               uint32_t w, uint32_t h, uint32_t d, void *data, size_t sizeBytes, size_t stride);
140 
141     void elementData(Context *rsc, uint32_t x, uint32_t y, uint32_t z,
142                      const void *data, uint32_t elementOff, size_t sizeBytes);
143 
144     void elementRead(Context *rsc, uint32_t x, uint32_t y, uint32_t z,
145                      void *data, uint32_t elementOff, size_t sizeBytes);
146 
147     void addProgramToDirty(const Program *);
148     void removeProgramToDirty(const Program *);
149 
150     virtual void dumpLOGV(const char *prefix) const;
151     virtual void serialize(Context *rsc, OStream *stream) const;
getClassId()152     virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ALLOCATION; }
153     static Allocation *createFromStream(Context *rsc, IStream *stream);
154 
getIsScript()155     bool getIsScript() const {
156         return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) != 0;
157     }
getIsTexture()158     bool getIsTexture() const {
159         return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) != 0;
160     }
getIsRenderTarget()161     bool getIsRenderTarget() const {
162         return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) != 0;
163     }
getIsBufferObject()164     bool getIsBufferObject() const {
165         return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) != 0;
166     }
167 
168     void incRefs(const void *ptr, size_t ct, size_t startOff = 0) const;
169     void decRefs(const void *ptr, size_t ct, size_t startOff = 0) const;
170     virtual void callUpdateCacheObject(const Context *rsc, void *dstObj) const;
171     virtual bool freeChildren();
172 
173     void sendDirty(const Context *rsc) const;
getHasGraphicsMipmaps()174     bool getHasGraphicsMipmaps() const {
175         return mHal.state.mipmapControl != RS_ALLOCATION_MIPMAP_NONE;
176     }
177 
178     void * getSurface(const Context *rsc);
179     void setSurface(const Context *rsc, RsNativeWindow sur);
180     void ioSend(const Context *rsc);
181     void ioReceive(const Context *rsc);
182 
183     void adapterOffset(Context *rsc, const uint32_t *offsets, size_t len);
184 
185     void * getPointer(const Context *rsc, uint32_t lod, RsAllocationCubemapFace face,
186                       uint32_t z, uint32_t array, size_t *stride);
187 
188     void * getPointerUnchecked(uint32_t x, uint32_t y,
189                                uint32_t z = 0, uint32_t lod = 0,
190                                RsAllocationCubemapFace face = RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X,
191                                uint32_t a1 = 0, uint32_t a2 = 0, uint32_t a3 = 0, uint32_t a4 = 0) const {
192 
193         uint8_t * p = (uint8_t *) mHal.drvState.lod[lod].mallocPtr;
194         p += x * getType()->getElementSizeBytes();
195         p += y * mHal.drvState.lod[lod].stride;
196         p += z * mHal.drvState.lod[lod].stride * mHal.drvState.lod[lod].dimY;
197 
198         // Todo: arrays
199 
200         return p;
201     }
202 
203     bool hasSameDims(const Allocation *Other) const;
204 
205 protected:
206     Vector<const Program *> mToDirtyList;
207     ObjectBaseRef<const Type> mType;
setType(const Type * t)208     void setType(const Type *t) {
209         mType.set(t);
210         mHal.state.type = t;
211     }
212 
213 #if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB)
214     class NewBufferListener : public android::ConsumerBase::FrameAvailableListener {
215     public:
216         const android::renderscript::Context *rsc;
217         const android::renderscript::Allocation *alloc;
218 
219         virtual void onFrameAvailable(const BufferItem& item);
220     };
221 
222     sp<NewBufferListener> mBufferListener;
223     sp< GrallocConsumer > mGrallocConsumer;
224 #endif
225 
226 
227 private:
228     void freeChildrenUnlocked();
229     Allocation(Context *rsc, const Type *, uint32_t usages, RsAllocationMipmapControl mc, void *ptr);
230     Allocation(Context *rsc, const Allocation *, const Type *);
231 
232     uint32_t getPackedSize() const;
233     static void writePackedData(Context *rsc, const Type *type, uint8_t *dst,
234                                 const uint8_t *src, bool dstPadded);
235     void unpackVec3Allocation(Context *rsc, const void *data, size_t dataSize);
236     void packVec3Allocation(Context *rsc, OStream *stream) const;
237 };
238 
239 }
240 }
241 #endif
242