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