summaryrefslogtreecommitdiffstats
path: root/libs/rs/rsContext.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'libs/rs/rsContext.cpp')
-rw-r--r--libs/rs/rsContext.cpp616
1 files changed, 358 insertions, 258 deletions
diff --git a/libs/rs/rsContext.cpp b/libs/rs/rsContext.cpp
index 596f533..4dd074e 100644
--- a/libs/rs/rsContext.cpp
+++ b/libs/rs/rsContext.cpp
@@ -18,11 +18,13 @@
#include "rsContext.h"
#include "rsThreadIO.h"
#include <ui/FramebufferNativeWindow.h>
+#include <ui/PixelFormat.h>
#include <ui/EGLUtils.h>
#include <ui/egl/android_natives.h>
#include <sys/types.h>
#include <sys/resource.h>
+#include <sched.h>
#include <cutils/properties.h>
@@ -32,6 +34,8 @@
#include <GLES2/gl2ext.h>
#include <cutils/sched_policy.h>
+#include <sys/syscall.h>
+#include <string.h>
using namespace android;
using namespace android::renderscript;
@@ -53,8 +57,61 @@ static void checkEglError(const char* op, EGLBoolean returnVal = EGL_TRUE) {
}
}
-void Context::initEGL(bool useGL2)
+void printEGLConfiguration(EGLDisplay dpy, EGLConfig config) {
+
+#define X(VAL) {VAL, #VAL}
+ struct {EGLint attribute; const char* name;} names[] = {
+ X(EGL_BUFFER_SIZE),
+ X(EGL_ALPHA_SIZE),
+ X(EGL_BLUE_SIZE),
+ X(EGL_GREEN_SIZE),
+ X(EGL_RED_SIZE),
+ X(EGL_DEPTH_SIZE),
+ X(EGL_STENCIL_SIZE),
+ X(EGL_CONFIG_CAVEAT),
+ X(EGL_CONFIG_ID),
+ X(EGL_LEVEL),
+ X(EGL_MAX_PBUFFER_HEIGHT),
+ X(EGL_MAX_PBUFFER_PIXELS),
+ X(EGL_MAX_PBUFFER_WIDTH),
+ X(EGL_NATIVE_RENDERABLE),
+ X(EGL_NATIVE_VISUAL_ID),
+ X(EGL_NATIVE_VISUAL_TYPE),
+ X(EGL_SAMPLES),
+ X(EGL_SAMPLE_BUFFERS),
+ X(EGL_SURFACE_TYPE),
+ X(EGL_TRANSPARENT_TYPE),
+ X(EGL_TRANSPARENT_RED_VALUE),
+ X(EGL_TRANSPARENT_GREEN_VALUE),
+ X(EGL_TRANSPARENT_BLUE_VALUE),
+ X(EGL_BIND_TO_TEXTURE_RGB),
+ X(EGL_BIND_TO_TEXTURE_RGBA),
+ X(EGL_MIN_SWAP_INTERVAL),
+ X(EGL_MAX_SWAP_INTERVAL),
+ X(EGL_LUMINANCE_SIZE),
+ X(EGL_ALPHA_MASK_SIZE),
+ X(EGL_COLOR_BUFFER_TYPE),
+ X(EGL_RENDERABLE_TYPE),
+ X(EGL_CONFORMANT),
+ };
+#undef X
+
+ for (size_t j = 0; j < sizeof(names) / sizeof(names[0]); j++) {
+ EGLint value = -1;
+ EGLint returnVal = eglGetConfigAttrib(dpy, config, names[j].attribute, &value);
+ EGLint error = eglGetError();
+ if (returnVal && error == EGL_SUCCESS) {
+ LOGV(" %s: %d (0x%x)", names[j].name, value, value);
+ }
+ }
+}
+
+
+void Context::initGLThread()
{
+ pthread_mutex_lock(&gInitMutex);
+ LOGV("initGLThread start %p", this);
+
mEGL.mNumConfigs = -1;
EGLint configAttribs[128];
EGLint *configAttribsPtr = configAttribs;
@@ -66,15 +123,13 @@ void Context::initEGL(bool useGL2)
configAttribsPtr[1] = EGL_WINDOW_BIT;
configAttribsPtr += 2;
- if (useGL2) {
- configAttribsPtr[0] = EGL_RENDERABLE_TYPE;
- configAttribsPtr[1] = EGL_OPENGL_ES2_BIT;
- configAttribsPtr += 2;
- }
+ configAttribsPtr[0] = EGL_RENDERABLE_TYPE;
+ configAttribsPtr[1] = EGL_OPENGL_ES2_BIT;
+ configAttribsPtr += 2;
- if (mUseDepth) {
+ if (mUserSurfaceConfig.depthMin > 0) {
configAttribsPtr[0] = EGL_DEPTH_SIZE;
- configAttribsPtr[1] = 16;
+ configAttribsPtr[1] = mUserSurfaceConfig.depthMin;
configAttribsPtr += 2;
}
@@ -87,36 +142,101 @@ void Context::initEGL(bool useGL2)
configAttribsPtr[0] = EGL_NONE;
rsAssert(configAttribsPtr < (configAttribs + (sizeof(configAttribs) / sizeof(EGLint))));
- LOGV("initEGL start");
+ LOGV("%p initEGL start", this);
mEGL.mDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
checkEglError("eglGetDisplay");
eglInitialize(mEGL.mDisplay, &mEGL.mMajorVersion, &mEGL.mMinorVersion);
checkEglError("eglInitialize");
- status_t err = EGLUtils::selectConfigForNativeWindow(mEGL.mDisplay, configAttribs, mWndSurface, &mEGL.mConfig);
- if (err) {
- LOGE("couldn't find an EGLConfig matching the screen format\n");
+#if 1
+ PixelFormat pf = PIXEL_FORMAT_RGBA_8888;
+ if (mUserSurfaceConfig.alphaMin == 0) {
+ pf = PIXEL_FORMAT_RGBX_8888;
}
- //eglChooseConfig(mEGL.mDisplay, configAttribs, &mEGL.mConfig, 1, &mEGL.mNumConfigs);
-
- if (useGL2) {
- mEGL.mContext = eglCreateContext(mEGL.mDisplay, mEGL.mConfig, EGL_NO_CONTEXT, context_attribs2);
- } else {
- mEGL.mContext = eglCreateContext(mEGL.mDisplay, mEGL.mConfig, EGL_NO_CONTEXT, NULL);
+ status_t err = EGLUtils::selectConfigForPixelFormat(mEGL.mDisplay, configAttribs, pf, &mEGL.mConfig);
+ if (err) {
+ LOGE("%p, couldn't find an EGLConfig matching the screen format\n", this);
}
+ if (props.mLogVisual) {
+ printEGLConfiguration(mEGL.mDisplay, mEGL.mConfig);
+ }
+#else
+ eglChooseConfig(mEGL.mDisplay, configAttribs, &mEGL.mConfig, 1, &mEGL.mNumConfigs);
+#endif
+
+ mEGL.mContext = eglCreateContext(mEGL.mDisplay, mEGL.mConfig, EGL_NO_CONTEXT, context_attribs2);
checkEglError("eglCreateContext");
if (mEGL.mContext == EGL_NO_CONTEXT) {
- LOGE("eglCreateContext returned EGL_NO_CONTEXT");
+ LOGE("%p, eglCreateContext returned EGL_NO_CONTEXT", this);
}
gGLContextCount++;
+
+
+ EGLint pbuffer_attribs[] = { EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE };
+ mEGL.mSurfaceDefault = eglCreatePbufferSurface(mEGL.mDisplay, mEGL.mConfig, pbuffer_attribs);
+ checkEglError("eglCreatePbufferSurface");
+ if (mEGL.mSurfaceDefault == EGL_NO_SURFACE) {
+ LOGE("eglCreatePbufferSurface returned EGL_NO_SURFACE");
+ }
+
+ EGLBoolean ret = eglMakeCurrent(mEGL.mDisplay, mEGL.mSurfaceDefault, mEGL.mSurfaceDefault, mEGL.mContext);
+ checkEglError("eglMakeCurrent", ret);
+
+ mGL.mVersion = glGetString(GL_VERSION);
+ mGL.mVendor = glGetString(GL_VENDOR);
+ mGL.mRenderer = glGetString(GL_RENDERER);
+ mGL.mExtensions = glGetString(GL_EXTENSIONS);
+
+ //LOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion);
+ LOGV("GL Version %s", mGL.mVersion);
+ //LOGV("GL Vendor %s", mGL.mVendor);
+ LOGV("GL Renderer %s", mGL.mRenderer);
+ //LOGV("GL Extensions %s", mGL.mExtensions);
+
+ const char *verptr = NULL;
+ if (strlen((const char *)mGL.mVersion) > 9) {
+ if (!memcmp(mGL.mVersion, "OpenGL ES-CM", 12)) {
+ verptr = (const char *)mGL.mVersion + 12;
+ }
+ if (!memcmp(mGL.mVersion, "OpenGL ES ", 10)) {
+ verptr = (const char *)mGL.mVersion + 9;
+ }
+ }
+
+ if (!verptr) {
+ LOGE("Error, OpenGL ES Lite not supported");
+ } else {
+ sscanf(verptr, " %i.%i", &mGL.mMajorVersion, &mGL.mMinorVersion);
+ }
+
+ glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &mGL.mMaxVertexAttribs);
+ glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &mGL.mMaxVertexUniformVectors);
+ glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &mGL.mMaxVertexTextureUnits);
+
+ glGetIntegerv(GL_MAX_VARYING_VECTORS, &mGL.mMaxVaryingVectors);
+ glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mGL.mMaxTextureImageUnits);
+
+ glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &mGL.mMaxFragmentTextureImageUnits);
+ glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &mGL.mMaxFragmentUniformVectors);
+
+ mGL.OES_texture_npot = NULL != strstr((const char *)mGL.mExtensions, "GL_OES_texture_npot");
+ mGL.EXT_texture_max_aniso = 1.0f;
+ bool hasAniso = NULL != strstr((const char *)mGL.mExtensions, "GL_EXT_texture_filter_anisotropic");
+ if(hasAniso) {
+ glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &mGL.EXT_texture_max_aniso);
+ }
+
+ LOGV("initGLThread end %p", this);
+ pthread_mutex_unlock(&gInitMutex);
}
void Context::deinitEGL()
{
- LOGV("deinitEGL");
- setSurface(0, 0, NULL);
+ LOGV("%p, deinitEGL", this);
+
+ eglMakeCurrent(mEGL.mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, mEGL.mContext);
eglDestroyContext(mEGL.mDisplay, mEGL.mContext);
checkEglError("eglDestroyContext");
@@ -127,19 +247,21 @@ void Context::deinitEGL()
}
-uint32_t Context::runScript(Script *s, uint32_t launchID)
+uint32_t Context::runScript(Script *s)
{
ObjectBaseRef<ProgramFragment> frag(mFragment);
ObjectBaseRef<ProgramVertex> vtx(mVertex);
- ObjectBaseRef<ProgramFragmentStore> store(mFragmentStore);
+ ObjectBaseRef<ProgramStore> store(mFragmentStore);
ObjectBaseRef<ProgramRaster> raster(mRaster);
+ ObjectBaseRef<Font> font(mFont);
- uint32_t ret = s->run(this, launchID);
+ uint32_t ret = s->run(this);
mFragment.set(frag);
mVertex.set(vtx);
mFragmentStore.set(store);
mRaster.set(raster);
+ mFont.set(font);
return ret;
}
@@ -147,42 +269,19 @@ void Context::checkError(const char *msg) const
{
GLenum err = glGetError();
if (err != GL_NO_ERROR) {
- LOGE("GL Error, 0x%x, from %s", err, msg);
+ LOGE("%p, GL Error, 0x%x, from %s", this, err, msg);
}
}
uint32_t Context::runRootScript()
{
- timerSet(RS_TIMER_CLEAR_SWAP);
- rsAssert(mRootScript->mEnviroment.mIsRoot);
-
- eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_WIDTH, &mEGL.mWidth);
- eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_HEIGHT, &mEGL.mHeight);
- glViewport(0, 0, mEGL.mWidth, mEGL.mHeight);
- glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
-
- glClearColor(mRootScript->mEnviroment.mClearColor[0],
- mRootScript->mEnviroment.mClearColor[1],
- mRootScript->mEnviroment.mClearColor[2],
- mRootScript->mEnviroment.mClearColor[3]);
- if (mUseDepth) {
- glDepthMask(GL_TRUE);
- glClearDepthf(mRootScript->mEnviroment.mClearDepth);
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
- } else {
- glClear(GL_COLOR_BUFFER_BIT);
- }
+ glViewport(0, 0, mWidth, mHeight);
timerSet(RS_TIMER_SCRIPT);
mStateFragmentStore.mLast.clear();
- uint32_t ret = runScript(mRootScript.get(), 0);
+ uint32_t ret = runScript(mRootScript.get());
checkError("runRootScript");
- if (mError != RS_ERROR_NONE) {
- // If we have an error condition we stop rendering until
- // somthing changes that might fix it.
- ret = 0;
- }
return ret;
}
@@ -206,6 +305,9 @@ void Context::timerInit()
mTimeFrame = mTimeLast;
mTimeLastFrame = mTimeLast;
mTimerActive = RS_TIMER_INTERNAL;
+ mAverageFPSFrameCount = 0;
+ mAverageFPSStartTime = mTimeLast;
+ mAverageFPS = 0;
timerReset();
}
@@ -213,6 +315,16 @@ void Context::timerFrame()
{
mTimeLastFrame = mTimeFrame;
mTimeFrame = getTime();
+ // Update average fps
+ const uint64_t averageFramerateInterval = 1000 * 1000000;
+ mAverageFPSFrameCount ++;
+ uint64_t inverval = mTimeFrame - mAverageFPSStartTime;
+ if(inverval >= averageFramerateInterval) {
+ inverval = inverval / 1000000;
+ mAverageFPS = (mAverageFPSFrameCount * 1000) / inverval;
+ mAverageFPSFrameCount = 0;
+ mAverageFPSStartTime = mTimeFrame;
+ }
}
void Context::timerSet(Timers tm)
@@ -236,37 +348,34 @@ void Context::timerPrint()
if (props.mLogTimes) {
- LOGV("RS: Frame (%i), Script %2.1f (%i), Clear & Swap %2.1f (%i), Idle %2.1f (%lli), Internal %2.1f (%lli)",
+ LOGV("RS: Frame (%i), Script %2.1f (%i), Clear & Swap %2.1f (%i), Idle %2.1f (%lli), Internal %2.1f (%lli), Avg fps: %u",
mTimeMSLastFrame,
100.0 * mTimers[RS_TIMER_SCRIPT] / total, mTimeMSLastScript,
100.0 * mTimers[RS_TIMER_CLEAR_SWAP] / total, mTimeMSLastSwap,
100.0 * mTimers[RS_TIMER_IDLE] / total, mTimers[RS_TIMER_IDLE] / 1000000,
- 100.0 * mTimers[RS_TIMER_INTERNAL] / total, mTimers[RS_TIMER_INTERNAL] / 1000000);
+ 100.0 * mTimers[RS_TIMER_INTERNAL] / total, mTimers[RS_TIMER_INTERNAL] / 1000000,
+ mAverageFPS);
}
}
bool Context::setupCheck()
{
- if (checkVersion2_0()) {
- if (!mShaderCache.lookup(this, mVertex.get(), mFragment.get())) {
- LOGE("Context::setupCheck() 1 fail");
- return false;
- }
-
- mFragmentStore->setupGL2(this, &mStateFragmentStore);
- mFragment->setupGL2(this, &mStateFragment, &mShaderCache);
- mRaster->setupGL2(this, &mStateRaster);
- mVertex->setupGL2(this, &mStateVertex, &mShaderCache);
-
- } else {
- mFragmentStore->setupGL(this, &mStateFragmentStore);
- mFragment->setupGL(this, &mStateFragment);
- mRaster->setupGL(this, &mStateRaster);
- mVertex->setupGL(this, &mStateVertex);
+ if (!mShaderCache.lookup(this, mVertex.get(), mFragment.get())) {
+ LOGE("Context::setupCheck() 1 fail");
+ return false;
}
+
+ mFragmentStore->setupGL2(this, &mStateFragmentStore);
+ mFragment->setupGL2(this, &mStateFragment, &mShaderCache);
+ mRaster->setupGL2(this, &mStateRaster);
+ mVertex->setupGL2(this, &mStateVertex, &mShaderCache);
return true;
}
+void Context::setupProgramStore() {
+ mFragmentStore->setupGL2(this, &mStateFragmentStore);
+}
+
static bool getProp(const char *str)
{
char buf[PROPERTY_VALUE_MAX];
@@ -274,6 +383,24 @@ static bool getProp(const char *str)
return 0 != strcmp(buf, "0");
}
+void Context::displayDebugStats()
+{
+ char buffer[128];
+ sprintf(buffer, "Avg fps %u, Frame %i ms, Script %i ms", mAverageFPS, mTimeMSLastFrame, mTimeMSLastScript);
+ float oldR, oldG, oldB, oldA;
+ mStateFont.getFontColor(&oldR, &oldG, &oldB, &oldA);
+ uint32_t bufferLen = strlen(buffer);
+
+ float shadowCol = 0.1f;
+ mStateFont.setFontColor(shadowCol, shadowCol, shadowCol, 1.0f);
+ mStateFont.renderText(buffer, bufferLen, 5, getHeight() - 6);
+
+ mStateFont.setFontColor(1.0f, 0.7f, 0.0f, 1.0f);
+ mStateFont.renderText(buffer, bufferLen, 4, getHeight() - 7);
+
+ mStateFont.setFontColor(oldR, oldG, oldB, oldA);
+}
+
void * Context::threadProc(void *vrsc)
{
Context *rsc = static_cast<Context *>(vrsc);
@@ -286,28 +413,36 @@ void * Context::threadProc(void *vrsc)
rsc->props.mLogScripts = getProp("debug.rs.script");
rsc->props.mLogObjects = getProp("debug.rs.object");
rsc->props.mLogShaders = getProp("debug.rs.shader");
+ rsc->props.mLogShadersAttr = getProp("debug.rs.shader.attributes");
+ rsc->props.mLogShadersUniforms = getProp("debug.rs.shader.uniforms");
+ rsc->props.mLogVisual = getProp("debug.rs.visual");
- ScriptTLSStruct *tlsStruct = new ScriptTLSStruct;
- if (!tlsStruct) {
+ rsc->mTlsStruct = new ScriptTLSStruct;
+ if (!rsc->mTlsStruct) {
LOGE("Error allocating tls storage");
return NULL;
}
- tlsStruct->mContext = rsc;
- tlsStruct->mScript = NULL;
- int status = pthread_setspecific(rsc->gThreadTLSKey, tlsStruct);
+ rsc->mTlsStruct->mContext = rsc;
+ rsc->mTlsStruct->mScript = NULL;
+ int status = pthread_setspecific(rsc->gThreadTLSKey, rsc->mTlsStruct);
if (status) {
LOGE("pthread_setspecific %i", status);
}
+ rsc->initGLThread();
+
+ rsc->mScriptC.init(rsc);
if (rsc->mIsGraphicsContext) {
- rsc->mStateRaster.init(rsc, rsc->mEGL.mWidth, rsc->mEGL.mHeight);
+ rsc->mStateRaster.init(rsc);
rsc->setRaster(NULL);
- rsc->mStateVertex.init(rsc, rsc->mEGL.mWidth, rsc->mEGL.mHeight);
+ rsc->mStateVertex.init(rsc);
rsc->setVertex(NULL);
- rsc->mStateFragment.init(rsc, rsc->mEGL.mWidth, rsc->mEGL.mHeight);
+ rsc->mStateFragment.init(rsc);
rsc->setFragment(NULL);
- rsc->mStateFragmentStore.init(rsc, rsc->mEGL.mWidth, rsc->mEGL.mHeight);
+ rsc->mStateFragmentStore.init(rsc);
rsc->setFragmentStore(NULL);
+ rsc->mStateFont.init(rsc);
+ rsc->setFont(NULL);
rsc->mStateVertexArray.init(rsc);
}
@@ -321,6 +456,11 @@ void * Context::threadProc(void *vrsc)
uint32_t targetTime = 0;
if (mDraw && rsc->mIsGraphicsContext) {
targetTime = rsc->runRootScript();
+
+ if(rsc->props.mLogVisual) {
+ rsc->displayDebugStats();
+ }
+
mDraw = targetTime && !rsc->mPaused;
rsc->timerSet(RS_TIMER_CLEAR_SWAP);
eglSwapBuffers(rsc->mEGL.mDisplay, rsc->mEGL.mSurface);
@@ -329,9 +469,6 @@ void * Context::threadProc(void *vrsc)
rsc->timerPrint();
rsc->timerReset();
}
- if (rsc->mObjDestroy.mNeedToEmpty) {
- rsc->objDestroyOOBRun();
- }
if (rsc->mThreadPriority > 0 && targetTime) {
int32_t t = (targetTime - (int32_t)(rsc->mTimeMSLastScript + rsc->mTimeMSLastSwap)) * 1000;
if (t > 0) {
@@ -340,33 +477,85 @@ void * Context::threadProc(void *vrsc)
}
}
- LOGV("RS Thread exiting");
+ LOGV("%p, RS Thread exiting", rsc);
if (rsc->mIsGraphicsContext) {
rsc->mRaster.clear();
rsc->mFragment.clear();
rsc->mVertex.clear();
rsc->mFragmentStore.clear();
+ rsc->mFont.clear();
rsc->mRootScript.clear();
rsc->mStateRaster.deinit(rsc);
rsc->mStateVertex.deinit(rsc);
rsc->mStateFragment.deinit(rsc);
rsc->mStateFragmentStore.deinit(rsc);
+ rsc->mStateFont.deinit(rsc);
}
ObjectBase::zeroAllUserRef(rsc);
- rsc->mObjDestroy.mNeedToEmpty = true;
- rsc->objDestroyOOBRun();
-
if (rsc->mIsGraphicsContext) {
pthread_mutex_lock(&gInitMutex);
rsc->deinitEGL();
pthread_mutex_unlock(&gInitMutex);
}
+ delete rsc->mTlsStruct;
- LOGV("RS Thread exited");
+ LOGV("%p, RS Thread exited", rsc);
return NULL;
}
+void * Context::helperThreadProc(void *vrsc)
+{
+ Context *rsc = static_cast<Context *>(vrsc);
+ uint32_t idx = (uint32_t)android_atomic_inc(&rsc->mWorkers.mLaunchCount);
+
+ LOGV("RS helperThread starting %p idx=%i", rsc, idx);
+
+ rsc->mWorkers.mLaunchSignals[idx].init();
+ rsc->mWorkers.mNativeThreadId[idx] = gettid();
+
+#if 0
+ typedef struct {uint64_t bits[1024 / 64]; } cpu_set_t;
+ cpu_set_t cpuset;
+ memset(&cpuset, 0, sizeof(cpuset));
+ cpuset.bits[idx / 64] |= 1ULL << (idx % 64);
+ int ret = syscall(241, rsc->mWorkers.mNativeThreadId[idx],
+ sizeof(cpuset), &cpuset);
+ LOGE("SETAFFINITY ret = %i %s", ret, EGLUtils::strerror(ret));
+#endif
+
+ setpriority(PRIO_PROCESS, rsc->mWorkers.mNativeThreadId[idx], rsc->mThreadPriority);
+ int status = pthread_setspecific(rsc->gThreadTLSKey, rsc->mTlsStruct);
+ if (status) {
+ LOGE("pthread_setspecific %i", status);
+ }
+
+ while(rsc->mRunning) {
+ rsc->mWorkers.mLaunchSignals[idx].wait();
+ if (rsc->mWorkers.mLaunchCallback) {
+ rsc->mWorkers.mLaunchCallback(rsc->mWorkers.mLaunchData, idx);
+ }
+ android_atomic_dec(&rsc->mWorkers.mRunningCount);
+ rsc->mWorkers.mCompleteSignal.set();
+ }
+
+ LOGV("RS helperThread exiting %p idx=%i", rsc, idx);
+ return NULL;
+}
+
+void Context::launchThreads(WorkerCallback_t cbk, void *data)
+{
+ mWorkers.mLaunchData = data;
+ mWorkers.mLaunchCallback = cbk;
+ mWorkers.mRunningCount = (int)mWorkers.mCount;
+ for (uint32_t ct = 0; ct < mWorkers.mCount; ct++) {
+ mWorkers.mLaunchSignals[ct].set();
+ }
+ while(mWorkers.mRunningCount) {
+ mWorkers.mCompleteSignal.wait();
+ }
+}
+
void Context::setPriority(int32_t p)
{
// Note: If we put this in the proper "background" policy
@@ -383,11 +572,14 @@ void Context::setPriority(int32_t p)
// success; reset the priority as well
}
#else
- setpriority(PRIO_PROCESS, mNativeThreadId, p);
+ setpriority(PRIO_PROCESS, mNativeThreadId, p);
+ for (uint32_t ct=0; ct < mWorkers.mCount; ct++) {
+ setpriority(PRIO_PROCESS, mWorkers.mNativeThreadId[ct], p);
+ }
#endif
}
-Context::Context(Device *dev, bool isGraphics, bool useDepth)
+Context::Context(Device *dev, const RsSurfaceConfig *sc)
{
pthread_mutex_lock(&gInitMutex);
@@ -395,15 +587,19 @@ Context::Context(Device *dev, bool isGraphics, bool useDepth)
mDev = dev;
mRunning = false;
mExit = false;
- mUseDepth = useDepth;
mPaused = false;
mObjHead = NULL;
mError = RS_ERROR_NONE;
mErrorMsg = NULL;
+ if (sc) {
+ mUserSurfaceConfig = *sc;
+ } else {
+ memset(&mUserSurfaceConfig, 0, sizeof(mUserSurfaceConfig));
+ }
memset(&mEGL, 0, sizeof(mEGL));
memset(&mGL, 0, sizeof(mGL));
- mIsGraphicsContext = isGraphics;
+ mIsGraphicsContext = sc != NULL;
int status;
pthread_attr_t threadAttr;
@@ -417,6 +613,7 @@ Context::Context(Device *dev, bool isGraphics, bool useDepth)
}
}
gThreadTLSKeyCount++;
+
pthread_mutex_unlock(&gInitMutex);
// Global init done at this point.
@@ -429,20 +626,38 @@ Context::Context(Device *dev, bool isGraphics, bool useDepth)
mWndSurface = NULL;
- objDestroyOOBInit();
timerInit();
timerSet(RS_TIMER_INTERNAL);
- LOGV("RS Launching thread");
+ int cpu = sysconf(_SC_NPROCESSORS_ONLN);
+ LOGV("RS Launching thread(s), reported CPU count %i", cpu);
+ if (cpu < 2) cpu = 0;
+
+ mWorkers.mCount = (uint32_t)cpu;
+ mWorkers.mThreadId = (pthread_t *) calloc(mWorkers.mCount, sizeof(pthread_t));
+ mWorkers.mNativeThreadId = (pid_t *) calloc(mWorkers.mCount, sizeof(pid_t));
+ mWorkers.mLaunchSignals = new Signal[mWorkers.mCount];
+ mWorkers.mLaunchCallback = NULL;
status = pthread_create(&mThreadId, &threadAttr, threadProc, this);
if (status) {
LOGE("Failed to start rs context thread.");
+ return;
}
-
while(!mRunning) {
usleep(100);
}
+ mWorkers.mCompleteSignal.init();
+ mWorkers.mRunningCount = 0;
+ mWorkers.mLaunchCount = 0;
+ for (uint32_t ct=0; ct < mWorkers.mCount; ct++) {
+ status = pthread_create(&mWorkers.mThreadId[ct], &threadAttr, helperThreadProc, this);
+ if (status) {
+ mWorkers.mCount = ct;
+ LOGE("Created fewer than expected number of RS threads.");
+ break;
+ }
+ }
pthread_attr_destroy(&threadAttr);
}
@@ -455,8 +670,6 @@ Context::~Context()
mIO.shutdown();
int status = pthread_join(mThreadId, &res);
- mObjDestroy.mNeedToEmpty = true;
- objDestroyOOBRun();
// Global structure cleanup.
pthread_mutex_lock(&gInitMutex);
@@ -469,8 +682,6 @@ Context::~Context()
mDev = NULL;
}
pthread_mutex_unlock(&gInitMutex);
-
- objDestroyOOBDestroy();
}
void Context::setSurface(uint32_t w, uint32_t h, ANativeWindow *sur)
@@ -479,28 +690,21 @@ void Context::setSurface(uint32_t w, uint32_t h, ANativeWindow *sur)
EGLBoolean ret;
if (mEGL.mSurface != NULL) {
- ret = eglMakeCurrent(mEGL.mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ ret = eglMakeCurrent(mEGL.mDisplay, mEGL.mSurfaceDefault, mEGL.mSurfaceDefault, mEGL.mContext);
checkEglError("eglMakeCurrent", ret);
ret = eglDestroySurface(mEGL.mDisplay, mEGL.mSurface);
checkEglError("eglDestroySurface", ret);
mEGL.mSurface = NULL;
- mEGL.mWidth = 0;
- mEGL.mHeight = 0;
- mWidth = 0;
- mHeight = 0;
+ mWidth = 1;
+ mHeight = 1;
}
mWndSurface = sur;
if (mWndSurface != NULL) {
- bool first = false;
- if (!mEGL.mContext) {
- first = true;
- pthread_mutex_lock(&gInitMutex);
- initEGL(true);
- pthread_mutex_unlock(&gInitMutex);
- }
+ mWidth = w;
+ mHeight = h;
mEGL.mSurface = eglCreateWindowSurface(mEGL.mDisplay, mEGL.mConfig, mWndSurface, NULL);
checkEglError("eglCreateWindowSurface");
@@ -511,57 +715,7 @@ void Context::setSurface(uint32_t w, uint32_t h, ANativeWindow *sur)
ret = eglMakeCurrent(mEGL.mDisplay, mEGL.mSurface, mEGL.mSurface, mEGL.mContext);
checkEglError("eglMakeCurrent", ret);
- eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_WIDTH, &mEGL.mWidth);
- eglQuerySurface(mEGL.mDisplay, mEGL.mSurface, EGL_HEIGHT, &mEGL.mHeight);
- mWidth = w;
- mHeight = h;
- mStateVertex.updateSize(this, w, h);
-
- if ((int)mWidth != mEGL.mWidth || (int)mHeight != mEGL.mHeight) {
- LOGE("EGL/Surface mismatch EGL (%i x %i) SF (%i x %i)", mEGL.mWidth, mEGL.mHeight, mWidth, mHeight);
- }
-
- if (first) {
- mGL.mVersion = glGetString(GL_VERSION);
- mGL.mVendor = glGetString(GL_VENDOR);
- mGL.mRenderer = glGetString(GL_RENDERER);
- mGL.mExtensions = glGetString(GL_EXTENSIONS);
-
- //LOGV("EGL Version %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion);
- LOGV("GL Version %s", mGL.mVersion);
- //LOGV("GL Vendor %s", mGL.mVendor);
- LOGV("GL Renderer %s", mGL.mRenderer);
- //LOGV("GL Extensions %s", mGL.mExtensions);
-
- const char *verptr = NULL;
- if (strlen((const char *)mGL.mVersion) > 9) {
- if (!memcmp(mGL.mVersion, "OpenGL ES-CM", 12)) {
- verptr = (const char *)mGL.mVersion + 12;
- }
- if (!memcmp(mGL.mVersion, "OpenGL ES ", 10)) {
- verptr = (const char *)mGL.mVersion + 9;
- }
- }
-
- if (!verptr) {
- LOGE("Error, OpenGL ES Lite not supported");
- } else {
- sscanf(verptr, " %i.%i", &mGL.mMajorVersion, &mGL.mMinorVersion);
- }
-
- glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &mGL.mMaxVertexAttribs);
- glGetIntegerv(GL_MAX_VERTEX_UNIFORM_VECTORS, &mGL.mMaxVertexUniformVectors);
- glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &mGL.mMaxVertexTextureUnits);
-
- glGetIntegerv(GL_MAX_VARYING_VECTORS, &mGL.mMaxVaryingVectors);
- glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &mGL.mMaxTextureImageUnits);
-
- glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &mGL.mMaxFragmentTextureImageUnits);
- glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_VECTORS, &mGL.mMaxFragmentUniformVectors);
-
- mGL.OES_texture_npot = NULL != strstr((const char *)mGL.mExtensions, "GL_OES_texture_npot");
- }
-
+ mStateVertex.updateSize(this);
}
}
@@ -583,7 +737,7 @@ void Context::setRootScript(Script *s)
mRootScript.set(s);
}
-void Context::setFragmentStore(ProgramFragmentStore *pfs)
+void Context::setFragmentStore(ProgramStore *pfs)
{
rsAssert(mIsGraphicsContext);
if (pfs == NULL) {
@@ -623,6 +777,16 @@ void Context::setVertex(ProgramVertex *pv)
}
}
+void Context::setFont(Font *f)
+{
+ rsAssert(mIsGraphicsContext);
+ if (f == NULL) {
+ mFont.set(mStateFont.mDefault);
+ } else {
+ mFont.set(f);
+ }
+}
+
void Context::assignName(ObjectBase *obj, const char *name, uint32_t len)
{
rsAssert(!obj->getName());
@@ -640,90 +804,13 @@ void Context::removeName(ObjectBase *obj)
}
}
-ObjectBase * Context::lookupName(const char *name) const
-{
- for(size_t ct=0; ct < mNames.size(); ct++) {
- if (!strcmp(name, mNames[ct]->getName())) {
- return mNames[ct];
- }
- }
- return NULL;
-}
-
-void Context::appendNameDefines(String8 *str) const
-{
- char buf[256];
- for (size_t ct=0; ct < mNames.size(); ct++) {
- str->append("#define NAMED_");
- str->append(mNames[ct]->getName());
- str->append(" ");
- sprintf(buf, "%i\n", (int)mNames[ct]);
- str->append(buf);
- }
-}
-
-bool Context::objDestroyOOBInit()
-{
- int status = pthread_mutex_init(&mObjDestroy.mMutex, NULL);
- if (status) {
- LOGE("Context::ObjDestroyOOBInit mutex init failure");
- return false;
- }
- return true;
-}
-
-void Context::objDestroyOOBRun()
-{
- if (mObjDestroy.mNeedToEmpty) {
- int status = pthread_mutex_lock(&mObjDestroy.mMutex);
- if (status) {
- LOGE("Context::ObjDestroyOOBRun: error %i locking for OOBRun.", status);
- return;
- }
-
- for (size_t ct = 0; ct < mObjDestroy.mDestroyList.size(); ct++) {
- mObjDestroy.mDestroyList[ct]->decUserRef();
- }
- mObjDestroy.mDestroyList.clear();
- mObjDestroy.mNeedToEmpty = false;
-
- status = pthread_mutex_unlock(&mObjDestroy.mMutex);
- if (status) {
- LOGE("Context::ObjDestroyOOBRun: error %i unlocking for set condition.", status);
- }
- }
-}
-
-void Context::objDestroyOOBDestroy()
-{
- rsAssert(!mObjDestroy.mNeedToEmpty);
- pthread_mutex_destroy(&mObjDestroy.mMutex);
-}
-
-void Context::objDestroyAdd(ObjectBase *obj)
-{
- int status = pthread_mutex_lock(&mObjDestroy.mMutex);
- if (status) {
- LOGE("Context::ObjDestroyOOBRun: error %i locking for OOBRun.", status);
- return;
- }
-
- mObjDestroy.mNeedToEmpty = true;
- mObjDestroy.mDestroyList.add(obj);
-
- status = pthread_mutex_unlock(&mObjDestroy.mMutex);
- if (status) {
- LOGE("Context::ObjDestroyOOBRun: error %i unlocking for set condition.", status);
- }
-}
-
uint32_t Context::getMessageToClient(void *data, size_t *receiveLen, size_t bufferLen, bool wait)
{
//LOGE("getMessageToClient %i %i", bufferLen, wait);
+ *receiveLen = 0;
if (!wait) {
if (mIO.mToClient.isEmpty()) {
// No message to get and not going to wait for one.
- receiveLen = 0;
return 0;
}
}
@@ -751,15 +838,19 @@ bool Context::sendMessageToClient(void *data, uint32_t cmdID, size_t len, bool w
return false;
}
if (!waitForSpace) {
- if (mIO.mToClient.getFreeSpace() < len) {
+ if (!mIO.mToClient.makeSpaceNonBlocking(len + 8)) {
// Not enough room, and not waiting.
return false;
}
}
//LOGE("sendMessageToClient 2");
- void *p = mIO.mToClient.reserve(len);
- memcpy(p, data, len);
- mIO.mToClient.commit(cmdID, len);
+ if (len > 0) {
+ void *p = mIO.mToClient.reserve(len);
+ memcpy(p, data, len);
+ mIO.mToClient.commit(cmdID, len);
+ } else {
+ mIO.mToClient.commit(cmdID, 0);
+ }
//LOGE("sendMessageToClient 3");
return true;
}
@@ -799,15 +890,14 @@ void Context::dumpDebug() const
LOGE("RS Context debug");
LOGE(" EGL ver %i %i", mEGL.mMajorVersion, mEGL.mMinorVersion);
- LOGE(" EGL context %p surface %p, w=%i h=%i Display=%p", mEGL.mContext,
- mEGL.mSurface, mEGL.mWidth, mEGL.mHeight, mEGL.mDisplay);
+ LOGE(" EGL context %p surface %p, Display=%p", mEGL.mContext, mEGL.mSurface, mEGL.mDisplay);
LOGE(" GL vendor: %s", mGL.mVendor);
LOGE(" GL renderer: %s", mGL.mRenderer);
LOGE(" GL Version: %s", mGL.mVersion);
LOGE(" GL Extensions: %s", mGL.mExtensions);
LOGE(" GL int Versions %i %i", mGL.mMajorVersion, mGL.mMinorVersion);
LOGE(" RS width %i, height %i", mWidth, mHeight);
- LOGE(" RS running %i, exit %i, useDepth %i, paused %i", mRunning, mExit, mUseDepth, mPaused);
+ LOGE(" RS running %i, exit %i, paused %i", mRunning, mExit, mPaused);
LOGE(" RS pThreadID %li, nativeThreadID %i", mThreadId, mNativeThreadId);
LOGV("MAX Textures %i, %i %i", mGL.mMaxVertexTextureUnits, mGL.mMaxFragmentTextureImageUnits, mGL.mMaxTextureImageUnits);
@@ -822,6 +912,9 @@ void Context::dumpDebug() const
namespace android {
namespace renderscript {
+void rsi_ContextFinish(Context *rsc)
+{
+}
void rsi_ContextBindRootScript(Context *rsc, RsScript vs)
{
@@ -841,9 +934,9 @@ void rsi_ContextBindSampler(Context *rsc, uint32_t slot, RsSampler vs)
s->bindToContext(&rsc->mStateSampler, slot);
}
-void rsi_ContextBindProgramFragmentStore(Context *rsc, RsProgramFragmentStore vpfs)
+void rsi_ContextBindProgramStore(Context *rsc, RsProgramStore vpfs)
{
- ProgramFragmentStore *pfs = static_cast<ProgramFragmentStore *>(vpfs);
+ ProgramStore *pfs = static_cast<ProgramStore *>(vpfs);
rsc->setFragmentStore(pfs);
}
@@ -865,15 +958,27 @@ void rsi_ContextBindProgramVertex(Context *rsc, RsProgramVertex vpv)
rsc->setVertex(pv);
}
+void rsi_ContextBindFont(Context *rsc, RsFont vfont)
+{
+ Font *font = static_cast<Font *>(vfont);
+ rsc->setFont(font);
+}
+
void rsi_AssignName(Context *rsc, void * obj, const char *name, uint32_t len)
{
ObjectBase *ob = static_cast<ObjectBase *>(obj);
rsc->assignName(ob, name, len);
}
-void rsi_ObjDestroy(Context *rsc, void *obj)
+void rsi_GetName(Context *rsc, void * obj, const char **name)
{
ObjectBase *ob = static_cast<ObjectBase *>(obj);
+ (*name) = ob->getName();
+}
+
+void rsi_ObjDestroy(Context *rsc, void *optr)
+{
+ ObjectBase *ob = static_cast<ObjectBase *>(optr);
rsc->removeName(ob);
ob->decUserRef();
}
@@ -920,15 +1025,16 @@ RsContext rsContextCreate(RsDevice vdev, uint32_t version)
{
LOGV("rsContextCreate %p", vdev);
Device * dev = static_cast<Device *>(vdev);
- Context *rsc = new Context(dev, false, false);
+ Context *rsc = new Context(dev, NULL);
return rsc;
}
-RsContext rsContextCreateGL(RsDevice vdev, uint32_t version, bool useDepth)
+RsContext rsContextCreateGL(RsDevice vdev, uint32_t version, RsSurfaceConfig sc)
{
- LOGV("rsContextCreateGL %p, %i", vdev, useDepth);
+ LOGV("rsContextCreateGL %p", vdev);
Device * dev = static_cast<Device *>(vdev);
- Context *rsc = new Context(dev, true, useDepth);
+ Context *rsc = new Context(dev, &sc);
+ LOGV("rsContextCreateGL ret %p ", rsc);
return rsc;
}
@@ -938,12 +1044,6 @@ void rsContextDestroy(RsContext vrsc)
delete rsc;
}
-void rsObjDestroyOOB(RsContext vrsc, void *obj)
-{
- Context * rsc = static_cast<Context *>(vrsc);
- rsc->objDestroyAdd(static_cast<ObjectBase *>(obj));
-}
-
uint32_t rsContextGetMessage(RsContext vrsc, void *data, size_t *receiveLen, size_t bufferLen, bool wait)
{
Context * rsc = static_cast<Context *>(vrsc);
generated by cgit v1.1 at 2025-08-17 16:29:10 +0000