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