1 /* libs/pixelflinger/codeflinger/texturing.cpp 2 ** 3 ** Copyright 2006, The Android Open Source Project 4 ** 5 ** Licensed under the Apache License, Version 2.0 (the "License"); 6 ** you may not use this file except in compliance with the License. 7 ** You may obtain a copy of the License at 8 ** 9 ** http://www.apache.org/licenses/LICENSE-2.0 10 ** 11 ** Unless required by applicable law or agreed to in writing, software 12 ** distributed under the License is distributed on an "AS IS" BASIS, 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 ** See the License for the specific language governing permissions and 15 ** limitations under the License. 16 */ 17 18 #include <assert.h> 19 #include <stdint.h> 20 #include <stdlib.h> 21 #include <stdio.h> 22 #include <sys/types.h> 23 24 #include <cutils/log.h> 25 26 #include "codeflinger/GGLAssembler.h" 27 28 #ifdef __ARM_ARCH__ 29 #include <machine/cpu-features.h> 30 #endif 31 32 namespace android { 33 34 // --------------------------------------------------------------------------- 35 36 // iterators are initialized like this: 37 // (intToFixedCenter(x) * dx)>>16 + x0 38 // ((x<<16 + 0x8000) * dx)>>16 + x0 39 // ((x<<16)*dx + (0x8000*dx))>>16 + x0 40 // ( (x*dx) + dx>>1 ) + x0 41 // (x*dx) + (dx>>1 + x0) 42 43 void GGLAssembler::init_iterated_color(fragment_parts_t& parts, const reg_t& x) 44 { 45 context_t const* c = mBuilderContext.c; 46 const needs_t& needs = mBuilderContext.needs; 47 48 if (mSmooth) { 49 // NOTE: we could take this case in the mDithering + !mSmooth case, 50 // but this would use up to 4 more registers for the color components 51 // for only a little added quality. 52 // Currently, this causes the system to run out of registers in 53 // some case (see issue #719496) 54 55 comment("compute initial iterated color (smooth and/or dither case)"); 56 57 parts.iterated_packed = 0; 58 parts.packed = 0; 59 60 // 0x1: color component 61 // 0x2: iterators 62 const int optReload = mOptLevel >> 1; 63 if (optReload >= 3) parts.reload = 0; // reload nothing 64 else if (optReload == 2) parts.reload = 2; // reload iterators 65 else if (optReload == 1) parts.reload = 1; // reload colors 66 else if (optReload <= 0) parts.reload = 3; // reload both 67 68 if (!mSmooth) { 69 // we're not smoothing (just dithering), we never have to 70 // reload the iterators 71 parts.reload &= ~2; 72 } 73 74 Scratch scratches(registerFile()); 75 const int t0 = (parts.reload & 1) ? scratches.obtain() : 0; 76 const int t1 = (parts.reload & 2) ? scratches.obtain() : 0; 77 for (int i=0 ; i<4 ; i++) { 78 if (!mInfo[i].iterated) 79 continue; 80 81 // this component exists in the destination and is not replaced 82 // by a texture unit. 83 const int c = (parts.reload & 1) ? t0 : obtainReg(); 84 if (i==0) CONTEXT_LOAD(c, iterators.ydady); 85 if (i==1) CONTEXT_LOAD(c, iterators.ydrdy); 86 if (i==2) CONTEXT_LOAD(c, iterators.ydgdy); 87 if (i==3) CONTEXT_LOAD(c, iterators.ydbdy); 88 parts.argb[i].reg = c; 89 90 if (mInfo[i].smooth) { 91 parts.argb_dx[i].reg = (parts.reload & 2) ? t1 : obtainReg(); 92 const int dvdx = parts.argb_dx[i].reg; 93 CONTEXT_LOAD(dvdx, generated_vars.argb[i].dx); 94 MLA(AL, 0, c, x.reg, dvdx, c); 95 96 // adjust the color iterator to make sure it won't overflow 97 if (!mAA) { 98 // this is not needed when we're using anti-aliasing 99 // because we will (have to) clamp the components 100 // anyway. 101 int end = scratches.obtain(); 102 MOV(AL, 0, end, reg_imm(parts.count.reg, LSR, 16)); 103 MLA(AL, 1, end, dvdx, end, c); 104 SUB(MI, 0, c, c, end); 105 BIC(AL, 0, c, c, reg_imm(c, ASR, 31)); 106 scratches.recycle(end); 107 } 108 } 109 110 if (parts.reload & 1) { 111 CONTEXT_STORE(c, generated_vars.argb[i].c); 112 } 113 } 114 } else { 115 // We're not smoothed, so we can 116 // just use a packed version of the color and extract the 117 // components as needed (or not at all if we don't blend) 118 119 // figure out if we need the iterated color 120 int load = 0; 121 for (int i=0 ; i<4 ; i++) { 122 component_info_t& info = mInfo[i]; 123 if ((info.inDest || info.needed) && !info.replaced) 124 load |= 1; 125 } 126 127 parts.iterated_packed = 1; 128 parts.packed = (!mTextureMachine.mask && !mBlending 129 && !mFog && !mDithering); 130 parts.reload = 0; 131 if (load || parts.packed) { 132 if (mBlending || mDithering || mInfo[GGLFormat::ALPHA].needed) { 133 comment("load initial iterated color (8888 packed)"); 134 parts.iterated.setTo(obtainReg(), 135 &(c->formats[GGL_PIXEL_FORMAT_RGBA_8888])); 136 CONTEXT_LOAD(parts.iterated.reg, packed8888); 137 } else { 138 comment("load initial iterated color (dest format packed)"); 139 140 parts.iterated.setTo(obtainReg(), &mCbFormat); 141 142 // pre-mask the iterated color 143 const int bits = parts.iterated.size(); 144 const uint32_t size = ((bits>=32) ? 0 : (1LU << bits)) - 1; 145 uint32_t mask = 0; 146 if (mMasking) { 147 for (int i=0 ; i<4 ; i++) { 148 const int component_mask = 1<<i; 149 const int h = parts.iterated.format.c[i].h; 150 const int l = parts.iterated.format.c[i].l; 151 if (h && (!(mMasking & component_mask))) { 152 mask |= ((1<<(h-l))-1) << l; 153 } 154 } 155 } 156 157 if (mMasking && ((mask & size)==0)) { 158 // none of the components are present in the mask 159 } else { 160 CONTEXT_LOAD(parts.iterated.reg, packed); 161 if (mCbFormat.size == 1) { 162 AND(AL, 0, parts.iterated.reg, 163 parts.iterated.reg, imm(0xFF)); 164 } else if (mCbFormat.size == 2) { 165 MOV(AL, 0, parts.iterated.reg, 166 reg_imm(parts.iterated.reg, LSR, 16)); 167 } 168 } 169 170 // pre-mask the iterated color 171 if (mMasking) { 172 build_and_immediate(parts.iterated.reg, parts.iterated.reg, 173 mask, bits); 174 } 175 } 176 } 177 } 178 } 179 180 void GGLAssembler::build_iterated_color( 181 component_t& fragment, 182 const fragment_parts_t& parts, 183 int component, 184 Scratch& regs) 185 { 186 fragment.setTo( regs.obtain(), 0, 32, CORRUPTIBLE); 187 188 if (!mInfo[component].iterated) 189 return; 190 191 if (parts.iterated_packed) { 192 // iterated colors are packed, extract the one we need 193 extract(fragment, parts.iterated, component); 194 } else { 195 fragment.h = GGL_COLOR_BITS; 196 fragment.l = GGL_COLOR_BITS - 8; 197 fragment.flags |= CLEAR_LO; 198 // iterated colors are held in their own register, 199 // (smooth and/or dithering case) 200 if (parts.reload==3) { 201 // this implies mSmooth 202 Scratch scratches(registerFile()); 203 int dx = scratches.obtain(); 204 CONTEXT_LOAD(fragment.reg, generated_vars.argb[component].c); 205 CONTEXT_LOAD(dx, generated_vars.argb[component].dx); 206 ADD(AL, 0, dx, fragment.reg, dx); 207 CONTEXT_STORE(dx, generated_vars.argb[component].c); 208 } else if (parts.reload & 1) { 209 CONTEXT_LOAD(fragment.reg, generated_vars.argb[component].c); 210 } else { 211 // we don't reload, so simply rename the register and mark as 212 // non CORRUPTIBLE so that the texture env or blending code 213 // won't modify this (renamed) register 214 regs.recycle(fragment.reg); 215 fragment.reg = parts.argb[component].reg; 216 fragment.flags &= ~CORRUPTIBLE; 217 } 218 if (mInfo[component].smooth && mAA) { 219 // when using smooth shading AND anti-aliasing, we need to clamp 220 // the iterators because there is always an extra pixel on the 221 // edges, which most of the time will cause an overflow 222 // (since technically its outside of the domain). 223 BIC(AL, 0, fragment.reg, fragment.reg, 224 reg_imm(fragment.reg, ASR, 31)); 225 component_sat(fragment); 226 } 227 } 228 } 229 230 // --------------------------------------------------------------------------- 231 232 void GGLAssembler::decodeLogicOpNeeds(const needs_t& needs) 233 { 234 // gather some informations about the components we need to process... 235 const int opcode = GGL_READ_NEEDS(LOGIC_OP, needs.n) | GGL_CLEAR; 236 switch(opcode) { 237 case GGL_COPY: 238 mLogicOp = 0; 239 break; 240 case GGL_CLEAR: 241 case GGL_SET: 242 mLogicOp = LOGIC_OP; 243 break; 244 case GGL_AND: 245 case GGL_AND_REVERSE: 246 case GGL_AND_INVERTED: 247 case GGL_XOR: 248 case GGL_OR: 249 case GGL_NOR: 250 case GGL_EQUIV: 251 case GGL_OR_REVERSE: 252 case GGL_OR_INVERTED: 253 case GGL_NAND: 254 mLogicOp = LOGIC_OP|LOGIC_OP_SRC|LOGIC_OP_DST; 255 break; 256 case GGL_NOOP: 257 case GGL_INVERT: 258 mLogicOp = LOGIC_OP|LOGIC_OP_DST; 259 break; 260 case GGL_COPY_INVERTED: 261 mLogicOp = LOGIC_OP|LOGIC_OP_SRC; 262 break; 263 }; 264 } 265 266 void GGLAssembler::decodeTMUNeeds(const needs_t& needs, context_t const* c) 267 { 268 uint8_t replaced=0; 269 mTextureMachine.mask = 0; 270 mTextureMachine.activeUnits = 0; 271 for (int i=GGL_TEXTURE_UNIT_COUNT-1 ; i>=0 ; i--) { 272 texture_unit_t& tmu = mTextureMachine.tmu[i]; 273 if (replaced == 0xF) { 274 // all components are replaced, skip this TMU. 275 tmu.format_idx = 0; 276 tmu.mask = 0; 277 tmu.replaced = replaced; 278 continue; 279 } 280 tmu.format_idx = GGL_READ_NEEDS(T_FORMAT, needs.t[i]); 281 tmu.format = c->formats[tmu.format_idx]; 282 tmu.bits = tmu.format.size*8; 283 tmu.swrap = GGL_READ_NEEDS(T_S_WRAP, needs.t[i]); 284 tmu.twrap = GGL_READ_NEEDS(T_T_WRAP, needs.t[i]); 285 tmu.env = ggl_needs_to_env(GGL_READ_NEEDS(T_ENV, needs.t[i])); 286 tmu.pot = GGL_READ_NEEDS(T_POT, needs.t[i]); 287 tmu.linear = GGL_READ_NEEDS(T_LINEAR, needs.t[i]) 288 && tmu.format.size!=3; // XXX: only 8, 16 and 32 modes for now 289 290 // 5551 linear filtering is not supported 291 if (tmu.format_idx == GGL_PIXEL_FORMAT_RGBA_5551) 292 tmu.linear = 0; 293 294 tmu.mask = 0; 295 tmu.replaced = replaced; 296 297 if (tmu.format_idx) { 298 mTextureMachine.activeUnits++; 299 if (tmu.format.c[0].h) tmu.mask |= 0x1; 300 if (tmu.format.c[1].h) tmu.mask |= 0x2; 301 if (tmu.format.c[2].h) tmu.mask |= 0x4; 302 if (tmu.format.c[3].h) tmu.mask |= 0x8; 303 if (tmu.env == GGL_REPLACE) { 304 replaced |= tmu.mask; 305 } else if (tmu.env == GGL_DECAL) { 306 if (!tmu.format.c[GGLFormat::ALPHA].h) { 307 // if we don't have alpha, decal does nothing 308 tmu.mask = 0; 309 } else { 310 // decal always ignores At 311 tmu.mask &= ~(1<<GGLFormat::ALPHA); 312 } 313 } 314 } 315 mTextureMachine.mask |= tmu.mask; 316 //printf("%d: mask=%08lx, replaced=%08lx\n", 317 // i, int(tmu.mask), int(tmu.replaced)); 318 } 319 mTextureMachine.replaced = replaced; 320 mTextureMachine.directTexture = 0; 321 //printf("replaced=%08lx\n", mTextureMachine.replaced); 322 } 323 324 325 void GGLAssembler::init_textures( 326 tex_coord_t* coords, 327 const reg_t& x, const reg_t& y) 328 { 329 context_t const* c = mBuilderContext.c; 330 const needs_t& needs = mBuilderContext.needs; 331 int Rctx = mBuilderContext.Rctx; 332 int Rx = x.reg; 333 int Ry = y.reg; 334 335 if (mTextureMachine.mask) { 336 comment("compute texture coordinates"); 337 } 338 339 // init texture coordinates for each tmu 340 const int cb_format_idx = GGL_READ_NEEDS(CB_FORMAT, needs.n); 341 const bool multiTexture = mTextureMachine.activeUnits > 1; 342 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT; i++) { 343 const texture_unit_t& tmu = mTextureMachine.tmu[i]; 344 if (tmu.format_idx == 0) 345 continue; 346 if ((tmu.swrap == GGL_NEEDS_WRAP_11) && 347 (tmu.twrap == GGL_NEEDS_WRAP_11)) 348 { 349 // 1:1 texture 350 pointer_t& txPtr = coords[i].ptr; 351 txPtr.setTo(obtainReg(), tmu.bits); 352 CONTEXT_LOAD(txPtr.reg, state.texture[i].iterators.ydsdy); 353 ADD(AL, 0, Rx, Rx, reg_imm(txPtr.reg, ASR, 16)); // x += (s>>16) 354 CONTEXT_LOAD(txPtr.reg, state.texture[i].iterators.ydtdy); 355 ADD(AL, 0, Ry, Ry, reg_imm(txPtr.reg, ASR, 16)); // y += (t>>16) 356 // merge base & offset 357 CONTEXT_LOAD(txPtr.reg, generated_vars.texture[i].stride); 358 SMLABB(AL, Rx, Ry, txPtr.reg, Rx); // x+y*stride 359 CONTEXT_LOAD(txPtr.reg, generated_vars.texture[i].data); 360 base_offset(txPtr, txPtr, Rx); 361 } else { 362 Scratch scratches(registerFile()); 363 reg_t& s = coords[i].s; 364 reg_t& t = coords[i].t; 365 // s = (x * dsdx)>>16 + ydsdy 366 // s = (x * dsdx)>>16 + (y*dsdy)>>16 + s0 367 // t = (x * dtdx)>>16 + ydtdy 368 // t = (x * dtdx)>>16 + (y*dtdy)>>16 + t0 369 s.setTo(obtainReg()); 370 t.setTo(obtainReg()); 371 const int need_w = GGL_READ_NEEDS(W, needs.n); 372 if (need_w) { 373 CONTEXT_LOAD(s.reg, state.texture[i].iterators.ydsdy); 374 CONTEXT_LOAD(t.reg, state.texture[i].iterators.ydtdy); 375 } else { 376 int ydsdy = scratches.obtain(); 377 int ydtdy = scratches.obtain(); 378 CONTEXT_LOAD(s.reg, generated_vars.texture[i].dsdx); 379 CONTEXT_LOAD(ydsdy, state.texture[i].iterators.ydsdy); 380 CONTEXT_LOAD(t.reg, generated_vars.texture[i].dtdx); 381 CONTEXT_LOAD(ydtdy, state.texture[i].iterators.ydtdy); 382 MLA(AL, 0, s.reg, Rx, s.reg, ydsdy); 383 MLA(AL, 0, t.reg, Rx, t.reg, ydtdy); 384 } 385 386 if ((mOptLevel&1)==0) { 387 CONTEXT_STORE(s.reg, generated_vars.texture[i].spill[0]); 388 CONTEXT_STORE(t.reg, generated_vars.texture[i].spill[1]); 389 recycleReg(s.reg); 390 recycleReg(t.reg); 391 } 392 } 393 394 // direct texture? 395 if (!multiTexture && !mBlending && !mDithering && !mFog && 396 cb_format_idx == tmu.format_idx && !tmu.linear && 397 mTextureMachine.replaced == tmu.mask) 398 { 399 mTextureMachine.directTexture = i + 1; 400 } 401 } 402 } 403 404 void GGLAssembler::build_textures( fragment_parts_t& parts, 405 Scratch& regs) 406 { 407 context_t const* c = mBuilderContext.c; 408 const needs_t& needs = mBuilderContext.needs; 409 int Rctx = mBuilderContext.Rctx; 410 411 // We don't have a way to spill registers automatically 412 // spill depth and AA regs, when we know we may have to. 413 // build the spill list... 414 uint32_t spill_list = 0; 415 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT; i++) { 416 const texture_unit_t& tmu = mTextureMachine.tmu[i]; 417 if (tmu.format_idx == 0) 418 continue; 419 if (tmu.linear) { 420 // we may run out of register if we have linear filtering 421 // at 1 or 4 bytes / pixel on any texture unit. 422 if (tmu.format.size == 1) { 423 // if depth and AA enabled, we'll run out of 1 register 424 if (parts.z.reg > 0 && parts.covPtr.reg > 0) 425 spill_list |= 1<<parts.covPtr.reg; 426 } 427 if (tmu.format.size == 4) { 428 // if depth or AA enabled, we'll run out of 1 or 2 registers 429 if (parts.z.reg > 0) 430 spill_list |= 1<<parts.z.reg; 431 if (parts.covPtr.reg > 0) 432 spill_list |= 1<<parts.covPtr.reg; 433 } 434 } 435 } 436 437 Spill spill(registerFile(), *this, spill_list); 438 439 const bool multiTexture = mTextureMachine.activeUnits > 1; 440 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT; i++) { 441 const texture_unit_t& tmu = mTextureMachine.tmu[i]; 442 if (tmu.format_idx == 0) 443 continue; 444 445 pointer_t& txPtr = parts.coords[i].ptr; 446 pixel_t& texel = parts.texel[i]; 447 448 // repeat... 449 if ((tmu.swrap == GGL_NEEDS_WRAP_11) && 450 (tmu.twrap == GGL_NEEDS_WRAP_11)) 451 { // 1:1 textures 452 comment("fetch texel"); 453 texel.setTo(regs.obtain(), &tmu.format); 454 load(txPtr, texel, WRITE_BACK); 455 } else { 456 Scratch scratches(registerFile()); 457 reg_t& s = parts.coords[i].s; 458 reg_t& t = parts.coords[i].t; 459 if ((mOptLevel&1)==0) { 460 comment("reload s/t (multitexture or linear filtering)"); 461 s.reg = scratches.obtain(); 462 t.reg = scratches.obtain(); 463 CONTEXT_LOAD(s.reg, generated_vars.texture[i].spill[0]); 464 CONTEXT_LOAD(t.reg, generated_vars.texture[i].spill[1]); 465 } 466 467 if (registerFile().status() & RegisterFile::OUT_OF_REGISTERS) 468 return; 469 470 comment("compute repeat/clamp"); 471 int u = scratches.obtain(); 472 int v = scratches.obtain(); 473 int width = scratches.obtain(); 474 int height = scratches.obtain(); 475 int U = 0; 476 int V = 0; 477 478 if (registerFile().status() & RegisterFile::OUT_OF_REGISTERS) 479 return; 480 481 CONTEXT_LOAD(width, generated_vars.texture[i].width); 482 CONTEXT_LOAD(height, generated_vars.texture[i].height); 483 484 int FRAC_BITS = 0; 485 if (tmu.linear) { 486 // linear interpolation 487 if (tmu.format.size == 1) { 488 // for 8-bits textures, we can afford 489 // 7 bits of fractional precision at no 490 // additional cost (we can't do 8 bits 491 // because filter8 uses signed 16 bits muls) 492 FRAC_BITS = 7; 493 } else if (tmu.format.size == 2) { 494 // filter16() is internally limited to 4 bits, so: 495 // FRAC_BITS=2 generates less instructions, 496 // FRAC_BITS=3,4,5 creates unpleasant artifacts, 497 // FRAC_BITS=6+ looks good 498 FRAC_BITS = 6; 499 } else if (tmu.format.size == 4) { 500 // filter32() is internally limited to 8 bits, so: 501 // FRAC_BITS=4 looks good 502 // FRAC_BITS=5+ looks better, but generates 3 extra ipp 503 FRAC_BITS = 6; 504 } else { 505 // for all other cases we use 4 bits. 506 FRAC_BITS = 4; 507 } 508 } 509 wrapping(u, s.reg, width, tmu.swrap, FRAC_BITS); 510 wrapping(v, t.reg, height, tmu.twrap, FRAC_BITS); 511 512 if (tmu.linear) { 513 comment("compute linear filtering offsets"); 514 // pixel size scale 515 const int shift = 31 - gglClz(tmu.format.size); 516 U = scratches.obtain(); 517 V = scratches.obtain(); 518 519 if (registerFile().status() & RegisterFile::OUT_OF_REGISTERS) 520 return; 521 522 // sample the texel center 523 SUB(AL, 0, u, u, imm(1<<(FRAC_BITS-1))); 524 SUB(AL, 0, v, v, imm(1<<(FRAC_BITS-1))); 525 526 // get the fractionnal part of U,V 527 AND(AL, 0, U, u, imm((1<<FRAC_BITS)-1)); 528 AND(AL, 0, V, v, imm((1<<FRAC_BITS)-1)); 529 530 // compute width-1 and height-1 531 SUB(AL, 0, width, width, imm(1)); 532 SUB(AL, 0, height, height, imm(1)); 533 534 // get the integer part of U,V and clamp/wrap 535 // and compute offset to the next texel 536 if (tmu.swrap == GGL_NEEDS_WRAP_REPEAT) { 537 // u has already been REPEATed 538 MOV(AL, 1, u, reg_imm(u, ASR, FRAC_BITS)); 539 MOV(MI, 0, u, width); 540 CMP(AL, u, width); 541 MOV(LT, 0, width, imm(1 << shift)); 542 if (shift) 543 MOV(GE, 0, width, reg_imm(width, LSL, shift)); 544 RSB(GE, 0, width, width, imm(0)); 545 } else { 546 // u has not been CLAMPed yet 547 // algorithm: 548 // if ((u>>4) >= width) 549 // u = width<<4 550 // width = 0 551 // else 552 // width = 1<<shift 553 // u = u>>4; // get integer part 554 // if (u<0) 555 // u = 0 556 // width = 0 557 // generated_vars.rt = width 558 559 CMP(AL, width, reg_imm(u, ASR, FRAC_BITS)); 560 MOV(LE, 0, u, reg_imm(width, LSL, FRAC_BITS)); 561 MOV(LE, 0, width, imm(0)); 562 MOV(GT, 0, width, imm(1 << shift)); 563 MOV(AL, 1, u, reg_imm(u, ASR, FRAC_BITS)); 564 MOV(MI, 0, u, imm(0)); 565 MOV(MI, 0, width, imm(0)); 566 } 567 CONTEXT_STORE(width, generated_vars.rt); 568 569 const int stride = width; 570 CONTEXT_LOAD(stride, generated_vars.texture[i].stride); 571 if (tmu.twrap == GGL_NEEDS_WRAP_REPEAT) { 572 // v has already been REPEATed 573 MOV(AL, 1, v, reg_imm(v, ASR, FRAC_BITS)); 574 MOV(MI, 0, v, height); 575 CMP(AL, v, height); 576 MOV(LT, 0, height, imm(1 << shift)); 577 if (shift) 578 MOV(GE, 0, height, reg_imm(height, LSL, shift)); 579 RSB(GE, 0, height, height, imm(0)); 580 MUL(AL, 0, height, stride, height); 581 } else { 582 // v has not been CLAMPed yet 583 CMP(AL, height, reg_imm(v, ASR, FRAC_BITS)); 584 MOV(LE, 0, v, reg_imm(height, LSL, FRAC_BITS)); 585 MOV(LE, 0, height, imm(0)); 586 if (shift) { 587 MOV(GT, 0, height, reg_imm(stride, LSL, shift)); 588 } else { 589 MOV(GT, 0, height, stride); 590 } 591 MOV(AL, 1, v, reg_imm(v, ASR, FRAC_BITS)); 592 MOV(MI, 0, v, imm(0)); 593 MOV(MI, 0, height, imm(0)); 594 } 595 CONTEXT_STORE(height, generated_vars.lb); 596 } 597 598 scratches.recycle(width); 599 scratches.recycle(height); 600 601 // iterate texture coordinates... 602 comment("iterate s,t"); 603 int dsdx = scratches.obtain(); 604 int dtdx = scratches.obtain(); 605 606 if (registerFile().status() & RegisterFile::OUT_OF_REGISTERS) 607 return; 608 609 CONTEXT_LOAD(dsdx, generated_vars.texture[i].dsdx); 610 CONTEXT_LOAD(dtdx, generated_vars.texture[i].dtdx); 611 ADD(AL, 0, s.reg, s.reg, dsdx); 612 ADD(AL, 0, t.reg, t.reg, dtdx); 613 if ((mOptLevel&1)==0) { 614 CONTEXT_STORE(s.reg, generated_vars.texture[i].spill[0]); 615 CONTEXT_STORE(t.reg, generated_vars.texture[i].spill[1]); 616 scratches.recycle(s.reg); 617 scratches.recycle(t.reg); 618 } 619 scratches.recycle(dsdx); 620 scratches.recycle(dtdx); 621 622 // merge base & offset... 623 comment("merge base & offset"); 624 texel.setTo(regs.obtain(), &tmu.format); 625 txPtr.setTo(texel.reg, tmu.bits); 626 int stride = scratches.obtain(); 627 628 if (registerFile().status() & RegisterFile::OUT_OF_REGISTERS) 629 return; 630 631 CONTEXT_LOAD(stride, generated_vars.texture[i].stride); 632 CONTEXT_LOAD(txPtr.reg, generated_vars.texture[i].data); 633 SMLABB(AL, u, v, stride, u); // u+v*stride 634 base_offset(txPtr, txPtr, u); 635 636 // load texel 637 if (!tmu.linear) { 638 comment("fetch texel"); 639 load(txPtr, texel, 0); 640 } else { 641 // recycle registers we don't need anymore 642 scratches.recycle(u); 643 scratches.recycle(v); 644 scratches.recycle(stride); 645 646 comment("fetch texel, bilinear"); 647 switch (tmu.format.size) { 648 case 1: filter8(parts, texel, tmu, U, V, txPtr, FRAC_BITS); break; 649 case 2: filter16(parts, texel, tmu, U, V, txPtr, FRAC_BITS); break; 650 case 3: filter24(parts, texel, tmu, U, V, txPtr, FRAC_BITS); break; 651 case 4: filter32(parts, texel, tmu, U, V, txPtr, FRAC_BITS); break; 652 } 653 } 654 } 655 } 656 } 657 658 void GGLAssembler::build_iterate_texture_coordinates( 659 const fragment_parts_t& parts) 660 { 661 const bool multiTexture = mTextureMachine.activeUnits > 1; 662 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT; i++) { 663 const texture_unit_t& tmu = mTextureMachine.tmu[i]; 664 if (tmu.format_idx == 0) 665 continue; 666 667 if ((tmu.swrap == GGL_NEEDS_WRAP_11) && 668 (tmu.twrap == GGL_NEEDS_WRAP_11)) 669 { // 1:1 textures 670 const pointer_t& txPtr = parts.coords[i].ptr; 671 ADD(AL, 0, txPtr.reg, txPtr.reg, imm(txPtr.size>>3)); 672 } else { 673 Scratch scratches(registerFile()); 674 int s = parts.coords[i].s.reg; 675 int t = parts.coords[i].t.reg; 676 if ((mOptLevel&1)==0) { 677 s = scratches.obtain(); 678 t = scratches.obtain(); 679 CONTEXT_LOAD(s, generated_vars.texture[i].spill[0]); 680 CONTEXT_LOAD(t, generated_vars.texture[i].spill[1]); 681 } 682 int dsdx = scratches.obtain(); 683 int dtdx = scratches.obtain(); 684 CONTEXT_LOAD(dsdx, generated_vars.texture[i].dsdx); 685 CONTEXT_LOAD(dtdx, generated_vars.texture[i].dtdx); 686 ADD(AL, 0, s, s, dsdx); 687 ADD(AL, 0, t, t, dtdx); 688 if ((mOptLevel&1)==0) { 689 CONTEXT_STORE(s, generated_vars.texture[i].spill[0]); 690 CONTEXT_STORE(t, generated_vars.texture[i].spill[1]); 691 } 692 } 693 } 694 } 695 696 void GGLAssembler::filter8( 697 const fragment_parts_t& parts, 698 pixel_t& texel, const texture_unit_t& tmu, 699 int U, int V, pointer_t& txPtr, 700 int FRAC_BITS) 701 { 702 if (tmu.format.components != GGL_ALPHA && 703 tmu.format.components != GGL_LUMINANCE) 704 { 705 // this is a packed format, and we don't support 706 // linear filtering (it's probably RGB 332) 707 // Should not happen with OpenGL|ES 708 LDRB(AL, texel.reg, txPtr.reg); 709 return; 710 } 711 712 // ------------------------ 713 // about ~22 cycles / pixel 714 Scratch scratches(registerFile()); 715 716 int pixel= scratches.obtain(); 717 int d = scratches.obtain(); 718 int u = scratches.obtain(); 719 int k = scratches.obtain(); 720 int rt = scratches.obtain(); 721 int lb = scratches.obtain(); 722 723 // RB -> U * V 724 725 CONTEXT_LOAD(rt, generated_vars.rt); 726 CONTEXT_LOAD(lb, generated_vars.lb); 727 728 int offset = pixel; 729 ADD(AL, 0, offset, lb, rt); 730 LDRB(AL, pixel, txPtr.reg, reg_scale_pre(offset)); 731 SMULBB(AL, u, U, V); 732 SMULBB(AL, d, pixel, u); 733 RSB(AL, 0, k, u, imm(1<<(FRAC_BITS*2))); 734 735 // LB -> (1-U) * V 736 RSB(AL, 0, U, U, imm(1<<FRAC_BITS)); 737 LDRB(AL, pixel, txPtr.reg, reg_scale_pre(lb)); 738 SMULBB(AL, u, U, V); 739 SMLABB(AL, d, pixel, u, d); 740 SUB(AL, 0, k, k, u); 741 742 // LT -> (1-U)*(1-V) 743 RSB(AL, 0, V, V, imm(1<<FRAC_BITS)); 744 LDRB(AL, pixel, txPtr.reg); 745 SMULBB(AL, u, U, V); 746 SMLABB(AL, d, pixel, u, d); 747 748 // RT -> U*(1-V) 749 LDRB(AL, pixel, txPtr.reg, reg_scale_pre(rt)); 750 SUB(AL, 0, u, k, u); 751 SMLABB(AL, texel.reg, pixel, u, d); 752 753 for (int i=0 ; i<4 ; i++) { 754 if (!texel.format.c[i].h) continue; 755 texel.format.c[i].h = FRAC_BITS*2+8; 756 texel.format.c[i].l = FRAC_BITS*2; // keeping 8 bits in enough 757 } 758 texel.format.size = 4; 759 texel.format.bitsPerPixel = 32; 760 texel.flags |= CLEAR_LO; 761 } 762 763 void GGLAssembler::filter16( 764 const fragment_parts_t& parts, 765 pixel_t& texel, const texture_unit_t& tmu, 766 int U, int V, pointer_t& txPtr, 767 int FRAC_BITS) 768 { 769 // compute the mask 770 // XXX: it would be nice if the mask below could be computed 771 // automatically. 772 uint32_t mask = 0; 773 int shift = 0; 774 int prec = 0; 775 switch (tmu.format_idx) { 776 case GGL_PIXEL_FORMAT_RGB_565: 777 // source: 00000ggg.ggg00000 | rrrrr000.000bbbbb 778 // result: gggggggg.gggrrrrr | rrrrr0bb.bbbbbbbb 779 mask = 0x07E0F81F; 780 shift = 16; 781 prec = 5; 782 break; 783 case GGL_PIXEL_FORMAT_RGBA_4444: 784 // 0000,1111,0000,1111 | 0000,1111,0000,1111 785 mask = 0x0F0F0F0F; 786 shift = 12; 787 prec = 4; 788 break; 789 case GGL_PIXEL_FORMAT_LA_88: 790 // 0000,0000,1111,1111 | 0000,0000,1111,1111 791 // AALL -> 00AA | 00LL 792 mask = 0x00FF00FF; 793 shift = 8; 794 prec = 8; 795 break; 796 default: 797 // unsupported format, do something sensical... 798 ALOGE("Unsupported 16-bits texture format (%d)", tmu.format_idx); 799 LDRH(AL, texel.reg, txPtr.reg); 800 return; 801 } 802 803 const int adjust = FRAC_BITS*2 - prec; 804 const int round = 0; 805 806 // update the texel format 807 texel.format.size = 4; 808 texel.format.bitsPerPixel = 32; 809 texel.flags |= CLEAR_HI|CLEAR_LO; 810 for (int i=0 ; i<4 ; i++) { 811 if (!texel.format.c[i].h) continue; 812 const uint32_t offset = (mask & tmu.format.mask(i)) ? 0 : shift; 813 texel.format.c[i].h = tmu.format.c[i].h + offset + prec; 814 texel.format.c[i].l = texel.format.c[i].h - (tmu.format.bits(i) + prec); 815 } 816 817 // ------------------------ 818 // about ~40 cycles / pixel 819 Scratch scratches(registerFile()); 820 821 int pixel= scratches.obtain(); 822 int d = scratches.obtain(); 823 int u = scratches.obtain(); 824 int k = scratches.obtain(); 825 826 // RB -> U * V 827 int offset = pixel; 828 CONTEXT_LOAD(offset, generated_vars.rt); 829 CONTEXT_LOAD(u, generated_vars.lb); 830 ADD(AL, 0, offset, offset, u); 831 832 LDRH(AL, pixel, txPtr.reg, reg_pre(offset)); 833 SMULBB(AL, u, U, V); 834 ORR(AL, 0, pixel, pixel, reg_imm(pixel, LSL, shift)); 835 build_and_immediate(pixel, pixel, mask, 32); 836 if (adjust) { 837 if (round) 838 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 839 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 840 } 841 MUL(AL, 0, d, pixel, u); 842 RSB(AL, 0, k, u, imm(1<<prec)); 843 844 // LB -> (1-U) * V 845 CONTEXT_LOAD(offset, generated_vars.lb); 846 RSB(AL, 0, U, U, imm(1<<FRAC_BITS)); 847 LDRH(AL, pixel, txPtr.reg, reg_pre(offset)); 848 SMULBB(AL, u, U, V); 849 ORR(AL, 0, pixel, pixel, reg_imm(pixel, LSL, shift)); 850 build_and_immediate(pixel, pixel, mask, 32); 851 if (adjust) { 852 if (round) 853 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 854 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 855 } 856 MLA(AL, 0, d, pixel, u, d); 857 SUB(AL, 0, k, k, u); 858 859 // LT -> (1-U)*(1-V) 860 RSB(AL, 0, V, V, imm(1<<FRAC_BITS)); 861 LDRH(AL, pixel, txPtr.reg); 862 SMULBB(AL, u, U, V); 863 ORR(AL, 0, pixel, pixel, reg_imm(pixel, LSL, shift)); 864 build_and_immediate(pixel, pixel, mask, 32); 865 if (adjust) { 866 if (round) 867 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 868 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 869 } 870 MLA(AL, 0, d, pixel, u, d); 871 872 // RT -> U*(1-V) 873 CONTEXT_LOAD(offset, generated_vars.rt); 874 LDRH(AL, pixel, txPtr.reg, reg_pre(offset)); 875 SUB(AL, 0, u, k, u); 876 ORR(AL, 0, pixel, pixel, reg_imm(pixel, LSL, shift)); 877 build_and_immediate(pixel, pixel, mask, 32); 878 MLA(AL, 0, texel.reg, pixel, u, d); 879 } 880 881 void GGLAssembler::filter24( 882 const fragment_parts_t& parts, 883 pixel_t& texel, const texture_unit_t& tmu, 884 int U, int V, pointer_t& txPtr, 885 int FRAC_BITS) 886 { 887 // not supported yet (currently disabled) 888 load(txPtr, texel, 0); 889 } 890 891 #if __ARM_ARCH__ >= 6 892 // ARMv6 version, using UXTB16, and scheduled for Cortex-A8 pipeline 893 void GGLAssembler::filter32( 894 const fragment_parts_t& parts, 895 pixel_t& texel, const texture_unit_t& tmu, 896 int U, int V, pointer_t& txPtr, 897 int FRAC_BITS) 898 { 899 const int adjust = FRAC_BITS*2 - 8; 900 const int round = 0; 901 const int prescale = 16 - adjust; 902 903 Scratch scratches(registerFile()); 904 905 int pixel= scratches.obtain(); 906 int dh = scratches.obtain(); 907 int u = scratches.obtain(); 908 int k = scratches.obtain(); 909 910 int temp = scratches.obtain(); 911 int dl = scratches.obtain(); 912 913 int offsetrt = scratches.obtain(); 914 int offsetlb = scratches.obtain(); 915 916 int pixellb = offsetlb; 917 918 // RB -> U * V 919 CONTEXT_LOAD(offsetrt, generated_vars.rt); 920 CONTEXT_LOAD(offsetlb, generated_vars.lb); 921 if(!round) { 922 MOV(AL, 0, U, reg_imm(U, LSL, prescale)); 923 } 924 ADD(AL, 0, u, offsetrt, offsetlb); 925 926 LDR(AL, pixel, txPtr.reg, reg_scale_pre(u)); 927 if (round) { 928 SMULBB(AL, u, U, V); 929 RSB(AL, 0, U, U, imm(1<<FRAC_BITS)); 930 } else { 931 SMULWB(AL, u, U, V); 932 RSB(AL, 0, U, U, imm(1<<(FRAC_BITS+prescale))); 933 } 934 UXTB16(AL, temp, pixel, 0); 935 if (round) { 936 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 937 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 938 } 939 LDR(AL, pixellb, txPtr.reg, reg_scale_pre(offsetlb)); 940 MUL(AL, 0, dh, temp, u); 941 UXTB16(AL, temp, pixel, 8); 942 MUL(AL, 0, dl, temp, u); 943 RSB(AL, 0, k, u, imm(0x100)); 944 945 // LB -> (1-U) * V 946 if (round) { 947 SMULBB(AL, u, U, V); 948 } else { 949 SMULWB(AL, u, U, V); 950 } 951 UXTB16(AL, temp, pixellb, 0); 952 if (round) { 953 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 954 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 955 } 956 MLA(AL, 0, dh, temp, u, dh); 957 UXTB16(AL, temp, pixellb, 8); 958 MLA(AL, 0, dl, temp, u, dl); 959 SUB(AL, 0, k, k, u); 960 961 // LT -> (1-U)*(1-V) 962 RSB(AL, 0, V, V, imm(1<<FRAC_BITS)); 963 LDR(AL, pixel, txPtr.reg); 964 if (round) { 965 SMULBB(AL, u, U, V); 966 } else { 967 SMULWB(AL, u, U, V); 968 } 969 UXTB16(AL, temp, pixel, 0); 970 if (round) { 971 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 972 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 973 } 974 MLA(AL, 0, dh, temp, u, dh); 975 UXTB16(AL, temp, pixel, 8); 976 MLA(AL, 0, dl, temp, u, dl); 977 978 // RT -> U*(1-V) 979 LDR(AL, pixel, txPtr.reg, reg_scale_pre(offsetrt)); 980 SUB(AL, 0, u, k, u); 981 UXTB16(AL, temp, pixel, 0); 982 MLA(AL, 0, dh, temp, u, dh); 983 UXTB16(AL, temp, pixel, 8); 984 MLA(AL, 0, dl, temp, u, dl); 985 986 UXTB16(AL, dh, dh, 8); 987 UXTB16(AL, dl, dl, 8); 988 ORR(AL, 0, texel.reg, dh, reg_imm(dl, LSL, 8)); 989 } 990 #else 991 void GGLAssembler::filter32( 992 const fragment_parts_t& parts, 993 pixel_t& texel, const texture_unit_t& tmu, 994 int U, int V, pointer_t& txPtr, 995 int FRAC_BITS) 996 { 997 const int adjust = FRAC_BITS*2 - 8; 998 const int round = 0; 999 1000 // ------------------------ 1001 // about ~38 cycles / pixel 1002 Scratch scratches(registerFile()); 1003 1004 int pixel= scratches.obtain(); 1005 int dh = scratches.obtain(); 1006 int u = scratches.obtain(); 1007 int k = scratches.obtain(); 1008 1009 int temp = scratches.obtain(); 1010 int dl = scratches.obtain(); 1011 int mask = scratches.obtain(); 1012 1013 MOV(AL, 0, mask, imm(0xFF)); 1014 ORR(AL, 0, mask, mask, imm(0xFF0000)); 1015 1016 // RB -> U * V 1017 int offset = pixel; 1018 CONTEXT_LOAD(offset, generated_vars.rt); 1019 CONTEXT_LOAD(u, generated_vars.lb); 1020 ADD(AL, 0, offset, offset, u); 1021 1022 LDR(AL, pixel, txPtr.reg, reg_scale_pre(offset)); 1023 SMULBB(AL, u, U, V); 1024 AND(AL, 0, temp, mask, pixel); 1025 if (adjust) { 1026 if (round) 1027 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 1028 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 1029 } 1030 MUL(AL, 0, dh, temp, u); 1031 AND(AL, 0, temp, mask, reg_imm(pixel, LSR, 8)); 1032 MUL(AL, 0, dl, temp, u); 1033 RSB(AL, 0, k, u, imm(0x100)); 1034 1035 // LB -> (1-U) * V 1036 CONTEXT_LOAD(offset, generated_vars.lb); 1037 RSB(AL, 0, U, U, imm(1<<FRAC_BITS)); 1038 LDR(AL, pixel, txPtr.reg, reg_scale_pre(offset)); 1039 SMULBB(AL, u, U, V); 1040 AND(AL, 0, temp, mask, pixel); 1041 if (adjust) { 1042 if (round) 1043 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 1044 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 1045 } 1046 MLA(AL, 0, dh, temp, u, dh); 1047 AND(AL, 0, temp, mask, reg_imm(pixel, LSR, 8)); 1048 MLA(AL, 0, dl, temp, u, dl); 1049 SUB(AL, 0, k, k, u); 1050 1051 // LT -> (1-U)*(1-V) 1052 RSB(AL, 0, V, V, imm(1<<FRAC_BITS)); 1053 LDR(AL, pixel, txPtr.reg); 1054 SMULBB(AL, u, U, V); 1055 AND(AL, 0, temp, mask, pixel); 1056 if (adjust) { 1057 if (round) 1058 ADD(AL, 0, u, u, imm(1<<(adjust-1))); 1059 MOV(AL, 0, u, reg_imm(u, LSR, adjust)); 1060 } 1061 MLA(AL, 0, dh, temp, u, dh); 1062 AND(AL, 0, temp, mask, reg_imm(pixel, LSR, 8)); 1063 MLA(AL, 0, dl, temp, u, dl); 1064 1065 // RT -> U*(1-V) 1066 CONTEXT_LOAD(offset, generated_vars.rt); 1067 LDR(AL, pixel, txPtr.reg, reg_scale_pre(offset)); 1068 SUB(AL, 0, u, k, u); 1069 AND(AL, 0, temp, mask, pixel); 1070 MLA(AL, 0, dh, temp, u, dh); 1071 AND(AL, 0, temp, mask, reg_imm(pixel, LSR, 8)); 1072 MLA(AL, 0, dl, temp, u, dl); 1073 1074 AND(AL, 0, dh, mask, reg_imm(dh, LSR, 8)); 1075 AND(AL, 0, dl, dl, reg_imm(mask, LSL, 8)); 1076 ORR(AL, 0, texel.reg, dh, dl); 1077 } 1078 #endif 1079 1080 void GGLAssembler::build_texture_environment( 1081 component_t& fragment, 1082 const fragment_parts_t& parts, 1083 int component, 1084 Scratch& regs) 1085 { 1086 const uint32_t component_mask = 1<<component; 1087 const bool multiTexture = mTextureMachine.activeUnits > 1; 1088 for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) { 1089 texture_unit_t& tmu = mTextureMachine.tmu[i]; 1090 1091 if (tmu.mask & component_mask) { 1092 // replace or modulate with this texture 1093 if ((tmu.replaced & component_mask) == 0) { 1094 // not replaced by a later tmu... 1095 1096 Scratch scratches(registerFile()); 1097 pixel_t texel(parts.texel[i]); 1098 1099 if (multiTexture && 1100 tmu.swrap == GGL_NEEDS_WRAP_11 && 1101 tmu.twrap == GGL_NEEDS_WRAP_11) 1102 { 1103 texel.reg = scratches.obtain(); 1104 texel.flags |= CORRUPTIBLE; 1105 comment("fetch texel (multitexture 1:1)"); 1106 load(parts.coords[i].ptr, texel, WRITE_BACK); 1107 } 1108 1109 component_t incoming(fragment); 1110 modify(fragment, regs); 1111 1112 switch (tmu.env) { 1113 case GGL_REPLACE: 1114 extract(fragment, texel, component); 1115 break; 1116 case GGL_MODULATE: 1117 modulate(fragment, incoming, texel, component); 1118 break; 1119 case GGL_DECAL: 1120 decal(fragment, incoming, texel, component); 1121 break; 1122 case GGL_BLEND: 1123 blend(fragment, incoming, texel, component, i); 1124 break; 1125 case GGL_ADD: 1126 add(fragment, incoming, texel, component); 1127 break; 1128 } 1129 } 1130 } 1131 } 1132 } 1133 1134 // --------------------------------------------------------------------------- 1135 1136 void GGLAssembler::wrapping( 1137 int d, 1138 int coord, int size, 1139 int tx_wrap, int tx_linear) 1140 { 1141 // notes: 1142 // if tx_linear is set, we need 4 extra bits of precision on the result 1143 // SMULL/UMULL is 3 cycles 1144 Scratch scratches(registerFile()); 1145 int c = coord; 1146 if (tx_wrap == GGL_NEEDS_WRAP_REPEAT) { 1147 // UMULL takes 4 cycles (interlocked), and we can get away with 1148 // 2 cycles using SMULWB, but we're loosing 16 bits of precision 1149 // out of 32 (this is not a problem because the iterator keeps 1150 // its full precision) 1151 // UMULL(AL, 0, size, d, c, size); 1152 // note: we can't use SMULTB because it's signed. 1153 MOV(AL, 0, d, reg_imm(c, LSR, 16-tx_linear)); 1154 SMULWB(AL, d, d, size); 1155 } else if (tx_wrap == GGL_NEEDS_WRAP_CLAMP_TO_EDGE) { 1156 if (tx_linear) { 1157 // 1 cycle 1158 MOV(AL, 0, d, reg_imm(coord, ASR, 16-tx_linear)); 1159 } else { 1160 // 4 cycles (common case) 1161 MOV(AL, 0, d, reg_imm(coord, ASR, 16)); 1162 BIC(AL, 0, d, d, reg_imm(d, ASR, 31)); 1163 CMP(AL, d, size); 1164 SUB(GE, 0, d, size, imm(1)); 1165 } 1166 } 1167 } 1168 1169 // --------------------------------------------------------------------------- 1170 1171 void GGLAssembler::modulate( 1172 component_t& dest, 1173 const component_t& incoming, 1174 const pixel_t& incomingTexel, int component) 1175 { 1176 Scratch locals(registerFile()); 1177 integer_t texel(locals.obtain(), 32, CORRUPTIBLE); 1178 extract(texel, incomingTexel, component); 1179 1180 const int Nt = texel.size(); 1181 // Nt should always be less than 10 bits because it comes 1182 // from the TMU. 1183 1184 int Ni = incoming.size(); 1185 // Ni could be big because it comes from previous MODULATEs 1186 1187 if (Nt == 1) { 1188 // texel acts as a bit-mask 1189 // dest = incoming & ((texel << incoming.h)-texel) 1190 RSB(AL, 0, dest.reg, texel.reg, reg_imm(texel.reg, LSL, incoming.h)); 1191 AND(AL, 0, dest.reg, dest.reg, incoming.reg); 1192 dest.l = incoming.l; 1193 dest.h = incoming.h; 1194 dest.flags |= (incoming.flags & CLEAR_LO); 1195 } else if (Ni == 1) { 1196 MOV(AL, 0, dest.reg, reg_imm(incoming.reg, LSL, 31-incoming.h)); 1197 AND(AL, 0, dest.reg, texel.reg, reg_imm(dest.reg, ASR, 31)); 1198 dest.l = 0; 1199 dest.h = Nt; 1200 } else { 1201 int inReg = incoming.reg; 1202 int shift = incoming.l; 1203 if ((Nt + Ni) > 32) { 1204 // we will overflow, reduce the precision of Ni to 8 bits 1205 // (Note Nt cannot be more than 10 bits which happens with 1206 // 565 textures and GGL_LINEAR) 1207 shift += Ni-8; 1208 Ni = 8; 1209 } 1210 1211 // modulate by the component with the lowest precision 1212 if (Nt >= Ni) { 1213 if (shift) { 1214 // XXX: we should be able to avoid this shift 1215 // when shift==16 && Nt<16 && Ni<16, in which 1216 // we could use SMULBT below. 1217 MOV(AL, 0, dest.reg, reg_imm(inReg, LSR, shift)); 1218 inReg = dest.reg; 1219 shift = 0; 1220 } 1221 // operation: (Cf*Ct)/((1<<Ni)-1) 1222 // approximated with: Cf*(Ct + Ct>>(Ni-1))>>Ni 1223 // this operation doesn't change texel's size 1224 ADD(AL, 0, dest.reg, inReg, reg_imm(inReg, LSR, Ni-1)); 1225 if (Nt<16 && Ni<16) SMULBB(AL, dest.reg, texel.reg, dest.reg); 1226 else MUL(AL, 0, dest.reg, texel.reg, dest.reg); 1227 dest.l = Ni; 1228 dest.h = Nt + Ni; 1229 } else { 1230 if (shift && (shift != 16)) { 1231 // if shift==16, we can use 16-bits mul instructions later 1232 MOV(AL, 0, dest.reg, reg_imm(inReg, LSR, shift)); 1233 inReg = dest.reg; 1234 shift = 0; 1235 } 1236 // operation: (Cf*Ct)/((1<<Nt)-1) 1237 // approximated with: Ct*(Cf + Cf>>(Nt-1))>>Nt 1238 // this operation doesn't change incoming's size 1239 Scratch scratches(registerFile()); 1240 int t = (texel.flags & CORRUPTIBLE) ? texel.reg : dest.reg; 1241 if (t == inReg) 1242 t = scratches.obtain(); 1243 ADD(AL, 0, t, texel.reg, reg_imm(texel.reg, LSR, Nt-1)); 1244 if (Nt<16 && Ni<16) { 1245 if (shift==16) SMULBT(AL, dest.reg, t, inReg); 1246 else SMULBB(AL, dest.reg, t, inReg); 1247 } else MUL(AL, 0, dest.reg, t, inReg); 1248 dest.l = Nt; 1249 dest.h = Nt + Ni; 1250 } 1251 1252 // low bits are not valid 1253 dest.flags |= CLEAR_LO; 1254 1255 // no need to keep more than 8 bits/component 1256 if (dest.size() > 8) 1257 dest.l = dest.h-8; 1258 } 1259 } 1260 1261 void GGLAssembler::decal( 1262 component_t& dest, 1263 const component_t& incoming, 1264 const pixel_t& incomingTexel, int component) 1265 { 1266 // RGBA: 1267 // Cv = Cf*(1 - At) + Ct*At = Cf + (Ct - Cf)*At 1268 // Av = Af 1269 Scratch locals(registerFile()); 1270 integer_t texel(locals.obtain(), 32, CORRUPTIBLE); 1271 integer_t factor(locals.obtain(), 32, CORRUPTIBLE); 1272 extract(texel, incomingTexel, component); 1273 extract(factor, incomingTexel, GGLFormat::ALPHA); 1274 1275 // no need to keep more than 8-bits for decal 1276 int Ni = incoming.size(); 1277 int shift = incoming.l; 1278 if (Ni > 8) { 1279 shift += Ni-8; 1280 Ni = 8; 1281 } 1282 integer_t incomingNorm(incoming.reg, Ni, incoming.flags); 1283 if (shift) { 1284 MOV(AL, 0, dest.reg, reg_imm(incomingNorm.reg, LSR, shift)); 1285 incomingNorm.reg = dest.reg; 1286 incomingNorm.flags |= CORRUPTIBLE; 1287 } 1288 ADD(AL, 0, factor.reg, factor.reg, reg_imm(factor.reg, LSR, factor.s-1)); 1289 build_blendOneMinusFF(dest, factor, incomingNorm, texel); 1290 } 1291 1292 void GGLAssembler::blend( 1293 component_t& dest, 1294 const component_t& incoming, 1295 const pixel_t& incomingTexel, int component, int tmu) 1296 { 1297 // RGBA: 1298 // Cv = (1 - Ct)*Cf + Ct*Cc = Cf + (Cc - Cf)*Ct 1299 // Av = At*Af 1300 1301 if (component == GGLFormat::ALPHA) { 1302 modulate(dest, incoming, incomingTexel, component); 1303 return; 1304 } 1305 1306 Scratch locals(registerFile()); 1307 integer_t color(locals.obtain(), 8, CORRUPTIBLE); 1308 integer_t factor(locals.obtain(), 32, CORRUPTIBLE); 1309 LDRB(AL, color.reg, mBuilderContext.Rctx, 1310 immed12_pre(GGL_OFFSETOF(state.texture[tmu].env_color[component]))); 1311 extract(factor, incomingTexel, component); 1312 1313 // no need to keep more than 8-bits for blend 1314 int Ni = incoming.size(); 1315 int shift = incoming.l; 1316 if (Ni > 8) { 1317 shift += Ni-8; 1318 Ni = 8; 1319 } 1320 integer_t incomingNorm(incoming.reg, Ni, incoming.flags); 1321 if (shift) { 1322 MOV(AL, 0, dest.reg, reg_imm(incomingNorm.reg, LSR, shift)); 1323 incomingNorm.reg = dest.reg; 1324 incomingNorm.flags |= CORRUPTIBLE; 1325 } 1326 ADD(AL, 0, factor.reg, factor.reg, reg_imm(factor.reg, LSR, factor.s-1)); 1327 build_blendOneMinusFF(dest, factor, incomingNorm, color); 1328 } 1329 1330 void GGLAssembler::add( 1331 component_t& dest, 1332 const component_t& incoming, 1333 const pixel_t& incomingTexel, int component) 1334 { 1335 // RGBA: 1336 // Cv = Cf + Ct; 1337 Scratch locals(registerFile()); 1338 1339 component_t incomingTemp(incoming); 1340 1341 // use "dest" as a temporary for extracting the texel, unless "dest" 1342 // overlaps "incoming". 1343 integer_t texel(dest.reg, 32, CORRUPTIBLE); 1344 if (dest.reg == incomingTemp.reg) 1345 texel.reg = locals.obtain(); 1346 extract(texel, incomingTexel, component); 1347 1348 if (texel.s < incomingTemp.size()) { 1349 expand(texel, texel, incomingTemp.size()); 1350 } else if (texel.s > incomingTemp.size()) { 1351 if (incomingTemp.flags & CORRUPTIBLE) { 1352 expand(incomingTemp, incomingTemp, texel.s); 1353 } else { 1354 incomingTemp.reg = locals.obtain(); 1355 expand(incomingTemp, incoming, texel.s); 1356 } 1357 } 1358 1359 if (incomingTemp.l) { 1360 ADD(AL, 0, dest.reg, texel.reg, 1361 reg_imm(incomingTemp.reg, LSR, incomingTemp.l)); 1362 } else { 1363 ADD(AL, 0, dest.reg, texel.reg, incomingTemp.reg); 1364 } 1365 dest.l = 0; 1366 dest.h = texel.size(); 1367 component_sat(dest); 1368 } 1369 1370 // ---------------------------------------------------------------------------- 1371 1372 }; // namespace android 1373 1374
