rsContext.h revision 366c9c85196675437a8dd74c1cf6b63ddbde3d6a 
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_RS_CONTEXT_H
18#define ANDROID_RS_CONTEXT_H
19
20#include "rsUtils.h"
21#include "rsMutex.h"
22
23#include "rsThreadIO.h"
24#include "rsType.h"
25#include "rsMatrix.h"
26#include "rsAllocation.h"
27#include "rsMesh.h"
28#include "rsDevice.h"
29#include "rsScriptC.h"
30#include "rsAllocation.h"
31#include "rsAdapter.h"
32#include "rsSampler.h"
33#include "rsFont.h"
34#include "rsProgramFragment.h"
35#include "rsProgramStore.h"
36#include "rsProgramRaster.h"
37#include "rsProgramVertex.h"
38#include "rsShaderCache.h"
39#include "rsVertexArray.h"
40
41#include "rsgApiStructs.h"
42#include "rsLocklessFifo.h"
43
44#include <ui/egl/android_natives.h>
45
46// ---------------------------------------------------------------------------
47namespace android {
48
49namespace renderscript {
50
51#if 0
52#define CHECK_OBJ(o) { \
53    GET_TLS(); \
54    if (!ObjectBase::isValid(rsc, (const ObjectBase *)o)) {  \
55        LOGE("Bad object %p at %s, %i", o, __FILE__, __LINE__);  \
56    } \
57}
58#define CHECK_OBJ_OR_NULL(o) { \
59    GET_TLS(); \
60    if (o && !ObjectBase::isValid(rsc, (const ObjectBase *)o)) {  \
61        LOGE("Bad object %p at %s, %i", o, __FILE__, __LINE__);  \
62    } \
63}
64#else
65#define CHECK_OBJ(o)
66#define CHECK_OBJ_OR_NULL(o)
67#endif
68
69class Context {
70public:
71    static Context * createContext(Device *, const RsSurfaceConfig *sc);
72    ~Context();
73
74    static pthread_key_t gThreadTLSKey;
75    static uint32_t gThreadTLSKeyCount;
76    static uint32_t gGLContextCount;
77    static pthread_mutex_t gInitMutex;
78
79    struct ScriptTLSStruct {
80        Context * mContext;
81        Script * mScript;
82    };
83
84    class PushState {
85    public:
86        PushState(Context *);
87        ~PushState();
88
89    private:
90        ObjectBaseRef<ProgramFragment> mFragment;
91        ObjectBaseRef<ProgramVertex> mVertex;
92        ObjectBaseRef<ProgramStore> mStore;
93        ObjectBaseRef<ProgramRaster> mRaster;
94        ObjectBaseRef<Font> mFont;
95        Context *mRsc;
96    };
97
98    ScriptTLSStruct *mTlsStruct;
99    RsSurfaceConfig mUserSurfaceConfig;
100
101    typedef void (*WorkerCallback_t)(void *usr, uint32_t idx);
102
103    //StructuredAllocationContext mStateAllocation;
104    ElementState mStateElement;
105    TypeState mStateType;
106    SamplerState mStateSampler;
107    ProgramFragmentState mStateFragment;
108    ProgramStoreState mStateFragmentStore;
109    ProgramRasterState mStateRaster;
110    ProgramVertexState mStateVertex;
111    VertexArrayState mStateVertexArray;
112    FontState mStateFont;
113
114    ScriptCState mScriptC;
115    ShaderCache mShaderCache;
116
117    void swapBuffers();
118    void setRootScript(Script *);
119    void setProgramRaster(ProgramRaster *);
120    void setProgramVertex(ProgramVertex *);
121    void setProgramFragment(ProgramFragment *);
122    void setProgramStore(ProgramStore *);
123    void setFont(Font *);
124
125    void updateSurface(void *sur);
126
127    ProgramFragment * getProgramFragment() {return mFragment.get();}
128    ProgramStore * getProgramStore() {return mFragmentStore.get();}
129    ProgramRaster * getProgramRaster() {return mRaster.get();}
130    ProgramVertex * getProgramVertex() {return mVertex.get();}
131    Font * getFont() {return mFont.get();}
132
133    bool setupCheck();
134    void setupProgramStore();
135
136    void pause();
137    void resume();
138    void setSurface(uint32_t w, uint32_t h, ANativeWindow *sur);
139    void setPriority(int32_t p);
140
141    void assignName(ObjectBase *obj, const char *name, uint32_t len);
142    void removeName(ObjectBase *obj);
143
144    RsMessageToClientType peekMessageToClient(size_t *receiveLen, uint32_t *subID, bool wait);
145    RsMessageToClientType getMessageToClient(void *data, size_t *receiveLen, uint32_t *subID, size_t bufferLen, bool wait);
146    bool sendMessageToClient(const void *data, RsMessageToClientType cmdID, uint32_t subID, size_t len, bool waitForSpace) const;
147    uint32_t runScript(Script *s);
148
149    void initToClient();
150    void deinitToClient();
151
152    ProgramFragment * getDefaultProgramFragment() const {
153        return mStateFragment.mDefault.get();
154    }
155    ProgramVertex * getDefaultProgramVertex() const {
156        return mStateVertex.mDefault.get();
157    }
158    ProgramStore * getDefaultProgramStore() const {
159        return mStateFragmentStore.mDefault.get();
160    }
161    ProgramRaster * getDefaultProgramRaster() const {
162        return mStateRaster.mDefault.get();
163    }
164    Font* getDefaultFont() const {
165        return mStateFont.mDefault.get();
166    }
167
168    uint32_t getWidth() const {return mWidth;}
169    uint32_t getHeight() const {return mHeight;}
170
171    mutable ThreadIO mIO;
172
173    // Timers
174    enum Timers {
175        RS_TIMER_IDLE,
176        RS_TIMER_INTERNAL,
177        RS_TIMER_SCRIPT,
178        RS_TIMER_CLEAR_SWAP,
179        _RS_TIMER_TOTAL
180    };
181    uint64_t getTime() const;
182    void timerInit();
183    void timerReset();
184    void timerSet(Timers);
185    void timerPrint();
186    void timerFrame();
187
188    struct {
189        bool mLogTimes;
190        bool mLogScripts;
191        bool mLogObjects;
192        bool mLogShaders;
193        bool mLogShadersAttr;
194        bool mLogShadersUniforms;
195        bool mLogVisual;
196    } props;
197
198    void dumpDebug() const;
199    void checkError(const char *, bool isFatal = false) const;
200    void setError(RsError e, const char *msg = NULL) const;
201
202    mutable const ObjectBase * mObjHead;
203
204    bool ext_OES_texture_npot() const {return mGL.OES_texture_npot;}
205    bool ext_GL_NV_texture_npot_2D_mipmap() const {return mGL.GL_NV_texture_npot_2D_mipmap;}
206    float ext_texture_max_aniso() const {return mGL.EXT_texture_max_aniso; }
207    uint32_t getMaxFragmentTextures() const {return mGL.mMaxFragmentTextureImageUnits;}
208    uint32_t getMaxFragmentUniformVectors() const {return mGL.mMaxFragmentUniformVectors;}
209    uint32_t getMaxVertexUniformVectors() const {return mGL.mMaxVertexUniformVectors;}
210
211    void launchThreads(WorkerCallback_t cbk, void *data);
212    uint32_t getWorkerPoolSize() const {return (uint32_t)mWorkers.mCount;}
213
214protected:
215    Device *mDev;
216
217    struct {
218        EGLint mNumConfigs;
219        EGLint mMajorVersion;
220        EGLint mMinorVersion;
221        EGLConfig mConfig;
222        EGLContext mContext;
223        EGLSurface mSurface;
224        EGLSurface mSurfaceDefault;
225        EGLDisplay mDisplay;
226    } mEGL;
227
228    struct {
229        const uint8_t * mVendor;
230        const uint8_t * mRenderer;
231        const uint8_t * mVersion;
232        const uint8_t * mExtensions;
233
234        uint32_t mMajorVersion;
235        uint32_t mMinorVersion;
236
237        int32_t mMaxVaryingVectors;
238        int32_t mMaxTextureImageUnits;
239
240        int32_t mMaxFragmentTextureImageUnits;
241        int32_t mMaxFragmentUniformVectors;
242
243        int32_t mMaxVertexAttribs;
244        int32_t mMaxVertexUniformVectors;
245        int32_t mMaxVertexTextureUnits;
246
247        bool OES_texture_npot;
248        bool GL_NV_texture_npot_2D_mipmap;
249        float EXT_texture_max_aniso;
250    } mGL;
251
252    uint32_t mWidth;
253    uint32_t mHeight;
254    int32_t mThreadPriority;
255    bool mIsGraphicsContext;
256
257    bool mRunning;
258    bool mExit;
259    bool mPaused;
260    mutable RsError mError;
261
262    pthread_t mThreadId;
263    pid_t mNativeThreadId;
264
265    struct Workers {
266        volatile int mRunningCount;
267        volatile int mLaunchCount;
268        uint32_t mCount;
269        pthread_t *mThreadId;
270        pid_t *mNativeThreadId;
271        Signal mCompleteSignal;
272
273        Signal *mLaunchSignals;
274        WorkerCallback_t mLaunchCallback;
275        void *mLaunchData;
276    };
277    Workers mWorkers;
278
279    ObjectBaseRef<Script> mRootScript;
280    ObjectBaseRef<ProgramFragment> mFragment;
281    ObjectBaseRef<ProgramVertex> mVertex;
282    ObjectBaseRef<ProgramStore> mFragmentStore;
283    ObjectBaseRef<ProgramRaster> mRaster;
284    ObjectBaseRef<Font> mFont;
285
286    void displayDebugStats();
287
288private:
289    Context();
290    bool initContext(Device *, const RsSurfaceConfig *sc);
291
292
293    bool initGLThread();
294    void deinitEGL();
295
296    uint32_t runRootScript();
297
298    static void * threadProc(void *);
299    static void * helperThreadProc(void *);
300
301    ANativeWindow *mWndSurface;
302
303    Vector<ObjectBase *> mNames;
304
305    uint64_t mTimers[_RS_TIMER_TOTAL];
306    Timers mTimerActive;
307    uint64_t mTimeLast;
308    uint64_t mTimeFrame;
309    uint64_t mTimeLastFrame;
310    uint32_t mTimeMSLastFrame;
311    uint32_t mTimeMSLastScript;
312    uint32_t mTimeMSLastSwap;
313    uint32_t mAverageFPSFrameCount;
314    uint64_t mAverageFPSStartTime;
315    uint32_t mAverageFPS;
316};
317
318}
319}
320#endif
321