Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "rsLib cleanup"

Browse Source
This commit is contained in:
Alex Sakhartchouk
2011-05-12 10:15:17 -07:00
committed by Android (Google) Code Review
parent e4ba346f0f 407cae9503
commit 415c842aa6
18 changed files with 66 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
libs/rs/driver/rsdGL.cpp
View File

@@ -30,11 +30,8 @@
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
//#include <cutils/sched_policy.h>
//#include <sys/syscall.h>
#include <string.h>
#include "rsdCore.h"
#include "rsdGL.h"
@@ -346,3 +343,27 @@ void rsdGLSwap(const android::renderscript::Context *rsc) {
eglSwapBuffers(dc->gl.egl.display, dc->gl.egl.surface);
}
void rsdGLCheckError(const android::renderscript::Context *rsc,
const char *msg, bool isFatal) {
GLenum err = glGetError();
if (err != GL_NO_ERROR) {
char buf[1024];
snprintf(buf, sizeof(buf), "GL Error = 0x%08x, from: %s", err, msg);
if (isFatal) {
rsc->setError(RS_ERROR_FATAL_DRIVER, buf);
} else {
switch (err) {
case GL_OUT_OF_MEMORY:
rsc->setError(RS_ERROR_OUT_OF_MEMORY, buf);
break;
default:
rsc->setError(RS_ERROR_DRIVER, buf);
break;
}
}
LOGE("%p, %s", rsc, buf);
}
}

2
libs/rs/driver/rsdGL.h
View File

@@ -76,6 +76,8 @@ void rsdGLShutdown(const android::renderscript::Context *rsc);
bool rsdGLSetSurface(const android::renderscript::Context *rsc,
uint32_t w, uint32_t h, ANativeWindow *sur);
void rsdGLSwap(const android::renderscript::Context *rsc);
void rsdGLCheckError(const android::renderscript::Context *rsc,
const char *msg, bool isFatal = false);
#endif

9
libs/rs/driver/rsdMeshObj.cpp
View File

@@ -23,6 +23,7 @@
#include <rsMesh.h>
#include "rsdMeshObj.h"
#include "rsdGL.h"
using namespace android;
using namespace android::renderscript;
@@ -134,7 +135,7 @@ void RsdMeshObj::renderPrimitiveRange(const Context *rsc, uint32_t primIndex, ui
return;
}
rsc->checkError("Mesh::renderPrimitiveRange 1");
rsdGLCheckError(rsc, "Mesh::renderPrimitiveRange 1");
// update attributes with either buffer information or data ptr based on their current state
for (uint32_t ct=0; ct < mAttribCount; ct++) {
uint32_t allocIndex = mAttribAllocationIndex[ct];
@@ -149,9 +150,9 @@ void RsdMeshObj::renderPrimitiveRange(const Context *rsc, uint32_t primIndex, ui
}
RsdVertexArray va(mAttribs, mAttribCount);
va.setupGL2(rsc);
va.setup(rsc);
rsc->checkError("Mesh::renderPrimitiveRange 2");
rsdGLCheckError(rsc, "Mesh::renderPrimitiveRange 2");
Mesh::Primitive_t *prim = mRSMesh->mHal.state.primitives[primIndex];
if (prim->mIndexBuffer.get()) {
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, prim->mIndexBuffer->getBufferObjectID());
@@ -160,7 +161,7 @@ void RsdMeshObj::renderPrimitiveRange(const Context *rsc, uint32_t primIndex, ui
glDrawArrays(mGLPrimitives[primIndex], start, len);
}
rsc->checkError("Mesh::renderPrimitiveRange");
rsdGLCheckError(rsc, "Mesh::renderPrimitiveRange");
}
void RsdMeshObj::updateGLPrimitives() {

14
libs/rs/driver/rsdShader.cpp
View File

@@ -377,7 +377,7 @@ void RsdShader::setupSampler(const Context *rsc, const Sampler *s, const Allocat
glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisoValue);
}
rsc->checkError("Sampler::setupGL2 tex env");
rsdGLCheckError(rsc, "Sampler::setup tex env");
}
void RsdShader::setupTextures(const Context *rsc, RsdShaderCache *sc) {
@@ -385,8 +385,10 @@ void RsdShader::setupTextures(const Context *rsc, RsdShaderCache *sc) {
return;
}
RsdHal *dc = (RsdHal *)rsc->mHal.drv;
uint32_t numTexturesToBind = mRSProgram->mHal.state.texturesCount;
uint32_t numTexturesAvailable = rsc->getMaxFragmentTextures();
uint32_t numTexturesAvailable = dc->gl.gl.maxFragmentTextureImageUnits;
if (numTexturesToBind >= numTexturesAvailable) {
LOGE("Attempting to bind %u textures on shader id %u, but only %u are available",
mRSProgram->mHal.state.texturesCount, (uint32_t)this, numTexturesAvailable);
@@ -408,7 +410,7 @@ void RsdShader::setupTextures(const Context *rsc, RsdShaderCache *sc) {
rsc->setError(RS_ERROR_BAD_SHADER, "Non-texture allocation bound to a shader");
}
glBindTexture(target, mRSProgram->mHal.state.textures[ct]->getTextureID());
rsc->checkError("ProgramFragment::setupGL2 tex bind");
rsdGLCheckError(rsc, "ProgramFragment::setup tex bind");
if (mRSProgram->mHal.state.samplers[ct].get()) {
setupSampler(rsc, mRSProgram->mHal.state.samplers[ct].get(), mRSProgram->mHal.state.textures[ct].get());
} else {
@@ -416,16 +418,16 @@ void RsdShader::setupTextures(const Context *rsc, RsdShaderCache *sc) {
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
rsc->checkError("ProgramFragment::setupGL2 tex env");
rsdGLCheckError(rsc, "ProgramFragment::setup tex env");
}
glUniform1i(sc->fragUniformSlot(mTextureUniformIndexStart + ct), ct);
rsc->checkError("ProgramFragment::setupGL2 uniforms");
rsdGLCheckError(rsc, "ProgramFragment::setup uniforms");
}
glActiveTexture(GL_TEXTURE0);
mDirty = false;
rsc->checkError("ProgramFragment::setupGL2");
rsdGLCheckError(rsc, "ProgramFragment::setup");
}
void RsdShader::setupUserConstants(const Context *rsc, RsdShaderCache *sc, bool isFragment) {

5
libs/rs/driver/rsdShaderCache.cpp
View File

@@ -19,6 +19,7 @@
#include "rsdShader.h"
#include "rsdShaderCache.h"
#include "rsdGL.h"
#include <GLES/gl.h>
#include <GLES2/gl2.h>
@@ -128,7 +129,7 @@ bool RsdShaderCache::link(const Context *rsc) {
glUseProgram(mEntries[ct]->program);
mCurrent = mEntries[ct];
//LOGV("RsdShaderCache hit, using %i", ct);
rsc->checkError("RsdShaderCache::link (hit)");
rsdGLCheckError(rsc, "RsdShaderCache::link (hit)");
return true;
}
}
@@ -230,7 +231,7 @@ bool RsdShaderCache::link(const Context *rsc) {
//LOGV("SC made program %i", e->program);
glUseProgram(e->program);
rsc->checkError("RsdShaderCache::link (miss)");
rsdGLCheckError(rsc, "RsdShaderCache::link (miss)");
return true;
}

9
libs/rs/driver/rsdVertexArray.cpp
View File

@@ -20,6 +20,7 @@
#include <GLES/gl.h>
#include <GLES2/gl2.h>
#include "rsdGL.h"
#include "rsdCore.h"
#include "rsdVertexArray.h"
#include "rsdShaderCache.h"
@@ -78,13 +79,13 @@ void RsdVertexArray::logAttrib(uint32_t idx, uint32_t slot) const {
mAttribs[idx].offset);
}
void RsdVertexArray::setupGL2(const Context *rsc) const {
void RsdVertexArray::setup(const Context *rsc) const {
RsdHal *dc = (RsdHal *)rsc->mHal.drv;
RsdVertexArrayState *state = dc->gl.vertexArrayState;
RsdShaderCache *sc = dc->gl.shaderCache;
rsc->checkError("RsdVertexArray::setupGL2 start");
rsdGLCheckError(rsc, "RsdVertexArray::setup start");
uint32_t maxAttrs = state->mAttrsEnabledSize;
for (uint32_t ct=1; ct < maxAttrs; ct++) {
@@ -94,7 +95,7 @@ void RsdVertexArray::setupGL2(const Context *rsc) const {
}
}
rsc->checkError("RsdVertexArray::setupGL2 disabled");
rsdGLCheckError(rsc, "RsdVertexArray::setup disabled");
for (uint32_t ct=0; ct < mCount; ct++) {
int32_t slot = sc->vtxAttribSlot(mAttribs[ct].name);
if (rsc->props.mLogShadersAttr) {
@@ -113,7 +114,7 @@ void RsdVertexArray::setupGL2(const Context *rsc) const {
mAttribs[ct].stride,
mAttribs[ct].ptr + mAttribs[ct].offset);
}
rsc->checkError("RsdVertexArray::setupGL2 done");
rsdGLCheckError(rsc, "RsdVertexArray::setup done");
}
////////////////////////////////////////////
RsdVertexArrayState::RsdVertexArrayState() {

2
libs/rs/driver/rsdVertexArray.h
View File

@@ -49,7 +49,7 @@ public:
RsdVertexArray(const Attrib *attribs, uint32_t numAttribs);
virtual ~RsdVertexArray();
void setupGL2(const android::renderscript::Context *rsc) const;
void setup(const android::renderscript::Context *rsc) const;
void logAttrib(uint32_t idx, uint32_t slot) const;
protected:

4
libs/rs/rsAllocation.cpp
View File

@@ -209,7 +209,7 @@ void Allocation::uploadToTexture(const Context *rsc) {
freeScriptMemory();
}
rsc->checkError("Allocation::uploadToTexture");
//rsc->checkError("Allocation::uploadToTexture");
#endif //ANDROID_RS_SERIALIZE
}
@@ -334,7 +334,7 @@ void Allocation::uploadToBufferObject(const Context *rsc) {
glBindBuffer(target, mBufferID);
glBufferData(target, mHal.state.type->getSizeBytes(), getPtr(), GL_DYNAMIC_DRAW);
glBindBuffer(target, 0);
rsc->checkError("Allocation::uploadToBufferObject");
//rsc->checkError("Allocation::uploadToBufferObject");
#endif //ANDROID_RS_SERIALIZE
}

61
libs/rs/rsContext.cpp
View File

@@ -27,11 +27,6 @@
#include <cutils/properties.h>
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#include <cutils/sched_policy.h>
#include <sys/syscall.h>
#include <string.h>
@@ -52,28 +47,6 @@ bool Context::initGLThread() {
return false;
}
const char * ext = (const char *)glGetString(GL_EXTENSIONS);
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(ext, "GL_OES_texture_npot");
mGL.GL_IMG_texture_npot = NULL != strstr(ext, "GL_IMG_texture_npot");
mGL.GL_NV_texture_npot_2D_mipmap = NULL != strstr(ext, "GL_NV_texture_npot_2D_mipmap");
mGL.EXT_texture_max_aniso = 1.0f;
bool hasAniso = NULL != strstr(ext, "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);
return true;
}
@@ -112,38 +85,11 @@ uint32_t Context::runScript(Script *s) {
return ret;
}
void Context::checkError(const char *msg, bool isFatal) const {
GLenum err = glGetError();
if (err != GL_NO_ERROR) {
char buf[1024];
snprintf(buf, sizeof(buf), "GL Error = 0x%08x, from: %s", err, msg);
if (isFatal) {
setError(RS_ERROR_FATAL_DRIVER, buf);
} else {
switch (err) {
case GL_OUT_OF_MEMORY:
setError(RS_ERROR_OUT_OF_MEMORY, buf);
break;
default:
setError(RS_ERROR_DRIVER, buf);
break;
}
}
LOGE("%p, %s", this, buf);
}
}
uint32_t Context::runRootScript() {
glViewport(0, 0, mWidth, mHeight);
timerSet(RS_TIMER_SCRIPT);
mStateFragmentStore.mLast.clear();
uint32_t ret = runScript(mRootScript.get());
checkError("runRootScript");
return ret;
}
@@ -217,10 +163,10 @@ void Context::timerPrint() {
bool Context::setupCheck() {
mFragmentStore->setup(this, &mStateFragmentStore);
mFragment->setupGL2(this, &mStateFragment);
mFragment->setup(this, &mStateFragment);
mRaster->setup(this, &mStateRaster);
mVertex->setupGL2(this, &mStateVertex);
mFBOCache.setupGL2(this);
mVertex->setup(this, &mStateVertex);
mFBOCache.setup(this);
return true;
}
@@ -406,7 +352,6 @@ bool Context::initContext(Device *dev, const RsSurfaceConfig *sc) {
memset(&mUserSurfaceConfig, 0, sizeof(mUserSurfaceConfig));
}
memset(&mGL, 0, sizeof(mGL));
mIsGraphicsContext = sc != NULL;
int status;

30
libs/rs/rsContext.h
View File

@@ -42,9 +42,10 @@
#include "rsgApiStructs.h"
#include "rsLocklessFifo.h"
#include <ui/egl/android_natives.h>
#endif // ANDROID_RS_SERIALIZE
class ANativeWindow;
// ---------------------------------------------------------------------------
namespace android {
@@ -197,43 +198,16 @@ public:
} props;
void dumpDebug() const;
void checkError(const char *, bool isFatal = false) const;
void setError(RsError e, const char *msg = NULL) const;
mutable const ObjectBase * mObjHead;
bool ext_OES_texture_npot() const {return mGL.OES_texture_npot;}
bool ext_GL_IMG_texture_npot() const {return mGL.GL_IMG_texture_npot;}
bool ext_GL_NV_texture_npot_2D_mipmap() const {return mGL.GL_NV_texture_npot_2D_mipmap;}
float ext_texture_max_aniso() const {return mGL.EXT_texture_max_aniso; }
uint32_t getMaxFragmentTextures() const {return mGL.mMaxFragmentTextureImageUnits;}
uint32_t getMaxFragmentUniformVectors() const {return mGL.mMaxFragmentUniformVectors;}
uint32_t getMaxVertexUniformVectors() const {return mGL.mMaxVertexUniformVectors;}
uint32_t getMaxVertexAttributes() const {return mGL.mMaxVertexAttribs;}
uint32_t getDPI() const {return mDPI;}
void setDPI(uint32_t dpi) {mDPI = dpi;}
Device *mDev;
protected:
struct {
int32_t mMaxVaryingVectors;
int32_t mMaxTextureImageUnits;
int32_t mMaxFragmentTextureImageUnits;
int32_t mMaxFragmentUniformVectors;
int32_t mMaxVertexAttribs;
int32_t mMaxVertexUniformVectors;
int32_t mMaxVertexTextureUnits;
bool OES_texture_npot;
bool GL_IMG_texture_npot;
bool GL_NV_texture_npot_2D_mipmap;
float EXT_texture_max_aniso;
} mGL;
uint32_t mDPI;
uint32_t mWidth;
uint32_t mHeight;

5
libs/rs/rsFBOCache.cpp
View File

@@ -30,7 +30,7 @@ using namespace android::renderscript;
FBOCache::FBOCache() {
mFBOId = 0;
mDirty = false;
mDirty = true;
mMaxTargets = 1;
mColorTargets = new ObjectBaseRef<Allocation>[mMaxTargets];
}
@@ -180,7 +180,7 @@ void FBOCache::setColorAttachment(Context *rsc) {
#endif //ANDROID_RS_SERIALIZE
}
void FBOCache::setupGL2(Context *rsc) {
void FBOCache::setup(Context *rsc) {
#ifndef ANDROID_RS_SERIALIZE
if (!mDirty) {
return;
@@ -205,5 +205,6 @@ void FBOCache::setupGL2(Context *rsc) {
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewport(0, 0, rsc->getWidth(), rsc->getHeight());
}
mDirty = false;
#endif //ANDROID_RS_SERIALIZE
}

2
libs/rs/rsFBOCache.h
View File

@@ -34,7 +34,7 @@ public:
void bindDepthTarget(Context *, Allocation *a);
void resetAll(Context *);
void setupGL2(Context *);
void setup(Context *);
protected:

2
libs/rs/rsMesh.cpp
View File

@@ -199,10 +199,8 @@ void Mesh::renderPrimitiveRange(Context *rsc, uint32_t primIndex, uint32_t start
if (prim->mIndexBuffer.get()) {
prim->mIndexBuffer->uploadCheck(rsc);
}
rsc->checkError("Mesh::renderPrimitiveRange upload check");
mRSC->mHal.funcs.mesh.draw(mRSC, this, primIndex, start, len);
rsc->checkError("Mesh::renderPrimitiveRange draw");
}
void Mesh::uploadAll(Context *rsc) {

4
libs/rs/rsProgramFragment.cpp
View File

@@ -55,14 +55,12 @@ void ProgramFragment::setConstantColor(Context *rsc, float r, float g, float b,
mDirty = true;
}
void ProgramFragment::setupGL2(Context *rsc, ProgramFragmentState *state) {
void ProgramFragment::setup(Context *rsc, ProgramFragmentState *state) {
if ((state->mLast.get() == this) && !mDirty) {
return;
}
state->mLast.set(this);
rsc->checkError("ProgramFragment::setupGL2 start");
for (uint32_t ct=0; ct < mHal.state.texturesCount; ct++) {
if (!mHal.state.textures[ct].get()) {
LOGE("No texture bound for shader id %u, texture unit %u", (uint)this, ct);

2
libs/rs/rsProgramFragment.h
View File

@@ -32,7 +32,7 @@ public:
uint32_t paramLength);
virtual ~ProgramFragment();
virtual void setupGL2(Context *, ProgramFragmentState *);
virtual void setup(Context *, ProgramFragmentState *);
virtual void serialize(OStream *stream) const;
virtual RsA3DClassID getClassId() const { return RS_A3D_CLASS_ID_PROGRAM_FRAGMENT; }

2
libs/rs/rsProgramVertex.cpp
View File

@@ -32,7 +32,7 @@ ProgramVertex::~ProgramVertex() {
mRSC->mHal.funcs.vertex.destroy(mRSC, this);
}
void ProgramVertex::setupGL2(Context *rsc, ProgramVertexState *state) {
void ProgramVertex::setup(Context *rsc, ProgramVertexState *state) {
if ((state->mLast.get() == this) && !mDirty) {
return;
}

2
libs/rs/rsProgramVertex.h
View File

@@ -31,7 +31,7 @@ public:
const uint32_t * params, uint32_t paramLength);
virtual ~ProgramVertex();
virtual void setupGL2(Context *rsc, ProgramVertexState *state);
virtual void setup(Context *rsc, ProgramVertexState *state);
void setProjectionMatrix(Context *, const rsc_Matrix *) const;
void getProjectionMatrix(Context *, rsc_Matrix *) const;

6
libs/rs/rsScriptC_LibGL.cpp
View File

@@ -156,7 +156,7 @@ void rsrDrawQuadTexCoords(Context *rsc, Script *sc,
attribs[1].set(GL_FLOAT, 2, 8, false, (uint32_t)tex, "ATTRIB_texture0");
RsdVertexArray va(attribs, 2);
va.setupGL2(rsc);
va.setup(rsc);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
}
@@ -250,7 +250,7 @@ void rsrFinish(Context *rsc, Script *sc) {
void rsrClearColor(Context *rsc, Script *sc, float r, float g, float b, float a) {
rsc->mFBOCache.setupGL2(rsc);
rsc->mFBOCache.setup(rsc);
rsc->setupProgramStore();
glClearColor(r, g, b, a);
@@ -258,7 +258,7 @@ void rsrClearColor(Context *rsc, Script *sc, float r, float g, float b, float a)
}
void rsrClearDepth(Context *rsc, Script *sc, float v) {
rsc->mFBOCache.setupGL2(rsc);
rsc->mFBOCache.setup(rsc);
rsc->setupProgramStore();
glClearDepthf(v);