blob: 6ffe05d9ef212bc7206670e9ff162de9fee5496a [file] [log] [blame]
Jason Sams326e0dd2009-05-22 14:03:28 -07001/*
Jason Samsbc0ca6b2013-02-15 18:13:43 -08002 * Copyright (C) 2013 The Android Open Source Project
Jason Sams326e0dd2009-05-22 14:03:28 -07003 *
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
Jason Samsddceab92013-08-07 13:02:32 -070022#if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB)
Stephen Hines16647802013-08-15 16:28:01 -070023#include <ui/GraphicBuffer.h>
Jason Samsddceab92013-08-07 13:02:32 -070024#include "rsGrallocConsumer.h"
25#include "gui/CpuConsumer.h"
26#include "gui/GLConsumer.h"
Stephen Hines16647802013-08-15 16:28:01 -070027#else
28struct ANativeWindowBuffer;
Jason Samsddceab92013-08-07 13:02:32 -070029#endif
30
Jason Sams326e0dd2009-05-22 14:03:28 -070031// ---------------------------------------------------------------------------
32namespace android {
Jason Sams3522f402012-03-23 11:47:26 -070033
Jason Sams326e0dd2009-05-22 14:03:28 -070034namespace renderscript {
35
Jason Sams5c3e3bc2009-10-26 15:19:28 -070036class Program;
Jason Sams326e0dd2009-05-22 14:03:28 -070037
Stephen Hines1e5149f2011-08-08 15:06:40 -070038/*****************************************************************************
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 *****************************************************************************/
Alex Sakhartchoukafb743a2010-11-09 17:00:54 -080046class Allocation : public ObjectBase {
Stephen Hines1e5149f2011-08-08 15:06:40 -070047 // The graphics equivalent of malloc. The allocation contains a structure of elements.
Jason Sams326e0dd2009-05-22 14:03:28 -070048
Jason Sams326e0dd2009-05-22 14:03:28 -070049public:
Jason Sams807fdc42012-07-25 17:55:39 -070050 const static int MAX_LOD = 16;
51
Jason Samsbad80742011-03-16 16:29:28 -070052 struct Hal {
53 void * drv;
54
55 struct State {
Alex Sakhartchouk064aa7e2011-10-18 10:54:29 -070056 const Type * type;
Jason Samsbad80742011-03-16 16:29:28 -070057
58 uint32_t usageFlags;
59 RsAllocationMipmapControl mipmapControl;
60
61 // Cached fields from the Type and Element
62 // to prevent pointer chasing in critical loops.
Jason Samsa572aca2013-01-09 11:52:26 -080063 uint32_t yuv;
Jason Samsbad80742011-03-16 16:29:28 -070064 uint32_t elementSizeBytes;
65 bool hasMipmaps;
66 bool hasFaces;
67 bool hasReferences;
Tim Murray2e1a94d2012-11-29 13:12:25 -080068 void * userProvidedPtr;
Jason Samscf27eb42012-02-10 13:24:18 -080069 int32_t surfaceTextureID;
Jason Samsddceab92013-08-07 13:02:32 -070070 ANativeWindowBuffer *nativeBuffer;
71 int64_t timestamp;
Jason Samscfea6c12015-02-09 12:50:22 -080072
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];
Jason Samsbad80742011-03-16 16:29:28 -070081 };
82 State state;
Jason Samseb4fe182011-05-26 16:33:01 -070083
84 struct DrvState {
Jason Sams709a0972012-11-15 18:18:04 -080085 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;
Jason Sams61656a72013-09-03 16:21:18 -070095
96 struct YuvState {
97 uint32_t shift;
98 uint32_t step;
99 } yuv;
Jason Samse49da132014-10-23 17:32:27 -0700100
101 int grallocFlags;
Jason Samscfea6c12015-02-09 12:50:22 -0800102 uint32_t dimArray[Type::mMaxArrays];
Jason Sams709a0972012-11-15 18:18:04 -0800103 };
104 mutable DrvState drvState;
Jason Samseb4fe182011-05-26 16:33:01 -0700105
Jason Samsbad80742011-03-16 16:29:28 -0700106 };
107 Hal mHal;
108
Tim Murray34689382013-03-11 12:12:03 -0700109 void operator delete(void* ptr);
110
Jason Samseb4fe182011-05-26 16:33:01 -0700111 static Allocation * createAllocation(Context *rsc, const Type *, uint32_t usages,
Jason Sams179e9a42011-11-23 15:02:15 -0800112 RsAllocationMipmapControl mc = RS_ALLOCATION_MIPMAP_NONE,
113 void *ptr = 0);
Jason Samscfea6c12015-02-09 12:50:22 -0800114 static Allocation * createAdapter(Context *rsc, const Allocation *alloc, const Type *type);
115
116
Jason Sams326e0dd2009-05-22 14:03:28 -0700117 virtual ~Allocation();
Jason Samsbad80742011-03-16 16:29:28 -0700118 void updateCache();
Jason Sams326e0dd2009-05-22 14:03:28 -0700119
Alex Sakhartchouk064aa7e2011-10-18 10:54:29 -0700120 const Type * getType() const {return mHal.state.type;}
Jason Sams326e0dd2009-05-22 14:03:28 -0700121
Jason Sams366c9c82010-12-08 16:14:36 -0800122 void syncAll(Context *rsc, RsAllocationUsageType src);
123
Jason Sams96abf812010-10-05 13:32:49 -0700124 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);
Jason Sams326e0dd2009-05-22 14:03:28 -0700128
Stephen Hines6ae039b2012-01-18 18:46:27 -0800129 void data(Context *rsc, uint32_t xoff, uint32_t lod, uint32_t count, const void *data, size_t sizeBytes);
Jason Sams4b45b892010-12-29 14:31:29 -0800130 void data(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face,
Tim Murray358747a2012-11-26 13:52:04 -0800131 uint32_t w, uint32_t h, const void *data, size_t sizeBytes, size_t stride);
Jason Sams3bbc0fd2013-04-09 14:16:13 -0700132 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);
Jason Sams326e0dd2009-05-22 14:03:28 -0700134
Jason Sams807fdc42012-07-25 17:55:39 -0700135 void read(Context *rsc, uint32_t xoff, uint32_t lod, uint32_t count, void *data, size_t sizeBytes);
Tim Murray358747a2012-11-26 13:52:04 -0800136 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);
Jason Sams3bbc0fd2013-04-09 14:16:13 -0700138 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);
Jason Sams807fdc42012-07-25 17:55:39 -0700140
Miao Wangcc8cea72015-02-19 18:14:46 -0800141 void elementData(Context *rsc, uint32_t x, uint32_t y, uint32_t z,
Stephen Hines6ae039b2012-01-18 18:46:27 -0800142 const void *data, uint32_t elementOff, size_t sizeBytes);
Miao Wangcc8cea72015-02-19 18:14:46 -0800143
144 void elementRead(Context *rsc, uint32_t x, uint32_t y, uint32_t z,
145 void *data, uint32_t elementOff, size_t sizeBytes);
Jason Sams5f0c84c2010-08-31 13:50:42 -0700146
Jason Sams5c3e3bc2009-10-26 15:19:28 -0700147 void addProgramToDirty(const Program *);
148 void removeProgramToDirty(const Program *);
Jason Samse5ffb872009-08-09 17:01:55 -0700149
Jason Samsc21cf402009-11-17 17:26:46 -0800150 virtual void dumpLOGV(const char *prefix) const;
Jason Samse3150cf2012-07-24 18:10:20 -0700151 virtual void serialize(Context *rsc, OStream *stream) const;
Alex Sakhartchoukb825f672010-06-04 10:06:50 -0700152 virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_ALLOCATION; }
Alex Sakhartchoukfb6b6142010-05-21 12:53:13 -0700153 static Allocation *createFromStream(Context *rsc, IStream *stream);
Jason Samsc21cf402009-11-17 17:26:46 -0800154
Jason Samsb89b0b72010-12-13 17:11:21 -0800155 bool getIsScript() const {
Jason Samsbad80742011-03-16 16:29:28 -0700156 return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) != 0;
Jason Samsb89b0b72010-12-13 17:11:21 -0800157 }
Jason Samsebc50192010-12-13 15:32:35 -0800158 bool getIsTexture() const {
Jason Samsbad80742011-03-16 16:29:28 -0700159 return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) != 0;
Jason Samsebc50192010-12-13 15:32:35 -0800160 }
Alex Sakhartchouk7d9c5ff2011-04-01 14:19:01 -0700161 bool getIsRenderTarget() const {
162 return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) != 0;
163 }
Jason Samsebc50192010-12-13 15:32:35 -0800164 bool getIsBufferObject() const {
Jason Samsbad80742011-03-16 16:29:28 -0700165 return (mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) != 0;
Jason Samsebc50192010-12-13 15:32:35 -0800166 }
Jason Sams760f1f72010-06-25 12:45:41 -0700167
Jason Sams96abf812010-10-05 13:32:49 -0700168 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;
Jason Samsa36c50a2014-06-17 12:06:06 -0700170 virtual void callUpdateCacheObject(const Context *rsc, void *dstObj) const;
Jason Samsc7cec1e2011-08-18 18:01:33 -0700171 virtual bool freeChildren();
Jason Samse3929c92010-08-09 18:13:33 -0700172
Jason Samseb4fe182011-05-26 16:33:01 -0700173 void sendDirty(const Context *rsc) const;
Jason Samsb89b0b72010-12-13 17:11:21 -0800174 bool getHasGraphicsMipmaps() const {
Jason Samsbad80742011-03-16 16:29:28 -0700175 return mHal.state.mipmapControl != RS_ALLOCATION_MIPMAP_NONE;
Jason Samsb89b0b72010-12-13 17:11:21 -0800176 }
177
Jason Sams733396b2013-02-22 12:46:18 -0800178 void * getSurface(const Context *rsc);
Jason Sams7ac2a4d2012-02-15 12:04:24 -0800179 void setSurface(const Context *rsc, RsNativeWindow sur);
180 void ioSend(const Context *rsc);
181 void ioReceive(const Context *rsc);
Jason Sams5c3e3bc2009-10-26 15:19:28 -0700182
Jason Sams442b7ff2015-03-06 16:50:11 -0800183 void adapterOffset(Context *rsc, const uint32_t *offsets, size_t len);
184
Jason Samsb8a94e22014-02-24 17:52:32 -0800185 void * getPointer(const Context *rsc, uint32_t lod, RsAllocationCubemapFace face,
186 uint32_t z, uint32_t array, size_t *stride);
187
Jason Samsc0d68472015-01-20 14:29:52 -0800188 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
Chris Wailes4b3c34e2014-06-11 12:00:29 -0700203 bool hasSameDims(const Allocation *Other) const;
204
Alex Sakhartchouk1e5168d2010-09-01 16:34:48 -0700205protected:
Yang Nib8353c52015-02-14 18:00:59 -0800206 Vector<const Program *> mToDirtyList;
Alex Sakhartchouk064aa7e2011-10-18 10:54:29 -0700207 ObjectBaseRef<const Type> mType;
208 void setType(const Type *t) {
209 mType.set(t);
210 mHal.state.type = t;
211 }
Jason Sams5c3e3bc2009-10-26 15:19:28 -0700212
Jason Samsddceab92013-08-07 13:02:32 -0700213#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
Dan Stozaf0d7aa22014-11-04 11:38:47 -0800219 virtual void onFrameAvailable(const BufferItem& item);
Jason Samsddceab92013-08-07 13:02:32 -0700220 };
221
222 sp<NewBufferListener> mBufferListener;
223 sp< GrallocConsumer > mGrallocConsumer;
224#endif
225
226
Jason Samsfa84da22010-03-01 15:31:04 -0800227private:
Jason Samsc7cec1e2011-08-18 18:01:33 -0700228 void freeChildrenUnlocked();
Jason Sams179e9a42011-11-23 15:02:15 -0800229 Allocation(Context *rsc, const Type *, uint32_t usages, RsAllocationMipmapControl mc, void *ptr);
Jason Samscfea6c12015-02-09 12:50:22 -0800230 Allocation(Context *rsc, const Allocation *, const Type *);
Alex Sakhartchouk2d1220c2011-11-15 15:15:21 -0800231
232 uint32_t getPackedSize() const;
Jason Sams807fdc42012-07-25 17:55:39 -0700233 static void writePackedData(Context *rsc, const Type *type, uint8_t *dst,
234 const uint8_t *src, bool dstPadded);
Jason Samse3150cf2012-07-24 18:10:20 -0700235 void unpackVec3Allocation(Context *rsc, const void *data, size_t dataSize);
236 void packVec3Allocation(Context *rsc, OStream *stream) const;
Jason Sams326e0dd2009-05-22 14:03:28 -0700237};
238
239}
240}
241#endif