Home | History | Annotate | Download | only in driver 
      1 /*
      2  * Copyright (C) 2011 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 #include <GLES2/gl2.h>
     18 #include <GLES2/gl2ext.h>
     19 
     20 #include <rs_hal.h>
     21 #include <rsContext.h>
     22 #include <rsProgram.h>
     23 
     24 #include "rsdCore.h"
     25 #include "rsdAllocation.h"
     26 #include "rsdShader.h"
     27 #include "rsdShaderCache.h"
     28 
     29 using namespace android;
     30 using namespace android::renderscript;
     31 
     32 RsdShader::RsdShader(const Program *p, uint32_t type,
     33                        const char * shaderText, uint32_t shaderLength) {
     34 
     35     mUserShader.setTo(shaderText, shaderLength);
     36     mRSProgram = p;
     37     mType = type;
     38     initMemberVars();
     39     initAttribAndUniformArray();
     40     init();
     41 }
     42 
     43 RsdShader::~RsdShader() {
     44     if (mShaderID) {
     45         glDeleteShader(mShaderID);
     46     }
     47 
     48     delete[] mAttribNames;
     49     delete[] mUniformNames;
     50     delete[] mUniformArraySizes;
     51     delete[] mTextureTargets;
     52 }
     53 
     54 void RsdShader::initMemberVars() {
     55     mDirty = true;
     56     mShaderID = 0;
     57     mAttribCount = 0;
     58     mUniformCount = 0;
     59 
     60     mAttribNames = NULL;
     61     mUniformNames = NULL;
     62     mUniformArraySizes = NULL;
     63     mTextureTargets = NULL;
     64 
     65     mIsValid = false;
     66 }
     67 
     68 void RsdShader::init() {
     69     uint32_t attribCount = 0;
     70     uint32_t uniformCount = 0;
     71     for (uint32_t ct=0; ct < mRSProgram->mHal.state.inputElementsCount; ct++) {
     72         initAddUserElement(mRSProgram->mHal.state.inputElements[ct], mAttribNames, NULL, &attribCount, RS_SHADER_ATTR);
     73     }
     74     for (uint32_t ct=0; ct < mRSProgram->mHal.state.constantsCount; ct++) {
     75         initAddUserElement(mRSProgram->mHal.state.constantTypes[ct]->getElement(), mUniformNames, mUniformArraySizes, &uniformCount, RS_SHADER_UNI);
     76     }
     77 
     78     mTextureUniformIndexStart = uniformCount;
     79     char buf[256];
     80     for (uint32_t ct=0; ct < mRSProgram->mHal.state.texturesCount; ct++) {
     81         snprintf(buf, sizeof(buf), "UNI_Tex%i", ct);
     82         mUniformNames[uniformCount].setTo(buf);
     83         mUniformArraySizes[uniformCount] = 1;
     84         uniformCount++;
     85     }
     86 
     87 }
     88 
     89 String8 RsdShader::getGLSLInputString() const {
     90     String8 s;
     91     for (uint32_t ct=0; ct < mRSProgram->mHal.state.inputElementsCount; ct++) {
     92         const Element *e = mRSProgram->mHal.state.inputElements[ct];
     93         for (uint32_t field=0; field < e->getFieldCount(); field++) {
     94             const Element *f = e->getField(field);
     95 
     96             // Cannot be complex
     97             rsAssert(!f->getFieldCount());
     98             switch (f->getComponent().getVectorSize()) {
     99             case 1: s.append("attribute float ATTRIB_"); break;
    100             case 2: s.append("attribute vec2 ATTRIB_"); break;
    101             case 3: s.append("attribute vec3 ATTRIB_"); break;
    102             case 4: s.append("attribute vec4 ATTRIB_"); break;
    103             default:
    104                 rsAssert(0);
    105             }
    106 
    107             s.append(e->getFieldName(field));
    108             s.append(";\n");
    109         }
    110     }
    111     return s;
    112 }
    113 
    114 void RsdShader::appendAttributes() {
    115     for (uint32_t ct=0; ct < mRSProgram->mHal.state.inputElementsCount; ct++) {
    116         const Element *e = mRSProgram->mHal.state.inputElements[ct];
    117         for (uint32_t field=0; field < e->getFieldCount(); field++) {
    118             const Element *f = e->getField(field);
    119             const char *fn = e->getFieldName(field);
    120 
    121             if (fn[0] == '#') {
    122                 continue;
    123             }
    124 
    125             // Cannot be complex
    126             rsAssert(!f->getFieldCount());
    127             switch (f->getComponent().getVectorSize()) {
    128             case 1: mShader.append("attribute float ATTRIB_"); break;
    129             case 2: mShader.append("attribute vec2 ATTRIB_"); break;
    130             case 3: mShader.append("attribute vec3 ATTRIB_"); break;
    131             case 4: mShader.append("attribute vec4 ATTRIB_"); break;
    132             default:
    133                 rsAssert(0);
    134             }
    135 
    136             mShader.append(fn);
    137             mShader.append(";\n");
    138         }
    139     }
    140 }
    141 
    142 void RsdShader::appendTextures() {
    143     char buf[256];
    144     for (uint32_t ct=0; ct < mRSProgram->mHal.state.texturesCount; ct++) {
    145         if (mRSProgram->mHal.state.textureTargets[ct] == RS_TEXTURE_2D) {
    146             snprintf(buf, sizeof(buf), "uniform sampler2D UNI_Tex%i;\n", ct);
    147             mTextureTargets[ct] = GL_TEXTURE_2D;
    148         } else {
    149             snprintf(buf, sizeof(buf), "uniform samplerCube UNI_Tex%i;\n", ct);
    150             mTextureTargets[ct] = GL_TEXTURE_CUBE_MAP;
    151         }
    152         mShader.append(buf);
    153     }
    154 }
    155 
    156 bool RsdShader::createShader() {
    157 
    158     if (mType == GL_FRAGMENT_SHADER) {
    159         mShader.append("precision mediump float;\n");
    160     }
    161     appendUserConstants();
    162     appendAttributes();
    163     appendTextures();
    164 
    165     mShader.append(mUserShader);
    166 
    167     return true;
    168 }
    169 
    170 bool RsdShader::loadShader(const Context *rsc) {
    171     mShaderID = glCreateShader(mType);
    172     rsAssert(mShaderID);
    173 
    174     if (rsc->props.mLogShaders) {
    175         LOGV("Loading shader type %x, ID %i", mType, mShaderID);
    176         LOGV("%s", mShader.string());
    177     }
    178 
    179     if (mShaderID) {
    180         const char * ss = mShader.string();
    181         RSD_CALL_GL(glShaderSource, mShaderID, 1, &ss, NULL);
    182         RSD_CALL_GL(glCompileShader, mShaderID);
    183 
    184         GLint compiled = 0;
    185         RSD_CALL_GL(glGetShaderiv, mShaderID, GL_COMPILE_STATUS, &compiled);
    186         if (!compiled) {
    187             GLint infoLen = 0;
    188             RSD_CALL_GL(glGetShaderiv, mShaderID, GL_INFO_LOG_LENGTH, &infoLen);
    189             if (infoLen) {
    190                 char* buf = (char*) malloc(infoLen);
    191                 if (buf) {
    192                     RSD_CALL_GL(glGetShaderInfoLog, mShaderID, infoLen, NULL, buf);
    193                     LOGE("Could not compile shader \n%s\n", buf);
    194                     free(buf);
    195                 }
    196                 RSD_CALL_GL(glDeleteShader, mShaderID);
    197                 mShaderID = 0;
    198                 rsc->setError(RS_ERROR_BAD_SHADER, "Error returned from GL driver loading shader text,");
    199                 return false;
    200             }
    201         }
    202     }
    203 
    204     if (rsc->props.mLogShaders) {
    205         LOGV("--Shader load result %x ", glGetError());
    206     }
    207     mIsValid = true;
    208     return true;
    209 }
    210 
    211 void RsdShader::appendUserConstants() {
    212     for (uint32_t ct=0; ct < mRSProgram->mHal.state.constantsCount; ct++) {
    213         const Element *e = mRSProgram->mHal.state.constantTypes[ct]->getElement();
    214         for (uint32_t field=0; field < e->getFieldCount(); field++) {
    215             const Element *f = e->getField(field);
    216             const char *fn = e->getFieldName(field);
    217 
    218             if (fn[0] == '#') {
    219                 continue;
    220             }
    221 
    222             // Cannot be complex
    223             rsAssert(!f->getFieldCount());
    224             if (f->getType() == RS_TYPE_MATRIX_4X4) {
    225                 mShader.append("uniform mat4 UNI_");
    226             } else if (f->getType() == RS_TYPE_MATRIX_3X3) {
    227                 mShader.append("uniform mat3 UNI_");
    228             } else if (f->getType() == RS_TYPE_MATRIX_2X2) {
    229                 mShader.append("uniform mat2 UNI_");
    230             } else {
    231                 switch (f->getComponent().getVectorSize()) {
    232                 case 1: mShader.append("uniform float UNI_"); break;
    233                 case 2: mShader.append("uniform vec2 UNI_"); break;
    234                 case 3: mShader.append("uniform vec3 UNI_"); break;
    235                 case 4: mShader.append("uniform vec4 UNI_"); break;
    236                 default:
    237                     rsAssert(0);
    238                 }
    239             }
    240 
    241             mShader.append(fn);
    242             if (e->getFieldArraySize(field) > 1) {
    243                 mShader.appendFormat("[%d]", e->getFieldArraySize(field));
    244             }
    245             mShader.append(";\n");
    246         }
    247     }
    248 }
    249 
    250 void RsdShader::logUniform(const Element *field, const float *fd, uint32_t arraySize ) {
    251     RsDataType dataType = field->getType();
    252     uint32_t elementSize = field->getSizeBytes() / sizeof(float);
    253     for (uint32_t i = 0; i < arraySize; i ++) {
    254         if (arraySize > 1) {
    255             LOGV("Array Element [%u]", i);
    256         }
    257         if (dataType == RS_TYPE_MATRIX_4X4) {
    258             LOGV("Matrix4x4");
    259             LOGV("{%f, %f, %f, %f",  fd[0], fd[4], fd[8], fd[12]);
    260             LOGV(" %f, %f, %f, %f",  fd[1], fd[5], fd[9], fd[13]);
    261             LOGV(" %f, %f, %f, %f",  fd[2], fd[6], fd[10], fd[14]);
    262             LOGV(" %f, %f, %f, %f}", fd[3], fd[7], fd[11], fd[15]);
    263         } else if (dataType == RS_TYPE_MATRIX_3X3) {
    264             LOGV("Matrix3x3");
    265             LOGV("{%f, %f, %f",  fd[0], fd[3], fd[6]);
    266             LOGV(" %f, %f, %f",  fd[1], fd[4], fd[7]);
    267             LOGV(" %f, %f, %f}", fd[2], fd[5], fd[8]);
    268         } else if (dataType == RS_TYPE_MATRIX_2X2) {
    269             LOGV("Matrix2x2");
    270             LOGV("{%f, %f",  fd[0], fd[2]);
    271             LOGV(" %f, %f}", fd[1], fd[3]);
    272         } else {
    273             switch (field->getComponent().getVectorSize()) {
    274             case 1:
    275                 LOGV("Uniform 1 = %f", fd[0]);
    276                 break;
    277             case 2:
    278                 LOGV("Uniform 2 = %f %f", fd[0], fd[1]);
    279                 break;
    280             case 3:
    281                 LOGV("Uniform 3 = %f %f %f", fd[0], fd[1], fd[2]);
    282                 break;
    283             case 4:
    284                 LOGV("Uniform 4 = %f %f %f %f", fd[0], fd[1], fd[2], fd[3]);
    285                 break;
    286             default:
    287                 rsAssert(0);
    288             }
    289         }
    290         LOGE("Element size %u data=%p", elementSize, fd);
    291         fd += elementSize;
    292         LOGE("New data=%p", fd);
    293     }
    294 }
    295 
    296 void RsdShader::setUniform(const Context *rsc, const Element *field, const float *fd,
    297                          int32_t slot, uint32_t arraySize ) {
    298     RsDataType dataType = field->getType();
    299     if (dataType == RS_TYPE_MATRIX_4X4) {
    300         RSD_CALL_GL(glUniformMatrix4fv, slot, arraySize, GL_FALSE, fd);
    301     } else if (dataType == RS_TYPE_MATRIX_3X3) {
    302         RSD_CALL_GL(glUniformMatrix3fv, slot, arraySize, GL_FALSE, fd);
    303     } else if (dataType == RS_TYPE_MATRIX_2X2) {
    304         RSD_CALL_GL(glUniformMatrix2fv, slot, arraySize, GL_FALSE, fd);
    305     } else {
    306         switch (field->getComponent().getVectorSize()) {
    307         case 1:
    308             RSD_CALL_GL(glUniform1fv, slot, arraySize, fd);
    309             break;
    310         case 2:
    311             RSD_CALL_GL(glUniform2fv, slot, arraySize, fd);
    312             break;
    313         case 3:
    314             RSD_CALL_GL(glUniform3fv, slot, arraySize, fd);
    315             break;
    316         case 4:
    317             RSD_CALL_GL(glUniform4fv, slot, arraySize, fd);
    318             break;
    319         default:
    320             rsAssert(0);
    321         }
    322     }
    323 }
    324 
    325 void RsdShader::setupSampler(const Context *rsc, const Sampler *s, const Allocation *tex) {
    326     RsdHal *dc = (RsdHal *)rsc->mHal.drv;
    327 
    328     GLenum trans[] = {
    329         GL_NEAREST, //RS_SAMPLER_NEAREST,
    330         GL_LINEAR, //RS_SAMPLER_LINEAR,
    331         GL_LINEAR_MIPMAP_LINEAR, //RS_SAMPLER_LINEAR_MIP_LINEAR,
    332         GL_REPEAT, //RS_SAMPLER_WRAP,
    333         GL_CLAMP_TO_EDGE, //RS_SAMPLER_CLAMP
    334         GL_LINEAR_MIPMAP_NEAREST, //RS_SAMPLER_LINEAR_MIP_NEAREST
    335     };
    336 
    337     GLenum transNP[] = {
    338         GL_NEAREST, //RS_SAMPLER_NEAREST,
    339         GL_LINEAR, //RS_SAMPLER_LINEAR,
    340         GL_LINEAR, //RS_SAMPLER_LINEAR_MIP_LINEAR,
    341         GL_CLAMP_TO_EDGE, //RS_SAMPLER_WRAP,
    342         GL_CLAMP_TO_EDGE, //RS_SAMPLER_CLAMP
    343         GL_LINEAR, //RS_SAMPLER_LINEAR_MIP_NEAREST,
    344     };
    345 
    346     // This tells us the correct texture type
    347     DrvAllocation *drvTex = (DrvAllocation *)tex->mHal.drv;
    348     const GLenum target = drvTex->glTarget;
    349 
    350     if (!dc->gl.gl.OES_texture_npot && tex->getType()->getIsNp2()) {
    351         if (tex->getHasGraphicsMipmaps() &&
    352             (dc->gl.gl.GL_NV_texture_npot_2D_mipmap || dc->gl.gl.GL_IMG_texture_npot)) {
    353             if (dc->gl.gl.GL_NV_texture_npot_2D_mipmap) {
    354                 RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_MIN_FILTER,
    355                             trans[s->mHal.state.minFilter]);
    356             } else {
    357                 switch (trans[s->mHal.state.minFilter]) {
    358                 case GL_LINEAR_MIPMAP_LINEAR:
    359                     RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_MIN_FILTER,
    360                                 GL_LINEAR_MIPMAP_NEAREST);
    361                     break;
    362                 default:
    363                     RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_MIN_FILTER,
    364                                 trans[s->mHal.state.minFilter]);
    365                     break;
    366                 }
    367             }
    368         } else {
    369             RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_MIN_FILTER,
    370                         transNP[s->mHal.state.minFilter]);
    371         }
    372         RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_MAG_FILTER,
    373                     transNP[s->mHal.state.magFilter]);
    374         RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_WRAP_S, transNP[s->mHal.state.wrapS]);
    375         RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_WRAP_T, transNP[s->mHal.state.wrapT]);
    376     } else {
    377         if (tex->getHasGraphicsMipmaps()) {
    378             RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_MIN_FILTER,
    379                         trans[s->mHal.state.minFilter]);
    380         } else {
    381             RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_MIN_FILTER,
    382                         transNP[s->mHal.state.minFilter]);
    383         }
    384         RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_MAG_FILTER, trans[s->mHal.state.magFilter]);
    385         RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_WRAP_S, trans[s->mHal.state.wrapS]);
    386         RSD_CALL_GL(glTexParameteri, target, GL_TEXTURE_WRAP_T, trans[s->mHal.state.wrapT]);
    387     }
    388 
    389     float anisoValue = rsMin(dc->gl.gl.EXT_texture_max_aniso, s->mHal.state.aniso);
    390     if (dc->gl.gl.EXT_texture_max_aniso > 1.0f) {
    391         RSD_CALL_GL(glTexParameterf, target, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisoValue);
    392     }
    393 
    394     rsdGLCheckError(rsc, "Sampler::setup tex env");
    395 }
    396 
    397 void RsdShader::setupTextures(const Context *rsc, RsdShaderCache *sc) {
    398     if (mRSProgram->mHal.state.texturesCount == 0) {
    399         return;
    400     }
    401 
    402     RsdHal *dc = (RsdHal *)rsc->mHal.drv;
    403 
    404     uint32_t numTexturesToBind = mRSProgram->mHal.state.texturesCount;
    405     uint32_t numTexturesAvailable = dc->gl.gl.maxFragmentTextureImageUnits;
    406     if (numTexturesToBind >= numTexturesAvailable) {
    407         LOGE("Attempting to bind %u textures on shader id %u, but only %u are available",
    408              mRSProgram->mHal.state.texturesCount, (uint32_t)this, numTexturesAvailable);
    409         rsc->setError(RS_ERROR_BAD_SHADER, "Cannot bind more textuers than available");
    410         numTexturesToBind = numTexturesAvailable;
    411     }
    412 
    413     for (uint32_t ct=0; ct < numTexturesToBind; ct++) {
    414         RSD_CALL_GL(glActiveTexture, GL_TEXTURE0 + ct);
    415         RSD_CALL_GL(glUniform1i, sc->fragUniformSlot(mTextureUniformIndexStart + ct), ct);
    416 
    417         if (!mRSProgram->mHal.state.textures[ct]) {
    418             // if nothing is bound, reset to default GL texture
    419             RSD_CALL_GL(glBindTexture, mTextureTargets[ct], 0);
    420             continue;
    421         }
    422 
    423         DrvAllocation *drvTex = (DrvAllocation *)mRSProgram->mHal.state.textures[ct]->mHal.drv;
    424         if (drvTex->glTarget != GL_TEXTURE_2D && drvTex->glTarget != GL_TEXTURE_CUBE_MAP) {
    425             LOGE("Attempting to bind unknown texture to shader id %u, texture unit %u", (uint)this, ct);
    426             rsc->setError(RS_ERROR_BAD_SHADER, "Non-texture allocation bound to a shader");
    427         }
    428         RSD_CALL_GL(glBindTexture, drvTex->glTarget, drvTex->textureID);
    429         rsdGLCheckError(rsc, "ProgramFragment::setup tex bind");
    430         if (mRSProgram->mHal.state.samplers[ct]) {
    431             setupSampler(rsc, mRSProgram->mHal.state.samplers[ct],
    432                          mRSProgram->mHal.state.textures[ct]);
    433         } else {
    434             RSD_CALL_GL(glTexParameteri, drvTex->glTarget, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    435             RSD_CALL_GL(glTexParameteri, drvTex->glTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    436             RSD_CALL_GL(glTexParameteri, drvTex->glTarget, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    437             RSD_CALL_GL(glTexParameteri, drvTex->glTarget, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    438             rsdGLCheckError(rsc, "ProgramFragment::setup tex env");
    439         }
    440         rsdGLCheckError(rsc, "ProgramFragment::setup uniforms");
    441     }
    442 
    443     RSD_CALL_GL(glActiveTexture, GL_TEXTURE0);
    444     mDirty = false;
    445     rsdGLCheckError(rsc, "ProgramFragment::setup");
    446 }
    447 
    448 void RsdShader::setupUserConstants(const Context *rsc, RsdShaderCache *sc, bool isFragment) {
    449     uint32_t uidx = 0;
    450     for (uint32_t ct=0; ct < mRSProgram->mHal.state.constantsCount; ct++) {
    451         Allocation *alloc = mRSProgram->mHal.state.constants[ct];
    452         if (!alloc) {
    453             LOGE("Attempting to set constants on shader id %u, but alloc at slot %u is not set",
    454                  (uint32_t)this, ct);
    455             rsc->setError(RS_ERROR_BAD_SHADER, "No constant allocation bound");
    456             continue;
    457         }
    458 
    459         const uint8_t *data = static_cast<const uint8_t *>(alloc->getPtr());
    460         const Element *e = mRSProgram->mHal.state.constantTypes[ct]->getElement();
    461         for (uint32_t field=0; field < e->getFieldCount(); field++) {
    462             const Element *f = e->getField(field);
    463             const char *fieldName = e->getFieldName(field);
    464             // If this field is padding, skip it
    465             if (fieldName[0] == '#') {
    466                 continue;
    467             }
    468 
    469             uint32_t offset = e->getFieldOffsetBytes(field);
    470             const float *fd = reinterpret_cast<const float *>(&data[offset]);
    471 
    472             int32_t slot = -1;
    473             uint32_t arraySize = 1;
    474             if (!isFragment) {
    475                 slot = sc->vtxUniformSlot(uidx);
    476                 arraySize = sc->vtxUniformSize(uidx);
    477             } else {
    478                 slot = sc->fragUniformSlot(uidx);
    479                 arraySize = sc->fragUniformSize(uidx);
    480             }
    481             if (rsc->props.mLogShadersUniforms) {
    482                 LOGV("Uniform  slot=%i, offset=%i, constant=%i, field=%i, uidx=%i, name=%s",
    483                      slot, offset, ct, field, uidx, fieldName);
    484             }
    485             uidx ++;
    486             if (slot < 0) {
    487                 continue;
    488             }
    489 
    490             if (rsc->props.mLogShadersUniforms) {
    491                 logUniform(f, fd, arraySize);
    492             }
    493             setUniform(rsc, f, fd, slot, arraySize);
    494         }
    495     }
    496 }
    497 
    498 void RsdShader::setup(const android::renderscript::Context *rsc, RsdShaderCache *sc) {
    499 
    500     setupUserConstants(rsc, sc, mType == GL_FRAGMENT_SHADER);
    501     setupTextures(rsc, sc);
    502 }
    503 
    504 void RsdShader::initAttribAndUniformArray() {
    505     mAttribCount = 0;
    506     for (uint32_t ct=0; ct < mRSProgram->mHal.state.inputElementsCount; ct++) {
    507         const Element *elem = mRSProgram->mHal.state.inputElements[ct];
    508         for (uint32_t field=0; field < elem->getFieldCount(); field++) {
    509             if (elem->getFieldName(field)[0] != '#') {
    510                 mAttribCount ++;
    511             }
    512         }
    513     }
    514 
    515     mUniformCount = 0;
    516     for (uint32_t ct=0; ct < mRSProgram->mHal.state.constantsCount; ct++) {
    517         const Element *elem = mRSProgram->mHal.state.constantTypes[ct]->getElement();
    518 
    519         for (uint32_t field=0; field < elem->getFieldCount(); field++) {
    520             if (elem->getFieldName(field)[0] != '#') {
    521                 mUniformCount ++;
    522             }
    523         }
    524     }
    525     mUniformCount += mRSProgram->mHal.state.texturesCount;
    526 
    527     if (mAttribCount) {
    528         mAttribNames = new String8[mAttribCount];
    529     }
    530     if (mUniformCount) {
    531         mUniformNames = new String8[mUniformCount];
    532         mUniformArraySizes = new uint32_t[mUniformCount];
    533     }
    534 
    535     mTextureCount = mRSProgram->mHal.state.texturesCount;
    536     if (mTextureCount) {
    537         mTextureTargets = new uint32_t[mTextureCount];
    538     }
    539 }
    540 
    541 void RsdShader::initAddUserElement(const Element *e, String8 *names, uint32_t *arrayLengths,
    542                                    uint32_t *count, const char *prefix) {
    543     rsAssert(e->getFieldCount());
    544     for (uint32_t ct=0; ct < e->getFieldCount(); ct++) {
    545         const Element *ce = e->getField(ct);
    546         if (ce->getFieldCount()) {
    547             initAddUserElement(ce, names, arrayLengths, count, prefix);
    548         } else if (e->getFieldName(ct)[0] != '#') {
    549             String8 tmp(prefix);
    550             tmp.append(e->getFieldName(ct));
    551             names[*count].setTo(tmp.string());
    552             if (arrayLengths) {
    553                 arrayLengths[*count] = e->getFieldArraySize(ct);
    554             }
    555             (*count)++;
    556         }
    557     }
    558 }
    559