Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 1 | /* |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 2 | * Copyright (C) 2011 The Android Open Source Project |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 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 "rsContext.h" |
Alex Sakhartchouk | fb6b614 | 2010-05-21 12:53:13 -0700 | [diff] [blame] | 18 | #include "rsProgram.h" |
Jason Sams | c460e55 | 2009-11-25 13:22:07 -0800 | [diff] [blame] | 19 | |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 20 | #include <inttypes.h> |
| 21 | |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 22 | using namespace android; |
| 23 | using namespace android::renderscript; |
| 24 | |
Alex Sakhartchouk | 748eb07 | 2012-02-15 16:21:46 -0800 | [diff] [blame] | 25 | Program::Program(Context *rsc, const char * shaderText, size_t shaderLength, |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 26 | const uintptr_t * params, size_t paramLength) |
Alex Sakhartchouk | 7f126c7 | 2011-05-05 16:56:27 -0700 | [diff] [blame] | 27 | : ProgramBase(rsc) { |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 28 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 29 | initMemberVars(); |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 30 | for (uint32_t ct=0; ct < paramLength; ct+=2) { |
| 31 | if (params[ct] == RS_PROGRAM_PARAM_INPUT) { |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 32 | mHal.state.inputElementsCount++; |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 33 | } |
| 34 | if (params[ct] == RS_PROGRAM_PARAM_CONSTANT) { |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 35 | mHal.state.constantsCount++; |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 36 | } |
Alex Sakhartchouk | 84e4027 | 2010-11-18 15:22:43 -0800 | [diff] [blame] | 37 | if (params[ct] == RS_PROGRAM_PARAM_TEXTURE_TYPE) { |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 38 | mHal.state.texturesCount++; |
Jason Sams | f2e4fa2 | 2009-12-15 13:27:04 -0800 | [diff] [blame] | 39 | } |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 40 | } |
| 41 | |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 42 | mTextures = new ObjectBaseRef<Allocation>[mHal.state.texturesCount]; |
| 43 | mSamplers = new ObjectBaseRef<Sampler>[mHal.state.texturesCount]; |
| 44 | mInputElements = new ObjectBaseRef<Element>[mHal.state.inputElementsCount]; |
| 45 | mConstantTypes = new ObjectBaseRef<Type>[mHal.state.constantsCount]; |
| 46 | mConstants = new ObjectBaseRef<Allocation>[mHal.state.constantsCount]; |
| 47 | |
| 48 | mHal.state.textures = new Allocation*[mHal.state.texturesCount]; |
| 49 | mHal.state.samplers = new Sampler*[mHal.state.texturesCount]; |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 50 | mHal.state.textureTargets = new RsTextureTarget[mHal.state.texturesCount]; |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 51 | mHal.state.inputElements = new Element*[mHal.state.inputElementsCount]; |
| 52 | mHal.state.constantTypes = new Type*[mHal.state.constantsCount]; |
| 53 | mHal.state.constants = new Allocation*[mHal.state.constantsCount]; |
| 54 | |
| 55 | // Will initialize everything |
| 56 | freeChildren(); |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 57 | |
| 58 | uint32_t input = 0; |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 59 | uint32_t constant = 0; |
Alex Sakhartchouk | 84e4027 | 2010-11-18 15:22:43 -0800 | [diff] [blame] | 60 | uint32_t texture = 0; |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 61 | for (uint32_t ct=0; ct < paramLength; ct+=2) { |
| 62 | if (params[ct] == RS_PROGRAM_PARAM_INPUT) { |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 63 | mInputElements[input].set(reinterpret_cast<Element *>(params[ct+1])); |
| 64 | mHal.state.inputElements[input++] = reinterpret_cast<Element *>(params[ct+1]); |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 65 | } |
| 66 | if (params[ct] == RS_PROGRAM_PARAM_CONSTANT) { |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 67 | mConstantTypes[constant].set(reinterpret_cast<Type *>(params[ct+1])); |
| 68 | mHal.state.constantTypes[constant++] = reinterpret_cast<Type *>(params[ct+1]); |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 69 | } |
Alex Sakhartchouk | 84e4027 | 2010-11-18 15:22:43 -0800 | [diff] [blame] | 70 | if (params[ct] == RS_PROGRAM_PARAM_TEXTURE_TYPE) { |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 71 | mHal.state.textureTargets[texture++] = (RsTextureTarget)params[ct+1]; |
Alex Sakhartchouk | 84e4027 | 2010-11-18 15:22:43 -0800 | [diff] [blame] | 72 | } |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 73 | } |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 74 | mIsInternal = false; |
| 75 | uint32_t internalTokenLen = strlen(RS_SHADER_INTERNAL); |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 76 | if (shaderLength > internalTokenLen && |
Alex Sakhartchouk | e7ae69f | 2010-09-14 09:50:43 -0700 | [diff] [blame] | 77 | strncmp(RS_SHADER_INTERNAL, shaderText, internalTokenLen) == 0) { |
| 78 | mIsInternal = true; |
| 79 | shaderText += internalTokenLen; |
| 80 | shaderLength -= internalTokenLen; |
| 81 | } |
Jason Sams | f313dc3 | 2013-07-09 14:29:39 -0700 | [diff] [blame] | 82 | |
| 83 | mUserShader = rsuCopyString(shaderText, shaderLength); |
| 84 | mUserShaderLen = shaderLength; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 85 | } |
| 86 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 87 | Program::~Program() { |
Jason Sams | c7cec1e | 2011-08-18 18:01:33 -0700 | [diff] [blame] | 88 | freeChildren(); |
Alex Sakhartchouk | 889fe50 | 2010-10-01 10:54:06 -0700 | [diff] [blame] | 89 | |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 90 | delete[] mTextures; |
| 91 | delete[] mSamplers; |
| 92 | delete[] mInputElements; |
| 93 | delete[] mConstantTypes; |
| 94 | delete[] mConstants; |
| 95 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 96 | delete[] mHal.state.textures; |
| 97 | delete[] mHal.state.samplers; |
| 98 | delete[] mHal.state.textureTargets; |
| 99 | delete[] mHal.state.inputElements; |
| 100 | delete[] mHal.state.constantTypes; |
| 101 | delete[] mHal.state.constants; |
| 102 | mHal.state.inputElementsCount = 0; |
| 103 | mHal.state.constantsCount = 0; |
| 104 | mHal.state.texturesCount = 0; |
Jason Sams | f313dc3 | 2013-07-09 14:29:39 -0700 | [diff] [blame] | 105 | |
| 106 | if (mUserShader != NULL) { |
| 107 | delete[] mUserShader; |
| 108 | mUserShader = NULL; |
| 109 | } |
| 110 | mUserShaderLen = 0; |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 111 | } |
| 112 | |
Jason Sams | c7cec1e | 2011-08-18 18:01:33 -0700 | [diff] [blame] | 113 | bool Program::freeChildren() { |
| 114 | for (uint32_t ct=0; ct < mHal.state.constantsCount; ct++) { |
| 115 | bindAllocation(NULL, NULL, ct); |
| 116 | } |
| 117 | |
| 118 | for (uint32_t ct=0; ct < mHal.state.texturesCount; ct++) { |
| 119 | bindTexture(NULL, ct, NULL); |
| 120 | bindSampler(NULL, ct, NULL); |
| 121 | } |
| 122 | return false; |
| 123 | } |
| 124 | |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 125 | void Program::initMemberVars() { |
| 126 | mDirty = true; |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 127 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 128 | mHal.drv = NULL; |
| 129 | mHal.state.textures = NULL; |
| 130 | mHal.state.samplers = NULL; |
| 131 | mHal.state.textureTargets = NULL; |
| 132 | mHal.state.inputElements = NULL; |
| 133 | mHal.state.constantTypes = NULL; |
| 134 | mHal.state.constants = NULL; |
| 135 | |
| 136 | mHal.state.inputElementsCount = 0; |
| 137 | mHal.state.constantsCount = 0; |
| 138 | mHal.state.texturesCount = 0; |
| 139 | |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 140 | mTextures = NULL; |
| 141 | mSamplers = NULL; |
| 142 | mInputElements = NULL; |
| 143 | mConstantTypes = NULL; |
| 144 | mConstants = NULL; |
| 145 | |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 146 | mIsInternal = false; |
Jason Sams | f313dc3 | 2013-07-09 14:29:39 -0700 | [diff] [blame] | 147 | |
| 148 | mUserShader = NULL; |
| 149 | mUserShaderLen = 0; |
Alex Sakhartchouk | 54929cc | 2010-11-08 15:10:52 -0800 | [diff] [blame] | 150 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 151 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 152 | void Program::bindAllocation(Context *rsc, Allocation *alloc, uint32_t slot) { |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 153 | if (alloc != NULL) { |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 154 | if (slot >= mHal.state.constantsCount) { |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 155 | ALOGE("Attempt to bind alloc at slot %u, on shader id %" PRIuPTR ", but const count is %u", |
| 156 | slot, (uintptr_t)this, mHal.state.constantsCount); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 157 | rsc->setError(RS_ERROR_BAD_SHADER, "Cannot bind allocation"); |
| 158 | return; |
| 159 | } |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 160 | if (alloc->getType() != mConstantTypes[slot].get()) { |
Ian Rogers | f8852d0 | 2014-01-29 15:35:17 -0800 | [diff] [blame] | 161 | ALOGE("Attempt to bind alloc at slot %u, on shader id %" PRIuPTR ", but types mismatch", |
| 162 | slot, (uintptr_t)this); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 163 | rsc->setError(RS_ERROR_BAD_SHADER, "Cannot bind allocation"); |
| 164 | return; |
| 165 | } |
| 166 | } |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 167 | if (mConstants[slot].get() == alloc) { |
Jason Sams | 5c3e3bc | 2009-10-26 15:19:28 -0700 | [diff] [blame] | 168 | return; |
| 169 | } |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 170 | if (mConstants[slot].get()) { |
| 171 | mConstants[slot]->removeProgramToDirty(this); |
Jason Sams | 5c3e3bc | 2009-10-26 15:19:28 -0700 | [diff] [blame] | 172 | } |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 173 | mConstants[slot].set(alloc); |
| 174 | mHal.state.constants[slot] = alloc; |
Jason Sams | 5c3e3bc | 2009-10-26 15:19:28 -0700 | [diff] [blame] | 175 | if (alloc) { |
| 176 | alloc->addProgramToDirty(this); |
| 177 | } |
Jason Sams | 326e0dd | 2009-05-22 14:03:28 -0700 | [diff] [blame] | 178 | mDirty = true; |
| 179 | } |
| 180 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 181 | void Program::bindTexture(Context *rsc, uint32_t slot, Allocation *a) { |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 182 | if (slot >= mHal.state.texturesCount) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 183 | ALOGE("Attempt to bind texture to slot %u but tex count is %u", slot, mHal.state.texturesCount); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 184 | rsc->setError(RS_ERROR_BAD_SHADER, "Cannot bind texture"); |
Jason Sams | 7dad9c3 | 2009-12-17 16:55:08 -0800 | [diff] [blame] | 185 | return; |
| 186 | } |
| 187 | |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 188 | if (a && a->getType()->getDimFaces() && mHal.state.textureTargets[slot] != RS_TEXTURE_CUBE) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 189 | ALOGE("Attempt to bind cubemap to slot %u but 2d texture needed", slot); |
Alex Sakhartchouk | 84e4027 | 2010-11-18 15:22:43 -0800 | [diff] [blame] | 190 | rsc->setError(RS_ERROR_BAD_SHADER, "Cannot bind cubemap to 2d texture slot"); |
| 191 | return; |
| 192 | } |
| 193 | |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 194 | mTextures[slot].set(a); |
| 195 | mHal.state.textures[slot] = a; |
| 196 | |
Jason Sams | 7dad9c3 | 2009-12-17 16:55:08 -0800 | [diff] [blame] | 197 | mDirty = true; |
| 198 | } |
| 199 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 200 | void Program::bindSampler(Context *rsc, uint32_t slot, Sampler *s) { |
Alex Sakhartchouk | a04e30d | 2011-04-29 16:49:08 -0700 | [diff] [blame] | 201 | if (slot >= mHal.state.texturesCount) { |
Steve Block | af12ac6 | 2012-01-06 19:20:56 +0000 | [diff] [blame] | 202 | ALOGE("Attempt to bind sampler to slot %u but tex count is %u", slot, mHal.state.texturesCount); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 203 | rsc->setError(RS_ERROR_BAD_SHADER, "Cannot bind sampler"); |
Jason Sams | 7dad9c3 | 2009-12-17 16:55:08 -0800 | [diff] [blame] | 204 | return; |
| 205 | } |
| 206 | |
Alex Sakhartchouk | 064aa7e | 2011-10-18 10:54:29 -0700 | [diff] [blame] | 207 | mSamplers[slot].set(s); |
| 208 | mHal.state.samplers[slot] = s; |
Jason Sams | 7dad9c3 | 2009-12-17 16:55:08 -0800 | [diff] [blame] | 209 | mDirty = true; |
| 210 | } |
| 211 | |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 212 | namespace android { |
| 213 | namespace renderscript { |
| 214 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 215 | void rsi_ProgramBindConstants(Context *rsc, RsProgram vp, uint32_t slot, RsAllocation constants) { |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 216 | Program *p = static_cast<Program *>(vp); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 217 | p->bindAllocation(rsc, static_cast<Allocation *>(constants), slot); |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 218 | } |
| 219 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 220 | void rsi_ProgramBindTexture(Context *rsc, RsProgram vpf, uint32_t slot, RsAllocation a) { |
Jason Sams | 7dad9c3 | 2009-12-17 16:55:08 -0800 | [diff] [blame] | 221 | Program *p = static_cast<Program *>(vpf); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 222 | p->bindTexture(rsc, slot, static_cast<Allocation *>(a)); |
Jason Sams | 7dad9c3 | 2009-12-17 16:55:08 -0800 | [diff] [blame] | 223 | } |
| 224 | |
Alex Sakhartchouk | afb743a | 2010-11-09 17:00:54 -0800 | [diff] [blame] | 225 | void rsi_ProgramBindSampler(Context *rsc, RsProgram vpf, uint32_t slot, RsSampler s) { |
Jason Sams | 7dad9c3 | 2009-12-17 16:55:08 -0800 | [diff] [blame] | 226 | Program *p = static_cast<Program *>(vpf); |
Alex Sakhartchouk | 383e5b1 | 2010-09-23 16:16:33 -0700 | [diff] [blame] | 227 | p->bindSampler(rsc, slot, static_cast<Sampler *>(s)); |
Jason Sams | 7dad9c3 | 2009-12-17 16:55:08 -0800 | [diff] [blame] | 228 | } |
Jason Sams | 4815c0d | 2009-12-15 12:58:36 -0800 | [diff] [blame] | 229 | |
| 230 | } |
| 231 | } |
| 232 | |