frameworks/base/libs/rs/rsAllocation.h

   1 /*
   2  * Copyright (C) 2009 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 // ---------------------------------------------------------------------------
  23 namespace android {
  24 namespace renderscript {
  25
  26 class Program;
  27
  28 class Allocation : public ObjectBase
  29 {
  30     // The graphics equilivent of malloc.  The allocation contains a structure of elements.
  31
  32 public:
  33     // By policy this allocation will hold a pointer to the type
  34     // but will not destroy it on destruction.
  35     Allocation(Context *rsc, const Type *);
  36     Allocation(Context *rsc, const Type *, void *bmp, void *callbackData, RsBitmapCallback_t callback);
  37
  38     virtual ~Allocation();
  39
  40     void setCpuWritable(bool);
  41     void setGpuWritable(bool);
  42     void setCpuReadable(bool);
  43     void setGpuReadable(bool);
  44
  45     bool fixAllocation();
  46
  47     void * getPtr() const {return mPtr;}
  48     const Type * getType() const {return mType.get();}
  49
  50     void deferedUploadToTexture(const Context *rsc, bool genMipmap, uint32_t lodOffset);
  51     void uploadToTexture(const Context *rsc);
  52     uint32_t getTextureID() const {return mTextureID;}
  53
  54     void deferedUploadToBufferObject(const Context *rsc);
  55     void uploadToBufferObject(const Context *rsc);
  56     uint32_t getBufferObjectID() const {return mBufferID;}
  57
  58
  59     void data(const void *data, uint32_t sizeBytes);
  60     void subData(uint32_t xoff, uint32_t count, const void *data, uint32_t sizeBytes);
  61     void subData(uint32_t xoff, uint32_t yoff,
  62                  uint32_t w, uint32_t h, const void *data, uint32_t sizeBytes);
  63     void subData(uint32_t xoff, uint32_t yoff, uint32_t zoff,
  64                  uint32_t w, uint32_t h, uint32_t d, const void *data, uint32_t sizeBytes);
  65
  66     void read(void *data);
  67
  68     void enableGLVertexBuffers() const;
  69     void setupGLIndexBuffers() const;
  70
  71     void addProgramToDirty(const Program *);
  72     void removeProgramToDirty(const Program *);
  73
  74     virtual void dumpLOGV(const char *prefix) const;
  75
  76     virtual void uploadCheck(const Context *rsc);
  77
  78 protected:
  79     void sendDirty() const;
  80
  81     ObjectBaseRef<const Type> mType;
  82     void * mPtr;
  83
  84     Vector<const Program *> mToDirtyList;
  85
  86     // Is we have a non-null user bitmap callback we do not own the bits and
  87     // instead call this function to free the memort when its time.
  88     RsBitmapCallback_t mUserBitmapCallback;
  89     void *mUserBitmapCallbackData;
  90
  91     // Usage restrictions
  92     bool mCpuWrite;
  93     bool mCpuRead;
  94     bool mGpuWrite;
  95     bool mGpuRead;
  96
  97     // more usage hint data from the application
  98     // which can be used by a driver to pick the best memory type.
  99     // Likely ignored for now
 100     float mReadWriteRatio;
 101     float mUpdateSize;
 102
 103
 104     // Is this a legal structure to be used as a texture source.
 105     // Initially this will require 1D or 2D and color data
 106     bool mIsTexture;
 107     bool mTextureGenMipmap;
 108     uint32_t mTextureLOD;
 109     uint32_t mTextureID;
 110
 111     // Is this a legal structure to be used as a vertex source.
 112     // Initially this will require 1D and x(yzw).  Additional per element data
 113     // is allowed.
 114     bool mIsVertexBuffer;
 115     uint32_t mBufferID;
 116
 117     bool mUploadDefered;
 118
 119 private:
 120     void init(Context *rsc, const Type *);
 121
 122 };
 123
 124 }
 125 }
 126 #endif
 127