1 /* 2 * Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 27 #include "mlib_image.h" 28 #include "mlib_ImageLookUp.h" 29 #include "mlib_c_ImageLookUp.h" 30 31 /***************************************************************/ 32 #define MLIB_C_IMAGELOOKUP(DTYPE, STYPE, TABLE) \ 33 { \ 34 mlib_s32 i, j, k; \ 35 \ 36 if (xsize < 2) { \ 37 for(j = 0; j < ysize; j++, dst += dlb, src += slb){ \ 38 for(k = 0; k < csize; k++) { \ 39 DTYPE *da = dst + k; \ 40 const STYPE *sa = src + k; \ 41 DTYPE *tab = (DTYPE*) TABLE[k]; \ 42 \ 43 for(i = 0; i < xsize; i++, da += csize, sa += csize) \ 44 *da=tab[*sa]; \ 45 } \ 46 } \ 47 } else { \ 48 for(j = 0; j < ysize; j++, dst += dlb, src += slb) { \ 49 for(k = 0; k < csize; k++) { \ 50 DTYPE *da = dst + k; \ 51 const STYPE *sa = src + k; \ 52 DTYPE *tab = (DTYPE*) TABLE[k]; \ 53 mlib_s32 s0, t0, s1, t1; \ 54 \ 55 s0 = (mlib_s32)sa[0]; \ 56 s1 = (mlib_s32)sa[csize]; \ 57 sa += 2*csize; \ 58 \ 59 for(i = 0; i < xsize - 3; i+=2, da += 2*csize, sa += 2*csize) { \ 60 t0 = (mlib_s32)tab[s0]; \ 61 t1 = (mlib_s32)tab[s1]; \ 62 s0 = (mlib_s32)sa[0]; \ 63 s1 = (mlib_s32)sa[csize]; \ 64 da[0] = (DTYPE)t0; \ 65 da[csize] = (DTYPE)t1; \ 66 } \ 67 t0 = (mlib_s32)tab[s0]; \ 68 t1 = (mlib_s32)tab[s1]; \ 69 da[0] = (DTYPE)t0; \ 70 da[csize] = (DTYPE)t1; \ 71 if (xsize & 1) da[2*csize] = tab[sa[0]]; \ 72 } \ 73 } \ 74 } \ 75 } 76 77 /***************************************************************/ 78 #define MLIB_C_IMAGELOOKUPSI(DTYPE, STYPE, TABLE) \ 79 { \ 80 mlib_s32 i, j, k; \ 81 \ 82 if (xsize < 2) { \ 83 for(j = 0; j < ysize; j++, dst += dlb, src += slb){ \ 84 for(k = 0; k < csize; k++) { \ 85 DTYPE *da = dst + k; \ 86 const STYPE *sa = (void *)src; \ 87 DTYPE *tab = (DTYPE*) TABLE[k]; \ 88 \ 89 for(i = 0; i < xsize; i++, da += csize, sa ++) \ 90 *da=tab[*sa]; \ 91 } \ 92 } \ 93 } else { \ 94 for(j = 0; j < ysize; j++, dst += dlb, src += slb) { \ 95 for(k = 0; k < csize; k++) { \ 96 DTYPE *da = dst + k; \ 97 const STYPE *sa = (void *)src; \ 98 DTYPE *tab = (DTYPE*) TABLE[k]; \ 99 mlib_s32 s0, t0, s1, t1; \ 100 \ 101 s0 = (mlib_s32)sa[0]; \ 102 s1 = (mlib_s32)sa[1]; \ 103 sa += 2; \ 104 \ 105 for(i = 0; i < xsize - 3; i+=2, da += 2*csize, sa += 2) { \ 106 t0 = (mlib_s32)tab[s0]; \ 107 t1 = (mlib_s32)tab[s1]; \ 108 s0 = (mlib_s32)sa[0]; \ 109 s1 = (mlib_s32)sa[1]; \ 110 da[0] = (DTYPE)t0; \ 111 da[csize] = (DTYPE)t1; \ 112 } \ 113 t0 = (mlib_s32)tab[s0]; \ 114 t1 = (mlib_s32)tab[s1]; \ 115 da[0] = (DTYPE)t0; \ 116 da[csize] = (DTYPE)t1; \ 117 if (xsize & 1) da[2*csize] = tab[sa[0]]; \ 118 } \ 119 } \ 120 } \ 121 } 122 123 #ifdef _LITTLE_ENDIAN 124 125 /***************************************************************/ 126 #define READ_U8_U8_ALIGN(table0, table1, table2, table3) \ 127 t3 = table0[s0 & 0xFF]; \ 128 t2 = table1[s0>>8]; \ 129 t1 = table2[s1 & 0xFF]; \ 130 t0 = table3[s1>>8] 131 132 /***************************************************************/ 133 #define READ_U8_U8_NOTALIGN(table0, table1, table2, table3) \ 134 t3 = table0[s0 >> 8]; \ 135 t2 = table1[s1 & 0xFF]; \ 136 t1 = table2[s1 >> 8]; \ 137 t0 = table3[s2 & 0xFF] 138 139 /***************************************************************/ 140 #define READ_U8_S16_ALIGN(table0, table1, table2, table3) \ 141 t1 = *(mlib_u16*)((mlib_u8*)table0 + ((s0 << 1) & 0x1FE)); \ 142 t0 = *(mlib_u16*)((mlib_u8*)table1 + ((s0 >> 7) & 0x1FE)); \ 143 t3 = *(mlib_u16*)((mlib_u8*)table2 + ((s0 >> 15) & 0x1FE)); \ 144 t2 = *(mlib_u16*)((mlib_u8*)table3 + ((s0 >> 23) & 0x1FE)) 145 146 /***************************************************************/ 147 #define READ_U8_S16_NOTALIGN(table0, table1, table2, table3) \ 148 t1 = *(mlib_u16*)((mlib_u8*)table0 + ((s0 >> 7) & 0x1FE)); \ 149 t0 = *(mlib_u16*)((mlib_u8*)table1 + ((s0 >> 15) & 0x1FE)); \ 150 t3 = *(mlib_u16*)((mlib_u8*)table2 + ((s0 >> 23) & 0x1FE)); \ 151 t2 = *(mlib_u16*)((mlib_u8*)table3 + ((s1 << 1) & 0x1FE)) 152 153 /***************************************************************/ 154 #define ADD_READ_U8_S16_NOTALIGN(table0, table1, table2) \ 155 t1 = *(mlib_u16*)((mlib_u8*)table0 + ((s1 >> 7) & 0x1FE)); \ 156 t0 = *(mlib_u16*)((mlib_u8*)table1 + ((s1 >> 15) & 0x1FE)); \ 157 t2 = *(mlib_u16*)((mlib_u8*)table2 + ((s1 >> 23) & 0x1FE)) 158 159 /***************************************************************/ 160 #define READ_U8_S32(table0, table1, table2, table3) \ 161 t0 = *(mlib_u32*)((mlib_u8*)table0 + ((s0 << 2) & 0x3FC)); \ 162 t1 = *(mlib_u32*)((mlib_u8*)table1 + ((s0 >> 6) & 0x3FC)); \ 163 t2 = *(mlib_u32*)((mlib_u8*)table2 + ((s0 >> 14) & 0x3FC)); \ 164 t3 = *(mlib_u32*)((mlib_u8*)table3 + ((s0 >> 22) & 0x3FC)) 165 166 #else /* _LITTLE_ENDIAN */ 167 168 /***********/ 169 #define READ_U8_U8_ALIGN(table0, table1, table2, table3) \ 170 t0 = table0[s0>>8]; \ 171 t1 = table1[s0 & 0xFF]; \ 172 t2 = table2[s1>>8]; \ 173 t3 = table3[s1 & 0xFF] 174 175 /***************************************************************/ 176 #define READ_U8_U8_NOTALIGN(table0, table1, table2, table3) \ 177 t0 = table0[s0 & 0xFF]; \ 178 t1 = table1[s1 >> 8]; \ 179 t2 = table2[s1 & 0xFF]; \ 180 t3 = table3[s2 >> 8] 181 182 /***************************************************************/ 183 #define READ_U8_S16_ALIGN(table0, table1, table2, table3) \ 184 t0 = *(mlib_u16*)((mlib_u8*)table0 + ((s0 >> 23) & 0x1FE)); \ 185 t1 = *(mlib_u16*)((mlib_u8*)table1 + ((s0 >> 15) & 0x1FE)); \ 186 t2 = *(mlib_u16*)((mlib_u8*)table2 + ((s0 >> 7) & 0x1FE)); \ 187 t3 = *(mlib_u16*)((mlib_u8*)table3 + ((s0 << 1) & 0x1FE)) 188 189 /***************************************************************/ 190 #define READ_U8_S16_NOTALIGN(table0, table1, table2, table3) \ 191 t0 = *(mlib_u16*)((mlib_u8*)table0 + ((s0 >> 15) & 0x1FE)); \ 192 t1 = *(mlib_u16*)((mlib_u8*)table1 + ((s0 >> 7) & 0x1FE)); \ 193 t2 = *(mlib_u16*)((mlib_u8*)table2 + ((s0 << 1) & 0x1FE)); \ 194 t3 = *(mlib_u16*)((mlib_u8*)table3 + ((s1 >> 23) & 0x1FE)) 195 196 /***************************************************************/ 197 #define ADD_READ_U8_S16_NOTALIGN(table0, table1, table2) \ 198 t0 = *(mlib_u16*)((mlib_u8*)table0 + ((s1 >> 15) & 0x1FE)); \ 199 t1 = *(mlib_u16*)((mlib_u8*)table1 + ((s1 >> 7) & 0x1FE)); \ 200 t2 = *(mlib_u16*)((mlib_u8*)table2 + ((s1 << 1) & 0x1FE)) 201 202 /***************************************************************/ 203 #define READ_U8_S32(table0, table1, table2, table3) \ 204 t0 = *(mlib_u32*)((mlib_u8*)table0 + ((s0 >> 22) & 0x3FC)); \ 205 t1 = *(mlib_u32*)((mlib_u8*)table1 + ((s0 >> 14) & 0x3FC)); \ 206 t2 = *(mlib_u32*)((mlib_u8*)table2 + ((s0 >> 6) & 0x3FC)); \ 207 t3 = *(mlib_u32*)((mlib_u8*)table3 + ((s0 << 2) & 0x3FC)) 208 209 #endif /* _LITTLE_ENDIAN */ 210 211 /***************************************************************/ 212 void mlib_c_ImageLookUp_U8_U8(const mlib_u8 *src, 213 mlib_s32 slb, 214 mlib_u8 *dst, 215 mlib_s32 dlb, 216 mlib_s32 xsize, 217 mlib_s32 ysize, 218 mlib_s32 csize, 219 const mlib_u8 **table) 220 { 221 222 if (xsize * csize < 9) { 223 MLIB_C_IMAGELOOKUP(mlib_u8, mlib_u8, table); 224 } 225 else if (csize == 1) { 226 mlib_s32 i, j; 227 228 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 229 mlib_u32 *da; 230 mlib_u16 *sa; 231 mlib_u8 *tab = (mlib_u8 *) table[0]; 232 mlib_u32 s0, s1, s2, t0, t1, t2, t3, t; 233 mlib_s32 off; 234 mlib_s32 size = xsize; 235 mlib_u8 *dp = dst, *sp = (void *)src; 236 237 off = (mlib_s32) ((4 - ((mlib_addr) dst & 3)) & 3); 238 239 for (i = 0; i < off; i++, sp++) { 240 *dp++ = tab[sp[0]]; 241 size--; 242 } 243 244 da = (mlib_u32 *) dp; 245 246 if (((mlib_addr) sp & 1) == 0) { 247 sa = (mlib_u16 *) sp; 248 249 s0 = sa[0]; 250 s1 = sa[1]; 251 sa += 2; 252 253 #ifdef __SUNPRO_C 254 #pragma pipeloop(0) 255 #endif /* __SUNPRO_C */ 256 for (i = 0; i < size - 7; i += 4, da++, sa += 2) { 257 READ_U8_U8_ALIGN(tab, tab, tab, tab); 258 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 259 s0 = sa[0]; 260 s1 = sa[1]; 261 da[0] = t; 262 } 263 264 READ_U8_U8_ALIGN(tab, tab, tab, tab); 265 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 266 da[0] = t; 267 da++; 268 dp = (mlib_u8 *) da; 269 sp = (mlib_u8 *) sa; 270 i += 4; 271 for (; i < size; i++, dp++, sp++) 272 dp[0] = tab[sp[0]]; 273 274 } 275 else { 276 sa = (mlib_u16 *) (sp - 1); 277 278 s0 = sa[0]; 279 s1 = sa[1]; 280 s2 = sa[2]; 281 sa += 3; 282 283 #ifdef __SUNPRO_C 284 #pragma pipeloop(0) 285 #endif /* __SUNPRO_C */ 286 for (i = 0; i < size - 8; i += 4, da++, sa += 2) { 287 READ_U8_U8_NOTALIGN(tab, tab, tab, tab); 288 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 289 s0 = s2; 290 s1 = sa[0]; 291 s2 = sa[1]; 292 da[0] = t; 293 } 294 295 READ_U8_U8_NOTALIGN(tab, tab, tab, tab); 296 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 297 da[0] = t; 298 da++; 299 dp = (mlib_u8 *) da; 300 #ifdef _LITTLE_ENDIAN 301 *dp++ = tab[s2 >> 8]; 302 #else 303 *dp++ = tab[s2 & 0xFF]; 304 #endif /* _LITTLE_ENDIAN */ 305 sp = (mlib_u8 *) sa; 306 i += 5; 307 for (; i < size; i++, dp++, sp++) 308 dp[0] = tab[sp[0]]; 309 } 310 } 311 312 } 313 else if (csize == 2) { 314 mlib_s32 i, j; 315 316 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 317 mlib_u32 *da; 318 mlib_u16 *sa; 319 mlib_u8 *tab0 = (mlib_u8 *) table[0]; 320 mlib_u8 *tab1 = (mlib_u8 *) table[1]; 321 mlib_u8 *tab; 322 mlib_u32 s0, s1, s2, t0, t1, t2, t3, t; 323 mlib_s32 off; 324 mlib_s32 size = xsize * 2; 325 mlib_u8 *dp = dst, *sp = (void *)src; 326 327 off = (mlib_s32) ((4 - ((mlib_addr) dst & 3)) & 3); 328 329 for (i = 0; i < off - 1; i += 2, sp += 2) { 330 *dp++ = tab0[sp[0]]; 331 *dp++ = tab1[sp[1]]; 332 size -= 2; 333 } 334 335 if ((off & 1) != 0) { 336 *dp++ = tab0[sp[0]]; 337 size--; 338 sp++; 339 tab = tab0; 340 tab0 = tab1; 341 tab1 = tab; 342 } 343 344 da = (mlib_u32 *) dp; 345 346 if (((mlib_addr) sp & 1) == 0) { 347 sa = (mlib_u16 *) sp; 348 349 s0 = sa[0]; 350 s1 = sa[1]; 351 sa += 2; 352 353 #ifdef __SUNPRO_C 354 #pragma pipeloop(0) 355 #endif /* __SUNPRO_C */ 356 for (i = 0; i < size - 7; i += 4, da++, sa += 2) { 357 READ_U8_U8_ALIGN(tab0, tab1, tab0, tab1); 358 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 359 s0 = sa[0]; 360 s1 = sa[1]; 361 da[0] = t; 362 } 363 364 READ_U8_U8_ALIGN(tab0, tab1, tab0, tab1); 365 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 366 da[0] = t; 367 da++; 368 dp = (mlib_u8 *) da; 369 sp = (mlib_u8 *) sa; 370 i += 4; 371 372 for (; i < size - 1; i += 2, sp += 2) { 373 *dp++ = tab0[sp[0]]; 374 *dp++ = tab1[sp[1]]; 375 } 376 377 if (i < size) 378 *dp = tab0[(*sp)]; 379 380 } 381 else { 382 sa = (mlib_u16 *) (sp - 1); 383 384 s0 = sa[0]; 385 s1 = sa[1]; 386 s2 = sa[2]; 387 sa += 3; 388 389 #ifdef __SUNPRO_C 390 #pragma pipeloop(0) 391 #endif /* __SUNPRO_C */ 392 for (i = 0; i < size - 8; i += 4, da++, sa += 2) { 393 READ_U8_U8_NOTALIGN(tab0, tab1, tab0, tab1); 394 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 395 s0 = s2; 396 s1 = sa[0]; 397 s2 = sa[1]; 398 da[0] = t; 399 } 400 401 READ_U8_U8_NOTALIGN(tab0, tab1, tab0, tab1); 402 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 403 da[0] = t; 404 da++; 405 dp = (mlib_u8 *) da; 406 #ifdef _LITTLE_ENDIAN 407 *dp++ = tab0[s2 >> 8]; 408 #else 409 *dp++ = tab0[s2 & 0xFF]; 410 #endif /* _LITTLE_ENDIAN */ 411 sp = (mlib_u8 *) sa; 412 i += 5; 413 414 for (; i < size - 1; i += 2, sp += 2) { 415 *dp++ = tab1[sp[0]]; 416 *dp++ = tab0[sp[1]]; 417 } 418 419 if (i < size) 420 *dp = tab1[(*sp)]; 421 } 422 } 423 424 } 425 else if (csize == 3) { 426 mlib_s32 i, j; 427 428 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 429 mlib_u32 *da; 430 mlib_u16 *sa; 431 mlib_u8 *tab0 = (mlib_u8 *) table[0]; 432 mlib_u8 *tab1 = (mlib_u8 *) table[1]; 433 mlib_u8 *tab2 = (mlib_u8 *) table[2]; 434 mlib_u8 *tab; 435 mlib_u32 s0, s1, s2, t0, t1, t2, t3, t; 436 mlib_s32 off; 437 mlib_s32 size = xsize * 3; 438 mlib_u8 *dp = dst, *sp = (void *)src; 439 440 off = (mlib_s32) ((4 - ((mlib_addr) dst & 3)) & 3); 441 442 if (off == 1) { 443 *dp++ = tab0[sp[0]]; 444 tab = tab0; 445 tab0 = tab1; 446 tab1 = tab2; 447 tab2 = tab; 448 size--; 449 sp++; 450 } 451 else if (off == 2) { 452 *dp++ = tab0[sp[0]]; 453 *dp++ = tab1[sp[1]]; 454 tab = tab2; 455 tab2 = tab1; 456 tab1 = tab0; 457 tab0 = tab; 458 size -= 2; 459 sp += 2; 460 } 461 else if (off == 3) { 462 *dp++ = tab0[sp[0]]; 463 *dp++ = tab1[sp[1]]; 464 *dp++ = tab2[sp[2]]; 465 size -= 3; 466 sp += 3; 467 } 468 469 da = (mlib_u32 *) dp; 470 471 if (((mlib_addr) sp & 1) == 0) { 472 sa = (mlib_u16 *) sp; 473 474 s0 = sa[0]; 475 s1 = sa[1]; 476 sa += 2; 477 478 #ifdef __SUNPRO_C 479 #pragma pipeloop(0) 480 #endif /* __SUNPRO_C */ 481 for (i = 0; i < size - 7; i += 4, da++, sa += 2) { 482 READ_U8_U8_ALIGN(tab0, tab1, tab2, tab0); 483 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 484 tab = tab0; 485 tab0 = tab1; 486 tab1 = tab2; 487 tab2 = tab; 488 s0 = sa[0]; 489 s1 = sa[1]; 490 da[0] = t; 491 } 492 493 READ_U8_U8_ALIGN(tab0, tab1, tab2, tab0); 494 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 495 da[0] = t; 496 da++; 497 dp = (mlib_u8 *) da; 498 sp = (mlib_u8 *) sa; 499 i += 4; 500 501 if (i < size) { 502 *dp++ = tab1[(*sp)]; 503 i++; 504 sp++; 505 } 506 507 if (i < size) { 508 *dp++ = tab2[(*sp)]; 509 i++; 510 sp++; 511 } 512 513 if (i < size) { 514 *dp++ = tab0[(*sp)]; 515 } 516 517 } 518 else { 519 sa = (mlib_u16 *) (sp - 1); 520 521 s0 = sa[0]; 522 s1 = sa[1]; 523 s2 = sa[2]; 524 sa += 3; 525 526 #ifdef __SUNPRO_C 527 #pragma pipeloop(0) 528 #endif /* __SUNPRO_C */ 529 for (i = 0; i < size - 8; i += 4, da++, sa += 2) { 530 READ_U8_U8_NOTALIGN(tab0, tab1, tab2, tab0); 531 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 532 tab = tab0; 533 tab0 = tab1; 534 tab1 = tab2; 535 tab2 = tab; 536 s0 = s2; 537 s1 = sa[0]; 538 s2 = sa[1]; 539 da[0] = t; 540 } 541 542 READ_U8_U8_NOTALIGN(tab0, tab1, tab2, tab0); 543 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 544 da[0] = t; 545 da++; 546 dp = (mlib_u8 *) da; 547 #ifdef _LITTLE_ENDIAN 548 *dp++ = tab1[s2 >> 8]; 549 #else 550 *dp++ = tab1[s2 & 0xFF]; 551 #endif /* _LITTLE_ENDIAN */ 552 sp = (mlib_u8 *) sa; 553 i += 5; 554 555 if (i < size) { 556 *dp++ = tab2[(*sp)]; 557 i++; 558 sp++; 559 } 560 561 if (i < size) { 562 *dp++ = tab0[(*sp)]; 563 i++; 564 sp++; 565 } 566 567 if (i < size) { 568 *dp = tab1[(*sp)]; 569 } 570 } 571 } 572 573 } 574 else if (csize == 4) { 575 mlib_s32 i, j; 576 577 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 578 mlib_u32 *da; 579 mlib_u16 *sa; 580 mlib_u8 *tab0 = (mlib_u8 *) table[0]; 581 mlib_u8 *tab1 = (mlib_u8 *) table[1]; 582 mlib_u8 *tab2 = (mlib_u8 *) table[2]; 583 mlib_u8 *tab3 = (mlib_u8 *) table[3]; 584 mlib_u8 *tab; 585 mlib_u32 s0, s1, s2, t0, t1, t2, t3, t; 586 mlib_s32 off; 587 mlib_s32 size = xsize * 4; 588 mlib_u8 *dp = dst, *sp = (void *)src; 589 590 off = (mlib_s32) ((4 - ((mlib_addr) dst & 3)) & 3); 591 592 if (off == 1) { 593 *dp++ = tab0[sp[0]]; 594 tab = tab0; 595 tab0 = tab1; 596 tab1 = tab2; 597 tab2 = tab3; 598 tab3 = tab; 599 size--; 600 sp++; 601 } 602 else if (off == 2) { 603 *dp++ = tab0[sp[0]]; 604 *dp++ = tab1[sp[1]]; 605 tab = tab0; 606 tab0 = tab2; 607 tab2 = tab; 608 tab = tab1; 609 tab1 = tab3; 610 tab3 = tab; 611 size -= 2; 612 sp += 2; 613 } 614 else if (off == 3) { 615 *dp++ = tab0[sp[0]]; 616 *dp++ = tab1[sp[1]]; 617 *dp++ = tab2[sp[2]]; 618 tab = tab3; 619 tab3 = tab2; 620 tab2 = tab1; 621 tab1 = tab0; 622 tab0 = tab; 623 size -= 3; 624 sp += 3; 625 } 626 627 da = (mlib_u32 *) dp; 628 629 if (((mlib_addr) sp & 1) == 0) { 630 sa = (mlib_u16 *) sp; 631 632 s0 = sa[0]; 633 s1 = sa[1]; 634 sa += 2; 635 636 #ifdef __SUNPRO_C 637 #pragma pipeloop(0) 638 #endif /* __SUNPRO_C */ 639 for (i = 0; i < size - 7; i += 4, da++, sa += 2) { 640 READ_U8_U8_ALIGN(tab0, tab1, tab2, tab3); 641 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 642 s0 = sa[0]; 643 s1 = sa[1]; 644 da[0] = t; 645 } 646 647 READ_U8_U8_ALIGN(tab0, tab1, tab2, tab3); 648 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 649 da[0] = t; 650 da++; 651 dp = (mlib_u8 *) da; 652 sp = (mlib_u8 *) sa; 653 i += 4; 654 655 if (i < size) { 656 *dp++ = tab0[(*sp)]; 657 i++; 658 sp++; 659 } 660 661 if (i < size) { 662 *dp++ = tab1[(*sp)]; 663 i++; 664 sp++; 665 } 666 667 if (i < size) { 668 *dp = tab2[(*sp)]; 669 } 670 671 } 672 else { 673 sa = (mlib_u16 *) (sp - 1); 674 675 s0 = sa[0]; 676 s1 = sa[1]; 677 s2 = sa[2]; 678 sa += 3; 679 680 #ifdef __SUNPRO_C 681 #pragma pipeloop(0) 682 #endif /* __SUNPRO_C */ 683 for (i = 0; i < size - 8; i += 4, da++, sa += 2) { 684 READ_U8_U8_NOTALIGN(tab0, tab1, tab2, tab3); 685 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 686 s0 = s2; 687 s1 = sa[0]; 688 s2 = sa[1]; 689 da[0] = t; 690 } 691 692 READ_U8_U8_NOTALIGN(tab0, tab1, tab2, tab3); 693 t = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 694 da[0] = t; 695 da++; 696 dp = (mlib_u8 *) da; 697 #ifdef _LITTLE_ENDIAN 698 *dp++ = tab0[s2 >> 8]; 699 #else 700 *dp++ = tab0[s2 & 0xFF]; 701 #endif /* _LITTLE_ENDIAN */ 702 sp = (mlib_u8 *) sa; 703 i += 5; 704 705 if (i < size) { 706 *dp++ = tab1[(*sp)]; 707 i++; 708 sp++; 709 } 710 711 if (i < size) { 712 *dp++ = tab2[(*sp)]; 713 i++; 714 sp++; 715 } 716 717 if (i < size) { 718 *dp = tab3[(*sp)]; 719 } 720 } 721 } 722 } 723 } 724 725 /***************************************************************/ 726 void mlib_c_ImageLookUp_S16_U8(const mlib_s16 *src, 727 mlib_s32 slb, 728 mlib_u8 *dst, 729 mlib_s32 dlb, 730 mlib_s32 xsize, 731 mlib_s32 ysize, 732 mlib_s32 csize, 733 const mlib_u8 **table) 734 { 735 const mlib_u8 *table_base[4]; 736 mlib_s32 c; 737 738 for (c = 0; c < csize; c++) { 739 table_base[c] = &table[c][32768]; 740 } 741 742 MLIB_C_IMAGELOOKUP(mlib_u8, mlib_s16, table_base); 743 } 744 745 /***************************************************************/ 746 void mlib_c_ImageLookUp_U16_U8(const mlib_u16 *src, 747 mlib_s32 slb, 748 mlib_u8 *dst, 749 mlib_s32 dlb, 750 mlib_s32 xsize, 751 mlib_s32 ysize, 752 mlib_s32 csize, 753 const mlib_u8 **table) 754 { 755 const mlib_u8 *table_base[4]; 756 mlib_s32 c; 757 758 for (c = 0; c < csize; c++) { 759 table_base[c] = &table[c][0]; 760 } 761 762 MLIB_C_IMAGELOOKUP(mlib_u8, mlib_u16, table_base); 763 } 764 765 /***************************************************************/ 766 void mlib_c_ImageLookUp_S32_U8(const mlib_s32 *src, 767 mlib_s32 slb, 768 mlib_u8 *dst, 769 mlib_s32 dlb, 770 mlib_s32 xsize, 771 mlib_s32 ysize, 772 mlib_s32 csize, 773 const mlib_u8 **table) 774 { 775 const mlib_u8 *table_base[4]; 776 mlib_s32 c; 777 778 for (c = 0; c < csize; c++) { 779 table_base[c] = &table[c][TABLE_SHIFT_S32]; 780 } 781 782 MLIB_C_IMAGELOOKUP(mlib_u8, mlib_s32, table_base); 783 } 784 785 /***************************************************************/ 786 void mlib_c_ImageLookUp_U8_S16(const mlib_u8 *src, 787 mlib_s32 slb, 788 mlib_s16 *dst, 789 mlib_s32 dlb, 790 mlib_s32 xsize, 791 mlib_s32 ysize, 792 mlib_s32 csize, 793 const mlib_s16 **table) 794 { 795 796 if (xsize * csize < 12) { 797 MLIB_C_IMAGELOOKUP(mlib_s16, mlib_u8, table); 798 } 799 else if (csize == 1) { 800 mlib_s32 i, j; 801 802 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 803 mlib_u32 *sa; 804 mlib_u32 *da; 805 mlib_u16 *tab = (mlib_u16 *) table[0]; 806 mlib_u32 s0, s1, t0, t1, t2, t3; 807 mlib_u32 res1, res2; 808 mlib_s32 off; 809 mlib_s32 size = xsize; 810 mlib_u16 *dp = (mlib_u16 *) dst; 811 mlib_u8 *sp = (void *)src; 812 813 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 814 815 for (i = 0; i < off; i++, sp++) { 816 *dp++ = tab[sp[0]]; 817 size--; 818 } 819 820 sa = (mlib_u32 *) sp; 821 822 if (((mlib_addr) dp & 3) == 0) { 823 da = (mlib_u32 *) dp; 824 825 s0 = sa[0]; 826 sa++; 827 828 #ifdef __SUNPRO_C 829 #pragma pipeloop(0) 830 #endif /* __SUNPRO_C */ 831 for (i = 0; i < size - 7; i += 4, da += 2, sa++) { 832 READ_U8_S16_ALIGN(tab, tab, tab, tab); 833 res1 = (t0 << 16) + t1; 834 res2 = (t2 << 16) + t3; 835 s0 = sa[0]; 836 da[0] = res1; 837 da[1] = res2; 838 } 839 840 READ_U8_S16_ALIGN(tab, tab, tab, tab); 841 res1 = (t0 << 16) + t1; 842 res2 = (t2 << 16) + t3; 843 da[0] = res1; 844 da[1] = res2; 845 da += 2; 846 dp = (mlib_u16 *) da; 847 sp = (mlib_u8 *) sa; 848 i += 4; 849 for (; i < size; i++, dp++, sp++) 850 dp[0] = tab[sp[0]]; 851 852 } 853 else { 854 855 *dp++ = tab[(*sp)]; 856 size--; 857 da = (mlib_u32 *) dp; 858 859 s0 = sa[0]; 860 s1 = sa[1]; 861 sa += 2; 862 863 #ifdef __SUNPRO_C 864 #pragma pipeloop(0) 865 #endif /* __SUNPRO_C */ 866 for (i = 0; i < size - 10; i += 4, da += 2, sa++) { 867 READ_U8_S16_NOTALIGN(tab, tab, tab, tab); 868 s0 = s1; 869 res1 = (t0 << 16) + t1; 870 res2 = (t2 << 16) + t3; 871 s1 = sa[0]; 872 da[0] = res1; 873 da[1] = res2; 874 } 875 876 READ_U8_S16_NOTALIGN(tab, tab, tab, tab); 877 res1 = (t0 << 16) + t1; 878 res2 = (t2 << 16) + t3; 879 da[0] = res1; 880 da[1] = res2; 881 ADD_READ_U8_S16_NOTALIGN(tab, tab, tab); 882 res1 = (t0 << 16) + t1; 883 da[2] = res1; 884 da += 3; 885 dp = (mlib_u16 *) da; 886 *dp++ = (mlib_u16) t2; 887 sp = (mlib_u8 *) sa; 888 i += 7; 889 for (; i < size; i++, dp++, sp++) 890 dp[0] = tab[sp[0]]; 891 } 892 } 893 894 } 895 else if (csize == 2) { 896 mlib_s32 i, j; 897 898 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 899 mlib_u32 *sa; 900 mlib_u32 *da; 901 mlib_u16 *tab0 = (mlib_u16 *) table[0]; 902 mlib_u16 *tab1 = (mlib_u16 *) table[1]; 903 mlib_u16 *tab; 904 mlib_u32 s0, s1, t0, t1, t2, t3; 905 mlib_u32 res1, res2; 906 mlib_s32 off; 907 mlib_s32 size = xsize * 2; 908 mlib_u16 *dp = (mlib_u16 *) dst; 909 mlib_u8 *sp = (void *)src; 910 911 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 912 913 for (i = 0; i < off - 1; i += 2, sp += 2) { 914 *dp++ = tab0[sp[0]]; 915 *dp++ = tab1[sp[1]]; 916 size -= 2; 917 } 918 919 if ((off & 1) != 0) { 920 *dp++ = tab0[*sp]; 921 size--; 922 sp++; 923 tab = tab0; 924 tab0 = tab1; 925 tab1 = tab; 926 } 927 928 sa = (mlib_u32 *) sp; 929 930 if (((mlib_addr) dp & 3) == 0) { 931 da = (mlib_u32 *) dp; 932 933 s0 = sa[0]; 934 sa++; 935 936 #ifdef __SUNPRO_C 937 #pragma pipeloop(0) 938 #endif /* __SUNPRO_C */ 939 for (i = 0; i < size - 7; i += 4, da += 2, sa++) { 940 READ_U8_S16_ALIGN(tab0, tab1, tab0, tab1); 941 res1 = (t0 << 16) + t1; 942 res2 = (t2 << 16) + t3; 943 s0 = sa[0]; 944 da[0] = res1; 945 da[1] = res2; 946 } 947 948 READ_U8_S16_ALIGN(tab0, tab1, tab0, tab1); 949 res1 = (t0 << 16) + t1; 950 res2 = (t2 << 16) + t3; 951 da[0] = res1; 952 da[1] = res2; 953 da += 2; 954 dp = (mlib_u16 *) da; 955 sp = (mlib_u8 *) sa; 956 i += 4; 957 958 for (; i < size - 1; i += 2, sp += 2) { 959 *dp++ = tab0[sp[0]]; 960 *dp++ = tab1[sp[1]]; 961 } 962 963 if (i < size) 964 *dp = tab0[(*sp)]; 965 966 } 967 else { 968 969 *dp++ = tab0[(*sp)]; 970 size--; 971 da = (mlib_u32 *) dp; 972 973 s0 = sa[0]; 974 s1 = sa[1]; 975 sa += 2; 976 977 #ifdef __SUNPRO_C 978 #pragma pipeloop(0) 979 #endif /* __SUNPRO_C */ 980 for (i = 0; i < size - 10; i += 4, da += 2, sa++) { 981 READ_U8_S16_NOTALIGN(tab1, tab0, tab1, tab0); 982 s0 = s1; 983 res1 = (t0 << 16) + t1; 984 res2 = (t2 << 16) + t3; 985 s1 = sa[0]; 986 da[0] = res1; 987 da[1] = res2; 988 } 989 990 READ_U8_S16_NOTALIGN(tab1, tab0, tab1, tab0); 991 res1 = (t0 << 16) + t1; 992 res2 = (t2 << 16) + t3; 993 da[0] = res1; 994 da[1] = res2; 995 ADD_READ_U8_S16_NOTALIGN(tab1, tab0, tab1); 996 res1 = (t0 << 16) + t1; 997 da[2] = res1; 998 da += 3; 999 dp = (mlib_u16 *) da; 1000 *dp++ = (mlib_u16) t2; 1001 sp = (mlib_u8 *) sa; 1002 i += 7; 1003 1004 for (; i < size - 1; i += 2, sp += 2) { 1005 *dp++ = tab0[sp[0]]; 1006 *dp++ = tab1[sp[1]]; 1007 } 1008 1009 if (i < size) 1010 *dp = tab0[(*sp)]; 1011 } 1012 } 1013 1014 } 1015 else if (csize == 3) { 1016 mlib_s32 i, j; 1017 1018 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 1019 mlib_u32 *sa; 1020 mlib_u32 *da; 1021 mlib_u16 *tab0 = (mlib_u16 *) table[0]; 1022 mlib_u16 *tab1 = (mlib_u16 *) table[1]; 1023 mlib_u16 *tab2 = (mlib_u16 *) table[2]; 1024 mlib_u16 *tab; 1025 mlib_u32 s0, s1, t0, t1, t2, t3; 1026 mlib_u32 res1, res2; 1027 mlib_s32 off; 1028 mlib_s32 size = xsize * 3; 1029 mlib_u16 *dp = (mlib_u16 *) dst; 1030 mlib_u8 *sp = (void *)src; 1031 1032 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 1033 1034 if (off == 1) { 1035 *dp++ = tab0[(*sp)]; 1036 tab = tab0; 1037 tab0 = tab1; 1038 tab1 = tab2; 1039 tab2 = tab; 1040 size--; 1041 sp++; 1042 } 1043 else if (off == 2) { 1044 *dp++ = tab0[sp[0]]; 1045 *dp++ = tab1[sp[1]]; 1046 tab = tab2; 1047 tab2 = tab1; 1048 tab1 = tab0; 1049 tab0 = tab; 1050 size -= 2; 1051 sp += 2; 1052 } 1053 else if (off == 3) { 1054 *dp++ = tab0[sp[0]]; 1055 *dp++ = tab1[sp[1]]; 1056 *dp++ = tab2[sp[2]]; 1057 size -= 3; 1058 sp += 3; 1059 } 1060 1061 sa = (mlib_u32 *) sp; 1062 1063 if (((mlib_addr) dp & 3) == 0) { 1064 da = (mlib_u32 *) dp; 1065 1066 s0 = sa[0]; 1067 sa++; 1068 1069 #ifdef __SUNPRO_C 1070 #pragma pipeloop(0) 1071 #endif /* __SUNPRO_C */ 1072 for (i = 0; i < size - 7; i += 4, da += 2, sa++) { 1073 READ_U8_S16_ALIGN(tab0, tab1, tab2, tab0); 1074 res1 = (t0 << 16) + t1; 1075 res2 = (t2 << 16) + t3; 1076 tab = tab0; 1077 tab0 = tab1; 1078 tab1 = tab2; 1079 tab2 = tab; 1080 s0 = sa[0]; 1081 da[0] = res1; 1082 da[1] = res2; 1083 } 1084 1085 READ_U8_S16_ALIGN(tab0, tab1, tab2, tab0); 1086 res1 = (t0 << 16) + t1; 1087 res2 = (t2 << 16) + t3; 1088 da[0] = res1; 1089 da[1] = res2; 1090 da += 2; 1091 dp = (mlib_u16 *) da; 1092 sp = (mlib_u8 *) sa; 1093 i += 4; 1094 1095 if (i < size) { 1096 *dp++ = tab1[(*sp)]; 1097 i++; 1098 sp++; 1099 } 1100 1101 if (i < size) { 1102 *dp++ = tab2[(*sp)]; 1103 i++; 1104 sp++; 1105 } 1106 1107 if (i < size) { 1108 *dp = tab0[(*sp)]; 1109 } 1110 1111 } 1112 else { 1113 1114 *dp++ = tab0[(*sp)]; 1115 size--; 1116 da = (mlib_u32 *) dp; 1117 1118 s0 = sa[0]; 1119 s1 = sa[1]; 1120 sa += 2; 1121 1122 #ifdef __SUNPRO_C 1123 #pragma pipeloop(0) 1124 #endif /* __SUNPRO_C */ 1125 for (i = 0; i < size - 10; i += 4, da += 2, sa++) { 1126 READ_U8_S16_NOTALIGN(tab1, tab2, tab0, tab1); 1127 s0 = s1; 1128 res1 = (t0 << 16) + t1; 1129 res2 = (t2 << 16) + t3; 1130 tab = tab0; 1131 tab0 = tab1; 1132 tab1 = tab2; 1133 tab2 = tab; 1134 s1 = sa[0]; 1135 da[0] = res1; 1136 da[1] = res2; 1137 } 1138 1139 READ_U8_S16_NOTALIGN(tab1, tab2, tab0, tab1); 1140 res1 = (t0 << 16) + t1; 1141 res2 = (t2 << 16) + t3; 1142 da[0] = res1; 1143 da[1] = res2; 1144 ADD_READ_U8_S16_NOTALIGN(tab2, tab0, tab1); 1145 res1 = (t0 << 16) + t1; 1146 da[2] = res1; 1147 da += 3; 1148 dp = (mlib_u16 *) da; 1149 *dp++ = (mlib_u16) t2; 1150 sp = (mlib_u8 *) sa; 1151 i += 7; 1152 1153 if (i < size) { 1154 *dp++ = tab2[(*sp)]; 1155 i++; 1156 sp++; 1157 } 1158 1159 if (i < size) { 1160 *dp++ = tab0[(*sp)]; 1161 i++; 1162 sp++; 1163 } 1164 1165 if (i < size) { 1166 *dp = tab1[(*sp)]; 1167 } 1168 } 1169 } 1170 1171 } 1172 else if (csize == 4) { 1173 mlib_s32 i, j; 1174 1175 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 1176 mlib_u32 *sa; 1177 mlib_u32 *da; 1178 mlib_u16 *tab0 = (mlib_u16 *) table[0]; 1179 mlib_u16 *tab1 = (mlib_u16 *) table[1]; 1180 mlib_u16 *tab2 = (mlib_u16 *) table[2]; 1181 mlib_u16 *tab3 = (mlib_u16 *) table[3]; 1182 mlib_u16 *tab; 1183 mlib_u32 s0, s1, t0, t1, t2, t3; 1184 mlib_u32 res1, res2; 1185 mlib_s32 off; 1186 mlib_s32 size = xsize * 4; 1187 mlib_u16 *dp = (mlib_u16 *) dst; 1188 mlib_u8 *sp = (void *)src; 1189 1190 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 1191 1192 if (off == 1) { 1193 *dp++ = tab0[(*sp)]; 1194 tab = tab0; 1195 tab0 = tab1; 1196 tab1 = tab2; 1197 tab2 = tab3; 1198 tab3 = tab; 1199 size--; 1200 sp++; 1201 } 1202 else if (off == 2) { 1203 *dp++ = tab0[sp[0]]; 1204 *dp++ = tab1[sp[1]]; 1205 tab = tab0; 1206 tab0 = tab2; 1207 tab2 = tab; 1208 tab = tab1; 1209 tab1 = tab3; 1210 tab3 = tab; 1211 size -= 2; 1212 sp += 2; 1213 } 1214 else if (off == 3) { 1215 *dp++ = tab0[sp[0]]; 1216 *dp++ = tab1[sp[1]]; 1217 *dp++ = tab2[sp[2]]; 1218 tab = tab3; 1219 tab3 = tab2; 1220 tab2 = tab1; 1221 tab1 = tab0; 1222 tab0 = tab; 1223 size -= 3; 1224 sp += 3; 1225 } 1226 1227 sa = (mlib_u32 *) sp; 1228 1229 if (((mlib_addr) dp & 3) == 0) { 1230 da = (mlib_u32 *) dp; 1231 1232 s0 = sa[0]; 1233 sa++; 1234 1235 #ifdef __SUNPRO_C 1236 #pragma pipeloop(0) 1237 #endif /* __SUNPRO_C */ 1238 for (i = 0; i < size - 7; i += 4, da += 2, sa++) { 1239 READ_U8_S16_ALIGN(tab0, tab1, tab2, tab3); 1240 res1 = (t0 << 16) + t1; 1241 res2 = (t2 << 16) + t3; 1242 s0 = sa[0]; 1243 da[0] = res1; 1244 da[1] = res2; 1245 } 1246 1247 READ_U8_S16_ALIGN(tab0, tab1, tab2, tab3); 1248 res1 = (t0 << 16) + t1; 1249 res2 = (t2 << 16) + t3; 1250 da[0] = res1; 1251 da[1] = res2; 1252 da += 2; 1253 dp = (mlib_u16 *) da; 1254 sp = (mlib_u8 *) sa; 1255 i += 4; 1256 1257 if (i < size) { 1258 *dp++ = tab0[(*sp)]; 1259 i++; 1260 sp++; 1261 } 1262 1263 if (i < size) { 1264 *dp++ = tab1[(*sp)]; 1265 i++; 1266 sp++; 1267 } 1268 1269 if (i < size) { 1270 *dp = tab2[(*sp)]; 1271 } 1272 1273 } 1274 else { 1275 1276 *dp++ = tab0[(*sp)]; 1277 size--; 1278 da = (mlib_u32 *) dp; 1279 1280 s0 = sa[0]; 1281 s1 = sa[1]; 1282 sa += 2; 1283 1284 #ifdef __SUNPRO_C 1285 #pragma pipeloop(0) 1286 #endif /* __SUNPRO_C */ 1287 for (i = 0; i < size - 10; i += 4, da += 2, sa++) { 1288 READ_U8_S16_NOTALIGN(tab1, tab2, tab3, tab0); 1289 s0 = s1; 1290 res1 = (t0 << 16) + t1; 1291 res2 = (t2 << 16) + t3; 1292 s1 = sa[0]; 1293 da[0] = res1; 1294 da[1] = res2; 1295 } 1296 1297 READ_U8_S16_NOTALIGN(tab1, tab2, tab3, tab0); 1298 res1 = (t0 << 16) + t1; 1299 res2 = (t2 << 16) + t3; 1300 da[0] = res1; 1301 da[1] = res2; 1302 ADD_READ_U8_S16_NOTALIGN(tab1, tab2, tab3); 1303 res1 = (t0 << 16) + t1; 1304 da[2] = res1; 1305 da += 3; 1306 dp = (mlib_u16 *) da; 1307 *dp++ = (mlib_u16) t2; 1308 sp = (mlib_u8 *) sa; 1309 i += 7; 1310 1311 if (i < size) { 1312 *dp++ = tab0[(*sp)]; 1313 i++; 1314 sp++; 1315 } 1316 1317 if (i < size) { 1318 *dp++ = tab1[(*sp)]; 1319 i++; 1320 sp++; 1321 } 1322 1323 if (i < size) { 1324 *dp = tab2[(*sp)]; 1325 } 1326 } 1327 } 1328 } 1329 } 1330 1331 /***************************************************************/ 1332 void mlib_c_ImageLookUp_S16_S16(const mlib_s16 *src, 1333 mlib_s32 slb, 1334 mlib_s16 *dst, 1335 mlib_s32 dlb, 1336 mlib_s32 xsize, 1337 mlib_s32 ysize, 1338 mlib_s32 csize, 1339 const mlib_s16 **table) 1340 { 1341 const mlib_s16 *table_base[4]; 1342 mlib_s32 c; 1343 1344 for (c = 0; c < csize; c++) { 1345 table_base[c] = &table[c][32768]; 1346 } 1347 1348 MLIB_C_IMAGELOOKUP(mlib_s16, mlib_s16, table_base); 1349 } 1350 1351 /***************************************************************/ 1352 void mlib_c_ImageLookUp_U16_S16(const mlib_u16 *src, 1353 mlib_s32 slb, 1354 mlib_s16 *dst, 1355 mlib_s32 dlb, 1356 mlib_s32 xsize, 1357 mlib_s32 ysize, 1358 mlib_s32 csize, 1359 const mlib_s16 **table) 1360 { 1361 const mlib_s16 *table_base[4]; 1362 mlib_s32 c; 1363 1364 for (c = 0; c < csize; c++) { 1365 table_base[c] = &table[c][0]; 1366 } 1367 1368 MLIB_C_IMAGELOOKUP(mlib_s16, mlib_u16, table_base); 1369 } 1370 1371 /***************************************************************/ 1372 void mlib_c_ImageLookUp_S32_S16(const mlib_s32 *src, 1373 mlib_s32 slb, 1374 mlib_s16 *dst, 1375 mlib_s32 dlb, 1376 mlib_s32 xsize, 1377 mlib_s32 ysize, 1378 mlib_s32 csize, 1379 const mlib_s16 **table) 1380 { 1381 const mlib_s16 *table_base[4]; 1382 mlib_s32 c; 1383 1384 for (c = 0; c < csize; c++) { 1385 table_base[c] = &table[c][TABLE_SHIFT_S32]; 1386 } 1387 1388 MLIB_C_IMAGELOOKUP(mlib_s16, mlib_s32, table_base); 1389 } 1390 1391 /***************************************************************/ 1392 void mlib_c_ImageLookUp_S16_U16(const mlib_s16 *src, 1393 mlib_s32 slb, 1394 mlib_u16 *dst, 1395 mlib_s32 dlb, 1396 mlib_s32 xsize, 1397 mlib_s32 ysize, 1398 mlib_s32 csize, 1399 const mlib_s16 **table) 1400 { 1401 const mlib_s16 *table_base[4]; 1402 mlib_s32 c; 1403 1404 for (c = 0; c < csize; c++) { 1405 table_base[c] = &table[c][32768]; 1406 } 1407 1408 MLIB_C_IMAGELOOKUP(mlib_u16, mlib_s16, table_base); 1409 } 1410 1411 /***************************************************************/ 1412 void mlib_c_ImageLookUp_U16_U16(const mlib_u16 *src, 1413 mlib_s32 slb, 1414 mlib_u16 *dst, 1415 mlib_s32 dlb, 1416 mlib_s32 xsize, 1417 mlib_s32 ysize, 1418 mlib_s32 csize, 1419 const mlib_s16 **table) 1420 { 1421 const mlib_s16 *table_base[4]; 1422 mlib_s32 c; 1423 1424 for (c = 0; c < csize; c++) { 1425 table_base[c] = &table[c][0]; 1426 } 1427 1428 MLIB_C_IMAGELOOKUP(mlib_u16, mlib_u16, table_base); 1429 } 1430 1431 /***************************************************************/ 1432 void mlib_c_ImageLookUp_S32_U16(const mlib_s32 *src, 1433 mlib_s32 slb, 1434 mlib_u16 *dst, 1435 mlib_s32 dlb, 1436 mlib_s32 xsize, 1437 mlib_s32 ysize, 1438 mlib_s32 csize, 1439 const mlib_s16 **table) 1440 { 1441 const mlib_s16 *table_base[4]; 1442 mlib_s32 c; 1443 1444 for (c = 0; c < csize; c++) { 1445 table_base[c] = &table[c][TABLE_SHIFT_S32]; 1446 } 1447 1448 MLIB_C_IMAGELOOKUP(mlib_u16, mlib_s32, table_base); 1449 } 1450 1451 /***************************************************************/ 1452 void mlib_c_ImageLookUp_U8_S32(const mlib_u8 *src, 1453 mlib_s32 slb, 1454 mlib_s32 *dst, 1455 mlib_s32 dlb, 1456 mlib_s32 xsize, 1457 mlib_s32 ysize, 1458 mlib_s32 csize, 1459 const mlib_s32 **table) 1460 { 1461 1462 if (xsize * csize < 7) { 1463 MLIB_C_IMAGELOOKUP(mlib_s32, mlib_u8, table); 1464 } 1465 else if (csize == 1) { 1466 mlib_s32 i, j; 1467 1468 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 1469 mlib_u32 *sa; 1470 mlib_u32 *tab = (mlib_u32 *) table[0]; 1471 mlib_u32 s0, t0, t1, t2, t3; 1472 mlib_s32 off; 1473 mlib_s32 size = xsize; 1474 mlib_u32 *dp = (mlib_u32 *) dst; 1475 mlib_u8 *sp = (void *)src; 1476 1477 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 1478 1479 for (i = 0; i < off; i++, sp++) { 1480 *dp++ = tab[sp[0]]; 1481 size--; 1482 } 1483 1484 sa = (mlib_u32 *) sp; 1485 1486 s0 = sa[0]; 1487 sa++; 1488 1489 #ifdef __SUNPRO_C 1490 #pragma pipeloop(0) 1491 #endif /* __SUNPRO_C */ 1492 for (i = 0; i < size - 7; i += 4, dp += 4, sa++) { 1493 READ_U8_S32(tab, tab, tab, tab); 1494 s0 = sa[0]; 1495 dp[0] = t0; 1496 dp[1] = t1; 1497 dp[2] = t2; 1498 dp[3] = t3; 1499 } 1500 1501 READ_U8_S32(tab, tab, tab, tab); 1502 dp[0] = t0; 1503 dp[1] = t1; 1504 dp[2] = t2; 1505 dp[3] = t3; 1506 dp += 4; 1507 sp = (mlib_u8 *) sa; 1508 i += 4; 1509 for (; i < size; i++, dp++, sp++) 1510 dp[0] = tab[sp[0]]; 1511 } 1512 1513 } 1514 else if (csize == 2) { 1515 mlib_s32 i, j; 1516 1517 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 1518 mlib_u32 *sa; 1519 mlib_u32 *tab0 = (mlib_u32 *) table[0]; 1520 mlib_u32 *tab1 = (mlib_u32 *) table[1]; 1521 mlib_u32 *tab; 1522 mlib_u32 s0, t0, t1, t2, t3; 1523 mlib_s32 off; 1524 mlib_s32 size = xsize * 2; 1525 mlib_u32 *dp = (mlib_u32 *) dst; 1526 mlib_u8 *sp = (void *)src; 1527 1528 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 1529 1530 for (i = 0; i < off - 1; i += 2, sp += 2) { 1531 *dp++ = tab0[sp[0]]; 1532 *dp++ = tab1[sp[1]]; 1533 size -= 2; 1534 } 1535 1536 if ((off & 1) != 0) { 1537 *dp++ = tab0[*sp]; 1538 size--; 1539 sp++; 1540 tab = tab0; 1541 tab0 = tab1; 1542 tab1 = tab; 1543 } 1544 1545 sa = (mlib_u32 *) sp; 1546 1547 s0 = sa[0]; 1548 sa++; 1549 1550 #ifdef __SUNPRO_C 1551 #pragma pipeloop(0) 1552 #endif /* __SUNPRO_C */ 1553 for (i = 0; i < size - 7; i += 4, dp += 4, sa++) { 1554 READ_U8_S32(tab0, tab1, tab0, tab1); 1555 s0 = sa[0]; 1556 dp[0] = t0; 1557 dp[1] = t1; 1558 dp[2] = t2; 1559 dp[3] = t3; 1560 } 1561 1562 READ_U8_S32(tab0, tab1, tab0, tab1); 1563 dp[0] = t0; 1564 dp[1] = t1; 1565 dp[2] = t2; 1566 dp[3] = t3; 1567 dp += 4; 1568 sp = (mlib_u8 *) sa; 1569 i += 4; 1570 1571 for (; i < size - 1; i += 2, sp += 2) { 1572 *dp++ = tab0[sp[0]]; 1573 *dp++ = tab1[sp[1]]; 1574 } 1575 1576 if (i < size) 1577 *dp = tab0[(*sp)]; 1578 } 1579 1580 } 1581 else if (csize == 3) { 1582 mlib_s32 i, j; 1583 1584 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 1585 mlib_u32 *sa; 1586 mlib_u32 *tab0 = (mlib_u32 *) table[0]; 1587 mlib_u32 *tab1 = (mlib_u32 *) table[1]; 1588 mlib_u32 *tab2 = (mlib_u32 *) table[2]; 1589 mlib_u32 *tab; 1590 mlib_u32 s0, t0, t1, t2, t3; 1591 mlib_s32 off; 1592 mlib_s32 size = xsize * 3; 1593 mlib_u32 *dp = (mlib_u32 *) dst; 1594 mlib_u8 *sp = (void *)src; 1595 1596 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 1597 1598 if (off == 1) { 1599 *dp++ = tab0[(*sp)]; 1600 tab = tab0; 1601 tab0 = tab1; 1602 tab1 = tab2; 1603 tab2 = tab; 1604 size--; 1605 sp++; 1606 } 1607 else if (off == 2) { 1608 *dp++ = tab0[sp[0]]; 1609 *dp++ = tab1[sp[1]]; 1610 tab = tab2; 1611 tab2 = tab1; 1612 tab1 = tab0; 1613 tab0 = tab; 1614 size -= 2; 1615 sp += 2; 1616 } 1617 else if (off == 3) { 1618 *dp++ = tab0[sp[0]]; 1619 *dp++ = tab1[sp[1]]; 1620 *dp++ = tab2[sp[2]]; 1621 size -= 3; 1622 sp += 3; 1623 } 1624 1625 sa = (mlib_u32 *) sp; 1626 1627 s0 = sa[0]; 1628 sa++; 1629 1630 #ifdef __SUNPRO_C 1631 #pragma pipeloop(0) 1632 #endif /* __SUNPRO_C */ 1633 for (i = 0; i < size - 7; i += 4, dp += 4, sa++) { 1634 READ_U8_S32(tab0, tab1, tab2, tab0); 1635 tab = tab0; 1636 tab0 = tab1; 1637 tab1 = tab2; 1638 tab2 = tab; 1639 s0 = sa[0]; 1640 dp[0] = t0; 1641 dp[1] = t1; 1642 dp[2] = t2; 1643 dp[3] = t3; 1644 } 1645 1646 READ_U8_S32(tab0, tab1, tab2, tab0); 1647 dp[0] = t0; 1648 dp[1] = t1; 1649 dp[2] = t2; 1650 dp[3] = t3; 1651 dp += 4; 1652 sp = (mlib_u8 *) sa; 1653 i += 4; 1654 1655 if (i < size) { 1656 *dp++ = tab1[(*sp)]; 1657 i++; 1658 sp++; 1659 } 1660 1661 if (i < size) { 1662 *dp++ = tab2[(*sp)]; 1663 i++; 1664 sp++; 1665 } 1666 1667 if (i < size) { 1668 *dp = tab0[(*sp)]; 1669 } 1670 } 1671 1672 } 1673 else if (csize == 4) { 1674 mlib_s32 i, j; 1675 1676 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 1677 mlib_u32 *sa; 1678 mlib_u32 *tab0 = (mlib_u32 *) table[0]; 1679 mlib_u32 *tab1 = (mlib_u32 *) table[1]; 1680 mlib_u32 *tab2 = (mlib_u32 *) table[2]; 1681 mlib_u32 *tab3 = (mlib_u32 *) table[3]; 1682 mlib_u32 *tab; 1683 mlib_u32 s0, t0, t1, t2, t3; 1684 mlib_s32 off; 1685 mlib_s32 size = xsize * 4; 1686 mlib_u32 *dp = (mlib_u32 *) dst; 1687 mlib_u8 *sp = (void *)src; 1688 1689 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 1690 1691 if (off == 1) { 1692 *dp++ = tab0[(*sp)]; 1693 tab = tab0; 1694 tab0 = tab1; 1695 tab1 = tab2; 1696 tab2 = tab3; 1697 tab3 = tab; 1698 size--; 1699 sp++; 1700 } 1701 else if (off == 2) { 1702 *dp++ = tab0[sp[0]]; 1703 *dp++ = tab1[sp[1]]; 1704 tab = tab0; 1705 tab0 = tab2; 1706 tab2 = tab; 1707 tab = tab1; 1708 tab1 = tab3; 1709 tab3 = tab; 1710 size -= 2; 1711 sp += 2; 1712 } 1713 else if (off == 3) { 1714 *dp++ = tab0[sp[0]]; 1715 *dp++ = tab1[sp[1]]; 1716 *dp++ = tab2[sp[2]]; 1717 tab = tab3; 1718 tab3 = tab2; 1719 tab2 = tab1; 1720 tab1 = tab0; 1721 tab0 = tab; 1722 size -= 3; 1723 sp += 3; 1724 } 1725 1726 sa = (mlib_u32 *) sp; 1727 1728 s0 = sa[0]; 1729 sa++; 1730 1731 #ifdef __SUNPRO_C 1732 #pragma pipeloop(0) 1733 #endif /* __SUNPRO_C */ 1734 for (i = 0; i < size - 7; i += 4, dp += 4, sa++) { 1735 READ_U8_S32(tab0, tab1, tab2, tab3); 1736 s0 = sa[0]; 1737 dp[0] = t0; 1738 dp[1] = t1; 1739 dp[2] = t2; 1740 dp[3] = t3; 1741 } 1742 1743 READ_U8_S32(tab0, tab1, tab2, tab3); 1744 dp[0] = t0; 1745 dp[1] = t1; 1746 dp[2] = t2; 1747 dp[3] = t3; 1748 dp += 4; 1749 sp = (mlib_u8 *) sa; 1750 i += 4; 1751 1752 if (i < size) { 1753 *dp++ = tab0[(*sp)]; 1754 i++; 1755 sp++; 1756 } 1757 1758 if (i < size) { 1759 *dp++ = tab1[(*sp)]; 1760 i++; 1761 sp++; 1762 } 1763 1764 if (i < size) { 1765 *dp = tab2[(*sp)]; 1766 } 1767 } 1768 } 1769 } 1770 1771 /***************************************************************/ 1772 void mlib_c_ImageLookUp_S16_S32(const mlib_s16 *src, 1773 mlib_s32 slb, 1774 mlib_s32 *dst, 1775 mlib_s32 dlb, 1776 mlib_s32 xsize, 1777 mlib_s32 ysize, 1778 mlib_s32 csize, 1779 const mlib_s32 **table) 1780 { 1781 const mlib_s32 *table_base[4]; 1782 mlib_s32 c; 1783 1784 for (c = 0; c < csize; c++) { 1785 table_base[c] = &table[c][32768]; 1786 } 1787 1788 MLIB_C_IMAGELOOKUP(mlib_s32, mlib_s16, table_base); 1789 } 1790 1791 /***************************************************************/ 1792 void mlib_c_ImageLookUp_U16_S32(const mlib_u16 *src, 1793 mlib_s32 slb, 1794 mlib_s32 *dst, 1795 mlib_s32 dlb, 1796 mlib_s32 xsize, 1797 mlib_s32 ysize, 1798 mlib_s32 csize, 1799 const mlib_s32 **table) 1800 { 1801 const mlib_s32 *table_base[4]; 1802 mlib_s32 c; 1803 1804 for (c = 0; c < csize; c++) { 1805 table_base[c] = &table[c][0]; 1806 } 1807 1808 MLIB_C_IMAGELOOKUP(mlib_s32, mlib_u16, table_base); 1809 } 1810 1811 /***************************************************************/ 1812 void mlib_c_ImageLookUp_S32_S32(const mlib_s32 *src, 1813 mlib_s32 slb, 1814 mlib_s32 *dst, 1815 mlib_s32 dlb, 1816 mlib_s32 xsize, 1817 mlib_s32 ysize, 1818 mlib_s32 csize, 1819 const mlib_s32 **table) 1820 { 1821 const mlib_s32 *table_base[4]; 1822 mlib_s32 c; 1823 1824 for (c = 0; c < csize; c++) { 1825 table_base[c] = &table[c][TABLE_SHIFT_S32]; 1826 } 1827 1828 MLIB_C_IMAGELOOKUP(mlib_s32, mlib_s32, table_base); 1829 } 1830 1831 /***************************************************************/ 1832 void mlib_c_ImageLookUpSI_U8_U8(const mlib_u8 *src, 1833 mlib_s32 slb, 1834 mlib_u8 *dst, 1835 mlib_s32 dlb, 1836 mlib_s32 xsize, 1837 mlib_s32 ysize, 1838 mlib_s32 csize, 1839 const mlib_u8 **table) 1840 { 1841 1842 if ((xsize < 8) || ((xsize * ysize) < 250)) { 1843 MLIB_C_IMAGELOOKUPSI(mlib_u8, mlib_u8, table); 1844 } 1845 else if (csize == 2) { 1846 1847 mlib_u16 tab[256]; 1848 const mlib_u8 *tab0 = table[0]; 1849 const mlib_u8 *tab1 = table[1]; 1850 mlib_s32 i, j, s0, s1, s2; 1851 1852 s0 = tab0[0]; 1853 s1 = tab1[0]; 1854 for (i = 1; i < 256; i++) { 1855 #ifdef _LITTLE_ENDIAN 1856 s2 = (s1 << 8) + s0; 1857 #else 1858 s2 = (s0 << 8) + s1; 1859 #endif /* _LITTLE_ENDIAN */ 1860 s0 = tab0[i]; 1861 s1 = tab1[i]; 1862 tab[i - 1] = (mlib_u16) s2; 1863 } 1864 1865 #ifdef _LITTLE_ENDIAN 1866 s2 = (s1 << 8) + s0; 1867 #else 1868 s2 = (s0 << 8) + s1; 1869 #endif /* _LITTLE_ENDIAN */ 1870 tab[255] = (mlib_u16) s2; 1871 1872 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 1873 mlib_s32 *da; 1874 mlib_u8 *dp = dst; 1875 mlib_u8 *sa = (void *)src; 1876 mlib_s32 s0, t0, s1, t1, t, t2, off; 1877 mlib_s32 size = xsize; 1878 1879 if (((mlib_addr) dp & 1) == 0) { 1880 1881 if (((mlib_addr) dp & 3) != 0) { 1882 *((mlib_u16 *) dp) = tab[sa[0]]; 1883 sa++; 1884 size--; 1885 dp += 2; 1886 } 1887 1888 da = (mlib_s32 *) dp; 1889 1890 s0 = sa[0]; 1891 s1 = sa[1]; 1892 sa += 2; 1893 1894 #ifdef __SUNPRO_C 1895 #pragma pipeloop(0) 1896 #endif /* __SUNPRO_C */ 1897 for (i = 0; i < size - 3; i += 2, da++, sa += 2) { 1898 t0 = tab[s0]; 1899 t1 = tab[s1]; 1900 #ifdef _LITTLE_ENDIAN 1901 t = (t1 << 16) + t0; 1902 #else 1903 t = (t0 << 16) + t1; 1904 #endif /* _LITTLE_ENDIAN */ 1905 s0 = sa[0]; 1906 s1 = sa[1]; 1907 da[0] = t; 1908 } 1909 1910 t0 = tab[s0]; 1911 t1 = tab[s1]; 1912 #ifdef _LITTLE_ENDIAN 1913 t = (t1 << 16) + t0; 1914 #else 1915 t = (t0 << 16) + t1; 1916 #endif /* _LITTLE_ENDIAN */ 1917 da[0] = t; 1918 da++; 1919 1920 if (size & 1) 1921 *((mlib_u16 *) da) = tab[sa[0]]; 1922 1923 } 1924 else { 1925 1926 off = (mlib_s32) (4 - ((mlib_addr) dp & 3)); 1927 1928 if (off > 1) { 1929 t0 = tab[sa[0]]; 1930 #ifdef _LITTLE_ENDIAN 1931 dp[1] = (t0 >> 8); 1932 dp[0] = t0; 1933 #else 1934 dp[0] = (t0 >> 8); 1935 dp[1] = t0; 1936 #endif /* _LITTLE_ENDIAN */ 1937 sa++; 1938 size--; 1939 dp += 2; 1940 } 1941 1942 t0 = tab[sa[0]]; 1943 sa++; 1944 #ifdef _LITTLE_ENDIAN 1945 *dp++ = t0; 1946 #else 1947 *dp++ = (t0 >> 8); 1948 #endif /* _LITTLE_ENDIAN */ 1949 1950 da = (mlib_s32 *) dp; 1951 1952 s0 = sa[0]; 1953 s1 = sa[1]; 1954 sa += 2; 1955 1956 #ifdef __SUNPRO_C 1957 #pragma pipeloop(0) 1958 #endif /* __SUNPRO_C */ 1959 for (i = 0; i < size - 4; i += 2, da++, sa += 2) { 1960 t1 = tab[s0]; 1961 t2 = tab[s1]; 1962 #ifdef _LITTLE_ENDIAN 1963 t = (t0 >> 8) + (t1 << 8) + (t2 << 24); 1964 #else 1965 t = (t0 << 24) + (t1 << 8) + (t2 >> 8); 1966 #endif /* _LITTLE_ENDIAN */ 1967 t0 = t2; 1968 s0 = sa[0]; 1969 s1 = sa[1]; 1970 da[0] = t; 1971 } 1972 1973 t1 = tab[s0]; 1974 t2 = tab[s1]; 1975 #ifdef _LITTLE_ENDIAN 1976 t = (t0 >> 8) + (t1 << 8) + (t2 << 24); 1977 #else 1978 t = (t0 << 24) + (t1 << 8) + (t2 >> 8); 1979 #endif /* _LITTLE_ENDIAN */ 1980 da[0] = t; 1981 da++; 1982 dp = (mlib_u8 *) da; 1983 #ifdef _LITTLE_ENDIAN 1984 dp[0] = (t2 >> 8); 1985 #else 1986 dp[0] = t2; 1987 #endif /* _LITTLE_ENDIAN */ 1988 1989 if ((size & 1) == 0) { 1990 t0 = tab[sa[0]]; 1991 #ifdef _LITTLE_ENDIAN 1992 dp[2] = (t0 >> 8); 1993 dp[1] = t0; 1994 #else 1995 dp[1] = (t0 >> 8); 1996 dp[2] = t0; 1997 #endif /* _LITTLE_ENDIAN */ 1998 } 1999 } 2000 } 2001 2002 } 2003 else if (csize == 3) { 2004 mlib_u32 tab[256]; 2005 const mlib_u8 *tab0 = table[0]; 2006 const mlib_u8 *tab1 = table[1]; 2007 const mlib_u8 *tab2 = table[2]; 2008 mlib_s32 i, j; 2009 mlib_u32 s0, s1, s2, s3; 2010 2011 s0 = tab0[0]; 2012 s1 = tab1[0]; 2013 s2 = tab2[0]; 2014 for (i = 1; i < 256; i++) { 2015 #ifdef _LITTLE_ENDIAN 2016 s3 = (s2 << 24) + (s1 << 16) + (s0 << 8); 2017 #else 2018 s3 = (s0 << 16) + (s1 << 8) + s2; 2019 #endif /* _LITTLE_ENDIAN */ 2020 s0 = tab0[i]; 2021 s1 = tab1[i]; 2022 s2 = tab2[i]; 2023 tab[i - 1] = s3; 2024 } 2025 2026 #ifdef _LITTLE_ENDIAN 2027 s3 = (s2 << 24) + (s1 << 16) + (s0 << 8); 2028 #else 2029 s3 = (s0 << 16) + (s1 << 8) + s2; 2030 #endif /* _LITTLE_ENDIAN */ 2031 tab[255] = s3; 2032 2033 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 2034 mlib_u32 *da; 2035 mlib_u8 *dp = dst; 2036 mlib_u8 *sa = (void *)src, *ptr; 2037 mlib_u32 s0, s1, t0, t1; 2038 mlib_u32 res1, res2; 2039 mlib_s32 size = xsize, off; 2040 2041 off = (mlib_s32) ((mlib_addr) dp & 3); 2042 2043 #ifdef __SUNPRO_C 2044 #pragma pipeloop(0) 2045 #endif /* __SUNPRO_C */ 2046 for (i = 0; i < off; i++) { 2047 ptr = (mlib_u8 *) (tab + sa[0]); 2048 dp[0] = ptr[1]; 2049 dp[1] = ptr[2]; 2050 dp[2] = ptr[3]; 2051 dp += 3; 2052 sa++; 2053 } 2054 2055 size -= off; 2056 da = (mlib_u32 *) dp; 2057 s0 = sa[0]; 2058 s1 = sa[1]; 2059 sa += 2; 2060 2061 #ifdef __SUNPRO_C 2062 #pragma pipeloop(0) 2063 #endif /* __SUNPRO_C */ 2064 for (i = 0; i < size - 7; i += 4, da += 3, sa += 4) { 2065 t0 = tab[s0]; 2066 t1 = tab[s1]; 2067 #ifdef _LITTLE_ENDIAN 2068 da[0] = (t0 >> 8) + (t1 << 16); 2069 res2 = (t1 >> 16); 2070 #else 2071 da[0] = (t0 << 8) + (t1 >> 16); 2072 res2 = (t1 << 16); 2073 #endif /* _LITTLE_ENDIAN */ 2074 s0 = sa[0]; 2075 s1 = sa[1]; 2076 t0 = tab[s0]; 2077 t1 = tab[s1]; 2078 #ifdef _LITTLE_ENDIAN 2079 res2 += (t0 << 8); 2080 res1 = (t0 >> 24) + t1; 2081 #else 2082 res2 += (t0 >> 8); 2083 res1 = (t0 << 24) + t1; 2084 #endif /* _LITTLE_ENDIAN */ 2085 s0 = sa[2]; 2086 s1 = sa[3]; 2087 da[1] = res2; 2088 da[2] = res1; 2089 } 2090 2091 t0 = tab[s0]; 2092 t1 = tab[s1]; 2093 #ifdef _LITTLE_ENDIAN 2094 da[0] = (t0 >> 8) + (t1 << 16); 2095 res2 = (t1 >> 16); 2096 #else 2097 da[0] = (t0 << 8) + (t1 >> 16); 2098 res2 = (t1 << 16); 2099 #endif /* _LITTLE_ENDIAN */ 2100 s0 = sa[0]; 2101 s1 = sa[1]; 2102 t0 = tab[s0]; 2103 t1 = tab[s1]; 2104 #ifdef _LITTLE_ENDIAN 2105 res2 += (t0 << 8); 2106 res1 = (t0 >> 24) + t1; 2107 #else 2108 res2 += (t0 >> 8); 2109 res1 = (t0 << 24) + t1; 2110 #endif /* _LITTLE_ENDIAN */ 2111 da[1] = res2; 2112 da[2] = res1; 2113 da += 3; 2114 sa += 2; 2115 dp = (mlib_u8 *) da; 2116 i += 4; 2117 2118 #ifdef __SUNPRO_C 2119 #pragma pipeloop(0) 2120 #endif /* __SUNPRO_C */ 2121 for (; i < size; i++) { 2122 ptr = (mlib_u8 *) (tab + sa[0]); 2123 dp[0] = ptr[1]; 2124 dp[1] = ptr[2]; 2125 dp[2] = ptr[3]; 2126 dp += 3; 2127 sa++; 2128 } 2129 } 2130 2131 } 2132 else if (csize == 4) { 2133 mlib_u32 tab[256]; 2134 const mlib_u8 *tab0 = table[0]; 2135 const mlib_u8 *tab1 = table[1]; 2136 const mlib_u8 *tab2 = table[2]; 2137 const mlib_u8 *tab3 = table[3]; 2138 mlib_s32 i, j; 2139 mlib_u32 s0, s1, s2, s3, s4; 2140 2141 s0 = tab0[0]; 2142 s1 = tab1[0]; 2143 s2 = tab2[0]; 2144 s3 = tab3[0]; 2145 for (i = 1; i < 256; i++) { 2146 #ifdef _LITTLE_ENDIAN 2147 s4 = (s3 << 24) + (s2 << 16) + (s1 << 8) + s0; 2148 #else 2149 s4 = (s0 << 24) + (s1 << 16) + (s2 << 8) + s3; 2150 #endif /* _LITTLE_ENDIAN */ 2151 s0 = tab0[i]; 2152 s1 = tab1[i]; 2153 s2 = tab2[i]; 2154 s3 = tab3[i]; 2155 tab[i - 1] = s4; 2156 } 2157 2158 #ifdef _LITTLE_ENDIAN 2159 s4 = (s3 << 24) + (s2 << 16) + (s1 << 8) + s0; 2160 #else 2161 s4 = (s0 << 24) + (s1 << 16) + (s2 << 8) + s3; 2162 #endif /* _LITTLE_ENDIAN */ 2163 tab[255] = s4; 2164 2165 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 2166 mlib_u32 *da; 2167 mlib_u8 *dp = dst; 2168 mlib_u8 *sa = (void *)src; 2169 mlib_u32 s0, t0, s1, t1, t2; 2170 mlib_s32 size = xsize, off; 2171 mlib_u32 shift, shift1, res1, res2; 2172 2173 if (((mlib_addr) dp & 3) == 0) { 2174 2175 da = (mlib_u32 *) dp; 2176 2177 s0 = sa[0]; 2178 s1 = sa[1]; 2179 sa += 2; 2180 2181 #ifdef __SUNPRO_C 2182 #pragma pipeloop(0) 2183 #endif /* __SUNPRO_C */ 2184 for (i = 0; i < size - 3; i += 2, da += 2, sa += 2) { 2185 t0 = tab[s0]; 2186 t1 = tab[s1]; 2187 s0 = sa[0]; 2188 s1 = sa[1]; 2189 da[0] = t0; 2190 da[1] = t1; 2191 } 2192 2193 t0 = tab[s0]; 2194 t1 = tab[s1]; 2195 da[0] = t0; 2196 da[1] = t1; 2197 2198 if (size & 1) 2199 da[2] = tab[sa[0]]; 2200 2201 } 2202 else { 2203 2204 off = (mlib_s32) (4 - ((mlib_addr) dp & 3)); 2205 shift = 8 * off; 2206 shift1 = 32 - shift; 2207 2208 for (i = 0; i < off; i++) { 2209 dp[i] = table[i][sa[0]]; 2210 } 2211 2212 dp += i; 2213 t0 = tab[sa[0]]; 2214 sa++; 2215 2216 da = (mlib_u32 *) dp; 2217 2218 s0 = sa[0]; 2219 s1 = sa[1]; 2220 sa += 2; 2221 2222 #ifdef __SUNPRO_C 2223 #pragma pipeloop(0) 2224 #endif /* __SUNPRO_C */ 2225 for (i = 0; i < size - 4; i += 2, da += 2, sa += 2) { 2226 t1 = tab[s0]; 2227 t2 = tab[s1]; 2228 #ifdef _LITTLE_ENDIAN 2229 res1 = (t0 >> shift) + (t1 << shift1); 2230 res2 = (t1 >> shift) + (t2 << shift1); 2231 #else 2232 res1 = (t0 << shift) + (t1 >> shift1); 2233 res2 = (t1 << shift) + (t2 >> shift1); 2234 #endif /* _LITTLE_ENDIAN */ 2235 t0 = t2; 2236 s0 = sa[0]; 2237 s1 = sa[1]; 2238 da[0] = res1; 2239 da[1] = res2; 2240 } 2241 2242 t1 = tab[s0]; 2243 t2 = tab[s1]; 2244 #ifdef _LITTLE_ENDIAN 2245 res1 = (t0 >> shift) + (t1 << shift1); 2246 res2 = (t1 >> shift) + (t2 << shift1); 2247 #else 2248 res1 = (t0 << shift) + (t1 >> shift1); 2249 res2 = (t1 << shift) + (t2 >> shift1); 2250 #endif /* _LITTLE_ENDIAN */ 2251 da[0] = res1; 2252 da[1] = res2; 2253 #ifdef _LITTLE_ENDIAN 2254 t0 = (da[2] >> shift1); 2255 da[2] = (t2 >> shift) + (t0 << shift1); 2256 #else 2257 t0 = (da[2] << shift1); 2258 da[2] = (t2 << shift) + (t0 >> shift1); 2259 #endif /* _LITTLE_ENDIAN */ 2260 da += 2; 2261 dp = (mlib_u8 *) da + (4 - off); 2262 2263 if ((size & 1) == 0) { 2264 t0 = tab[sa[0]]; 2265 #ifdef _LITTLE_ENDIAN 2266 dp[3] = (mlib_u8) (t0 >> 24); 2267 dp[2] = (mlib_u8) (t0 >> 16); 2268 dp[1] = (mlib_u8) (t0 >> 8); 2269 dp[0] = (mlib_u8) t0; 2270 #else 2271 dp[0] = (mlib_u8) (t0 >> 24); 2272 dp[1] = (mlib_u8) (t0 >> 16); 2273 dp[2] = (mlib_u8) (t0 >> 8); 2274 dp[3] = (mlib_u8) t0; 2275 #endif /* _LITTLE_ENDIAN */ 2276 } 2277 } 2278 } 2279 } 2280 } 2281 2282 /***************************************************************/ 2283 2284 #ifdef _MSC_VER 2285 #pragma optimize("", off) 2286 #endif /* _MSC_VER */ 2287 2288 void mlib_c_ImageLookUpSI_S16_U8(const mlib_s16 *src, 2289 mlib_s32 slb, 2290 mlib_u8 *dst, 2291 mlib_s32 dlb, 2292 mlib_s32 xsize, 2293 mlib_s32 ysize, 2294 mlib_s32 csize, 2295 const mlib_u8 **table) 2296 { 2297 const mlib_u8 *table_base[4]; 2298 mlib_s32 c; 2299 2300 for (c = 0; c < csize; c++) { 2301 table_base[c] = &table[c][32768]; 2302 } 2303 2304 if ((xsize < 8) || (csize == 2)) { 2305 MLIB_C_IMAGELOOKUPSI(mlib_u8, mlib_s16, table_base); 2306 } 2307 else if (csize == 3) { 2308 mlib_s32 i, j; 2309 2310 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 2311 mlib_u32 *da; 2312 mlib_u8 *dp = dst; 2313 mlib_s16 *sa = (void *)src; 2314 const mlib_u8 *tab0 = table_base[0]; 2315 const mlib_u8 *tab1 = table_base[1]; 2316 const mlib_u8 *tab2 = table_base[2]; 2317 mlib_s32 s0, s1; 2318 mlib_u32 t0, t1, t2, t3, t4, t5; 2319 mlib_u32 res1, res2; 2320 mlib_s32 size = xsize, off; 2321 2322 off = (mlib_s32) ((mlib_addr) dp & 3); 2323 2324 #ifdef __SUNPRO_C 2325 #pragma pipeloop(0) 2326 #endif /* __SUNPRO_C */ 2327 for (i = 0; i < off; i++) { 2328 s0 = *sa++; 2329 dp[0] = tab0[s0]; 2330 dp[1] = tab1[s0]; 2331 dp[2] = tab2[s0]; 2332 dp += 3; 2333 } 2334 2335 size -= off; 2336 da = (mlib_u32 *) dp; 2337 s0 = sa[0]; 2338 s1 = sa[1]; 2339 sa += 2; 2340 2341 #ifdef __SUNPRO_C 2342 #pragma pipeloop(0) 2343 #endif /* __SUNPRO_C */ 2344 for (i = 0; i < size - 7; i += 4, da += 3, sa += 4) { 2345 t0 = tab0[s0]; 2346 t1 = tab1[s0]; 2347 t2 = tab2[s0]; 2348 t3 = tab0[s1]; 2349 t4 = tab1[s1]; 2350 t5 = tab2[s1]; 2351 #ifdef _LITTLE_ENDIAN 2352 da[0] = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2353 res2 = (t5 << 8) + t4; 2354 #else 2355 da[0] = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2356 res2 = (t4 << 24) + (t5 << 16); 2357 #endif /* _LITTLE_ENDIAN */ 2358 s0 = sa[0]; 2359 s1 = sa[1]; 2360 t0 = tab0[s0]; 2361 t1 = tab1[s0]; 2362 t2 = tab2[s0]; 2363 t3 = tab0[s1]; 2364 t4 = tab1[s1]; 2365 t5 = tab2[s1]; 2366 #ifdef _LITTLE_ENDIAN 2367 res2 += ((t1 << 24) + (t0 << 16)); 2368 res1 = (t5 << 24) + (t4 << 16) + (t3 << 8) + t2; 2369 #else 2370 res2 += ((t0 << 8) + t1); 2371 res1 = (t2 << 24) + (t3 << 16) + (t4 << 8) + t5; 2372 #endif /* _LITTLE_ENDIAN */ 2373 s0 = sa[2]; 2374 s1 = sa[3]; 2375 da[1] = res2; 2376 da[2] = res1; 2377 } 2378 2379 t0 = tab0[s0]; 2380 t1 = tab1[s0]; 2381 t2 = tab2[s0]; 2382 t3 = tab0[s1]; 2383 t4 = tab1[s1]; 2384 t5 = tab2[s1]; 2385 #ifdef _LITTLE_ENDIAN 2386 da[0] = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2387 res2 = (t5 << 8) + t4; 2388 #else 2389 da[0] = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2390 res2 = (t4 << 24) + (t5 << 16); 2391 #endif /* _LITTLE_ENDIAN */ 2392 s0 = sa[0]; 2393 s1 = sa[1]; 2394 t0 = tab0[s0]; 2395 t1 = tab1[s0]; 2396 t2 = tab2[s0]; 2397 t3 = tab0[s1]; 2398 t4 = tab1[s1]; 2399 t5 = tab2[s1]; 2400 #ifdef _LITTLE_ENDIAN 2401 res2 += ((t1 << 24) + (t0 << 16)); 2402 res1 = (t5 << 24) + (t4 << 16) + (t3 << 8) + t2; 2403 #else 2404 res2 += ((t0 << 8) + t1); 2405 res1 = (t2 << 24) + (t3 << 16) + (t4 << 8) + t5; 2406 #endif /* _LITTLE_ENDIAN */ 2407 da[1] = res2; 2408 da[2] = res1; 2409 da += 3; 2410 sa += 2; 2411 dp = (mlib_u8 *) da; 2412 i += 4; 2413 2414 #ifdef __SUNPRO_C 2415 #pragma pipeloop(0) 2416 #endif /* __SUNPRO_C */ 2417 for (; i < size; i++) { 2418 s0 = *sa++; 2419 dp[0] = tab0[s0]; 2420 dp[1] = tab1[s0]; 2421 dp[2] = tab2[s0]; 2422 dp += 3; 2423 } 2424 } 2425 2426 } 2427 else if (csize == 4) { 2428 mlib_s32 i, j; 2429 2430 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 2431 mlib_u32 *da; 2432 mlib_u8 *dp = dst; 2433 mlib_s16 *sa = (void *)src; 2434 const mlib_u8 *tab0 = table_base[0]; 2435 const mlib_u8 *tab1 = table_base[1]; 2436 const mlib_u8 *tab2 = table_base[2]; 2437 const mlib_u8 *tab3 = table_base[3]; 2438 mlib_s32 s0; 2439 mlib_u32 t0, t1, t2, t3; 2440 mlib_s32 size = xsize, off; 2441 mlib_u32 shift, shift1, res1, res2, res; 2442 2443 if (((mlib_addr) dp & 3) == 0) { 2444 2445 da = (mlib_u32 *) dp; 2446 2447 s0 = sa[0]; 2448 sa++; 2449 2450 #ifdef __SUNPRO_C 2451 #pragma pipeloop(0) 2452 #endif /* __SUNPRO_C */ 2453 for (i = 0; i < size - 1; i++, da++, sa++) { 2454 t0 = tab0[s0]; 2455 t1 = tab1[s0]; 2456 t2 = tab2[s0]; 2457 t3 = tab3[s0]; 2458 #ifdef _LITTLE_ENDIAN 2459 res = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2460 #else 2461 res = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2462 #endif /* _LITTLE_ENDIAN */ 2463 s0 = sa[0]; 2464 da[0] = res; 2465 } 2466 2467 t0 = tab0[s0]; 2468 t1 = tab1[s0]; 2469 t2 = tab2[s0]; 2470 t3 = tab3[s0]; 2471 #ifdef _LITTLE_ENDIAN 2472 res = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2473 #else 2474 res = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2475 #endif /* _LITTLE_ENDIAN */ 2476 da[0] = res; 2477 2478 } 2479 else { 2480 2481 off = (mlib_s32) (4 - ((mlib_addr) dp & 3)); 2482 shift = 8 * off; 2483 shift1 = 32 - shift; 2484 2485 s0 = *sa++; 2486 2487 for (i = 0; i < off; i++) { 2488 dp[i] = table_base[i][s0]; 2489 } 2490 2491 dp += i; 2492 da = (mlib_u32 *) dp; 2493 2494 t0 = tab0[s0]; 2495 t1 = tab1[s0]; 2496 t2 = tab2[s0]; 2497 t3 = tab3[s0]; 2498 2499 #ifdef _LITTLE_ENDIAN 2500 res1 = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2501 #else 2502 res1 = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2503 #endif /* _LITTLE_ENDIAN */ 2504 2505 s0 = sa[0]; 2506 sa++; 2507 2508 #ifdef __SUNPRO_C 2509 #pragma pipeloop(0) 2510 #endif /* __SUNPRO_C */ 2511 for (i = 0; i < size - 2; i++, da++, sa++) { 2512 t0 = tab0[s0]; 2513 t1 = tab1[s0]; 2514 t2 = tab2[s0]; 2515 t3 = tab3[s0]; 2516 #ifdef _LITTLE_ENDIAN 2517 res2 = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2518 res = (res1 >> shift) + (res2 << shift1); 2519 #else 2520 res2 = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2521 res = (res1 << shift) + (res2 >> shift1); 2522 #endif /* _LITTLE_ENDIAN */ 2523 res1 = res2; 2524 s0 = sa[0]; 2525 da[0] = res; 2526 } 2527 2528 t0 = tab0[s0]; 2529 t1 = tab1[s0]; 2530 t2 = tab2[s0]; 2531 t3 = tab3[s0]; 2532 #ifdef _LITTLE_ENDIAN 2533 res2 = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2534 res = (res1 >> shift) + (res2 << shift1); 2535 #else 2536 res2 = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2537 res = (res1 << shift) + (res2 >> shift1); 2538 #endif /* _LITTLE_ENDIAN */ 2539 da[0] = res; 2540 #ifdef _LITTLE_ENDIAN 2541 res1 = (da[1] >> shift1); 2542 da[1] = (res2 >> shift) + (res1 << shift1); 2543 #else 2544 res1 = (da[1] << shift1); 2545 da[1] = (res2 << shift) + (res1 >> shift1); 2546 #endif /* _LITTLE_ENDIAN */ 2547 } 2548 } 2549 } 2550 } 2551 2552 #ifdef _MSC_VER 2553 #pragma optimize("", on) 2554 #endif /* _MSC_VER */ 2555 2556 /***************************************************************/ 2557 void mlib_c_ImageLookUpSI_U16_U8(const mlib_u16 *src, 2558 mlib_s32 slb, 2559 mlib_u8 *dst, 2560 mlib_s32 dlb, 2561 mlib_s32 xsize, 2562 mlib_s32 ysize, 2563 mlib_s32 csize, 2564 const mlib_u8 **table) 2565 { 2566 const mlib_u8 *table_base[4]; 2567 mlib_s32 c; 2568 2569 for (c = 0; c < csize; c++) { 2570 table_base[c] = &table[c][0]; 2571 } 2572 2573 if ((xsize < 8) || (csize == 2)) { 2574 MLIB_C_IMAGELOOKUPSI(mlib_u8, mlib_u16, table_base); 2575 } 2576 else if (csize == 3) { 2577 mlib_s32 i, j; 2578 2579 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 2580 mlib_u32 *da; 2581 mlib_u8 *dp = dst; 2582 mlib_u16 *sa = (void *)src; 2583 const mlib_u8 *tab0 = table_base[0]; 2584 const mlib_u8 *tab1 = table_base[1]; 2585 const mlib_u8 *tab2 = table_base[2]; 2586 mlib_s32 s0, s1; 2587 mlib_u32 t0, t1, t2, t3, t4, t5; 2588 mlib_u32 res1, res2; 2589 mlib_s32 size = xsize, off; 2590 2591 off = (mlib_s32) ((mlib_addr) dp & 3); 2592 2593 #ifdef __SUNPRO_C 2594 #pragma pipeloop(0) 2595 #endif /* __SUNPRO_C */ 2596 for (i = 0; i < off; i++) { 2597 s0 = *sa++; 2598 dp[0] = tab0[s0]; 2599 dp[1] = tab1[s0]; 2600 dp[2] = tab2[s0]; 2601 dp += 3; 2602 } 2603 2604 size -= off; 2605 da = (mlib_u32 *) dp; 2606 s0 = sa[0]; 2607 s1 = sa[1]; 2608 sa += 2; 2609 2610 #ifdef __SUNPRO_C 2611 #pragma pipeloop(0) 2612 #endif /* __SUNPRO_C */ 2613 for (i = 0; i < size - 7; i += 4, da += 3, sa += 4) { 2614 t0 = tab0[s0]; 2615 t1 = tab1[s0]; 2616 t2 = tab2[s0]; 2617 t3 = tab0[s1]; 2618 t4 = tab1[s1]; 2619 t5 = tab2[s1]; 2620 #ifdef _LITTLE_ENDIAN 2621 da[0] = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2622 res2 = (t5 << 8) + t4; 2623 #else 2624 da[0] = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2625 res2 = (t4 << 24) + (t5 << 16); 2626 #endif /* _LITTLE_ENDIAN */ 2627 s0 = sa[0]; 2628 s1 = sa[1]; 2629 t0 = tab0[s0]; 2630 t1 = tab1[s0]; 2631 t2 = tab2[s0]; 2632 t3 = tab0[s1]; 2633 t4 = tab1[s1]; 2634 t5 = tab2[s1]; 2635 #ifdef _LITTLE_ENDIAN 2636 res2 += ((t1 << 24) + (t0 << 16)); 2637 res1 = (t5 << 24) + (t4 << 16) + (t3 << 8) + t2; 2638 #else 2639 res2 += ((t0 << 8) + t1); 2640 res1 = (t2 << 24) + (t3 << 16) + (t4 << 8) + t5; 2641 #endif /* _LITTLE_ENDIAN */ 2642 s0 = sa[2]; 2643 s1 = sa[3]; 2644 da[1] = res2; 2645 da[2] = res1; 2646 } 2647 2648 t0 = tab0[s0]; 2649 t1 = tab1[s0]; 2650 t2 = tab2[s0]; 2651 t3 = tab0[s1]; 2652 t4 = tab1[s1]; 2653 t5 = tab2[s1]; 2654 #ifdef _LITTLE_ENDIAN 2655 da[0] = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2656 res2 = (t5 << 8) + t4; 2657 #else 2658 da[0] = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2659 res2 = (t4 << 24) + (t5 << 16); 2660 #endif /* _LITTLE_ENDIAN */ 2661 s0 = sa[0]; 2662 s1 = sa[1]; 2663 t0 = tab0[s0]; 2664 t1 = tab1[s0]; 2665 t2 = tab2[s0]; 2666 t3 = tab0[s1]; 2667 t4 = tab1[s1]; 2668 t5 = tab2[s1]; 2669 #ifdef _LITTLE_ENDIAN 2670 res2 += ((t1 << 24) + (t0 << 16)); 2671 res1 = (t5 << 24) + (t4 << 16) + (t3 << 8) + t2; 2672 #else 2673 res2 += ((t0 << 8) + t1); 2674 res1 = (t2 << 24) + (t3 << 16) + (t4 << 8) + t5; 2675 #endif /* _LITTLE_ENDIAN */ 2676 da[1] = res2; 2677 da[2] = res1; 2678 da += 3; 2679 sa += 2; 2680 dp = (mlib_u8 *) da; 2681 i += 4; 2682 2683 #ifdef __SUNPRO_C 2684 #pragma pipeloop(0) 2685 #endif /* __SUNPRO_C */ 2686 for (; i < size; i++) { 2687 s0 = *sa++; 2688 dp[0] = tab0[s0]; 2689 dp[1] = tab1[s0]; 2690 dp[2] = tab2[s0]; 2691 dp += 3; 2692 } 2693 } 2694 2695 } 2696 else if (csize == 4) { 2697 mlib_s32 i, j; 2698 2699 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 2700 mlib_u32 *da; 2701 mlib_u8 *dp = dst; 2702 mlib_u16 *sa = (void *)src; 2703 const mlib_u8 *tab0 = table_base[0]; 2704 const mlib_u8 *tab1 = table_base[1]; 2705 const mlib_u8 *tab2 = table_base[2]; 2706 const mlib_u8 *tab3 = table_base[3]; 2707 mlib_s32 s0; 2708 mlib_u32 t0, t1, t2, t3; 2709 mlib_s32 size = xsize, off; 2710 mlib_u32 shift, shift1, res1, res2, res; 2711 2712 if (((mlib_addr) dp & 3) == 0) { 2713 2714 da = (mlib_u32 *) dp; 2715 2716 s0 = sa[0]; 2717 sa++; 2718 2719 #ifdef __SUNPRO_C 2720 #pragma pipeloop(0) 2721 #endif /* __SUNPRO_C */ 2722 for (i = 0; i < size - 1; i++, da++, sa++) { 2723 t0 = tab0[s0]; 2724 t1 = tab1[s0]; 2725 t2 = tab2[s0]; 2726 t3 = tab3[s0]; 2727 #ifdef _LITTLE_ENDIAN 2728 res = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2729 #else 2730 res = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2731 #endif /* _LITTLE_ENDIAN */ 2732 s0 = sa[0]; 2733 da[0] = res; 2734 } 2735 2736 t0 = tab0[s0]; 2737 t1 = tab1[s0]; 2738 t2 = tab2[s0]; 2739 t3 = tab3[s0]; 2740 #ifdef _LITTLE_ENDIAN 2741 res = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2742 #else 2743 res = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2744 #endif /* _LITTLE_ENDIAN */ 2745 da[0] = res; 2746 2747 } 2748 else { 2749 2750 off = (mlib_s32) (4 - ((mlib_addr) dp & 3)); 2751 shift = 8 * off; 2752 shift1 = 32 - shift; 2753 2754 s0 = *sa++; 2755 2756 for (i = 0; i < off; i++) { 2757 dp[i] = table_base[i][s0]; 2758 } 2759 2760 dp += i; 2761 da = (mlib_u32 *) dp; 2762 2763 t0 = tab0[s0]; 2764 t1 = tab1[s0]; 2765 t2 = tab2[s0]; 2766 t3 = tab3[s0]; 2767 2768 #ifdef _LITTLE_ENDIAN 2769 res1 = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2770 #else 2771 res1 = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2772 #endif /* _LITTLE_ENDIAN */ 2773 2774 s0 = sa[0]; 2775 sa++; 2776 2777 #ifdef __SUNPRO_C 2778 #pragma pipeloop(0) 2779 #endif /* __SUNPRO_C */ 2780 for (i = 0; i < size - 2; i++, da++, sa++) { 2781 t0 = tab0[s0]; 2782 t1 = tab1[s0]; 2783 t2 = tab2[s0]; 2784 t3 = tab3[s0]; 2785 #ifdef _LITTLE_ENDIAN 2786 res2 = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2787 res = (res1 >> shift) + (res2 << shift1); 2788 #else 2789 res2 = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2790 res = (res1 << shift) + (res2 >> shift1); 2791 #endif /* _LITTLE_ENDIAN */ 2792 res1 = res2; 2793 s0 = sa[0]; 2794 da[0] = res; 2795 } 2796 2797 t0 = tab0[s0]; 2798 t1 = tab1[s0]; 2799 t2 = tab2[s0]; 2800 t3 = tab3[s0]; 2801 #ifdef _LITTLE_ENDIAN 2802 res2 = (t3 << 24) + (t2 << 16) + (t1 << 8) + t0; 2803 res = (res1 >> shift) + (res2 << shift1); 2804 #else 2805 res2 = (t0 << 24) + (t1 << 16) + (t2 << 8) + t3; 2806 res = (res1 << shift) + (res2 >> shift1); 2807 #endif /* _LITTLE_ENDIAN */ 2808 da[0] = res; 2809 #ifdef _LITTLE_ENDIAN 2810 res1 = (da[1] >> shift1); 2811 da[1] = (res2 >> shift) + (res1 << shift1); 2812 #else 2813 res1 = (da[1] << shift1); 2814 da[1] = (res2 << shift) + (res1 >> shift1); 2815 #endif /* _LITTLE_ENDIAN */ 2816 } 2817 } 2818 } 2819 } 2820 2821 /***************************************************************/ 2822 void mlib_c_ImageLookUpSI_S32_U8(const mlib_s32 *src, 2823 mlib_s32 slb, 2824 mlib_u8 *dst, 2825 mlib_s32 dlb, 2826 mlib_s32 xsize, 2827 mlib_s32 ysize, 2828 mlib_s32 csize, 2829 const mlib_u8 **table) 2830 { 2831 const mlib_u8 *table_base[4]; 2832 mlib_s32 c; 2833 2834 for (c = 0; c < csize; c++) { 2835 table_base[c] = &table[c][TABLE_SHIFT_S32]; 2836 } 2837 2838 MLIB_C_IMAGELOOKUPSI(mlib_u8, mlib_s32, table_base); 2839 } 2840 2841 /***************************************************************/ 2842 void mlib_c_ImageLookUpSI_U8_S16(const mlib_u8 *src, 2843 mlib_s32 slb, 2844 mlib_s16 *dst, 2845 mlib_s32 dlb, 2846 mlib_s32 xsize, 2847 mlib_s32 ysize, 2848 mlib_s32 csize, 2849 const mlib_s16 **table) 2850 { 2851 2852 if ((xsize < 4) || ((xsize * ysize) < 250)) { 2853 MLIB_C_IMAGELOOKUPSI(mlib_s16, mlib_u8, table); 2854 2855 } 2856 else if (csize == 2) { 2857 mlib_u32 tab[256]; 2858 mlib_u16 *tab0 = (mlib_u16 *) table[0]; 2859 mlib_u16 *tab1 = (mlib_u16 *) table[1]; 2860 mlib_s32 i, j; 2861 mlib_u32 s0, s1, s2; 2862 2863 s0 = tab0[0]; 2864 s1 = tab1[0]; 2865 for (i = 1; i < 256; i++) { 2866 #ifdef _LITTLE_ENDIAN 2867 s2 = (s1 << 16) + s0; 2868 #else 2869 s2 = (s0 << 16) + s1; 2870 #endif /* _LITTLE_ENDIAN */ 2871 s0 = tab0[i]; 2872 s1 = tab1[i]; 2873 tab[i - 1] = s2; 2874 } 2875 2876 #ifdef _LITTLE_ENDIAN 2877 s2 = (s1 << 16) + s0; 2878 #else 2879 s2 = (s0 << 16) + s1; 2880 #endif /* _LITTLE_ENDIAN */ 2881 tab[255] = s2; 2882 2883 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 2884 mlib_u32 *da; 2885 mlib_u16 *dp = (mlib_u16 *) dst; 2886 mlib_u8 *sa = (void *)src; 2887 mlib_u32 s0, t0, s1, t1, t2; 2888 mlib_u32 res1, res2; 2889 mlib_s32 size = xsize; 2890 2891 if (((mlib_addr) dp & 3) == 0) { 2892 2893 da = (mlib_u32 *) dp; 2894 s0 = sa[0]; 2895 s1 = sa[1]; 2896 sa += 2; 2897 2898 #ifdef __SUNPRO_C 2899 #pragma pipeloop(0) 2900 #endif /* __SUNPRO_C */ 2901 for (i = 0; i < size - 3; i += 2, da += 2, sa += 2) { 2902 t0 = tab[s0]; 2903 t1 = tab[s1]; 2904 s0 = sa[0]; 2905 s1 = sa[1]; 2906 da[0] = t0; 2907 da[1] = t1; 2908 } 2909 2910 t0 = tab[s0]; 2911 t1 = tab[s1]; 2912 da[0] = t0; 2913 da[1] = t1; 2914 2915 if (size & 1) 2916 da[2] = tab[sa[0]]; 2917 2918 } 2919 else { 2920 2921 t0 = tab[*sa++]; 2922 #ifdef _LITTLE_ENDIAN 2923 *dp++ = (mlib_u16) (t0); 2924 #else 2925 *dp++ = (mlib_u16) (t0 >> 16); 2926 #endif /* _LITTLE_ENDIAN */ 2927 da = (mlib_u32 *) dp; 2928 s0 = sa[0]; 2929 s1 = sa[1]; 2930 sa += 2; 2931 2932 #ifdef __SUNPRO_C 2933 #pragma pipeloop(0) 2934 #endif /* __SUNPRO_C */ 2935 for (i = 0; i < size - 4; i += 2, da += 2, sa += 2) { 2936 t1 = tab[s0]; 2937 t2 = tab[s1]; 2938 #ifdef _LITTLE_ENDIAN 2939 res1 = (t0 >> 16) + (t1 << 16); 2940 res2 = (t1 >> 16) + (t2 << 16); 2941 #else 2942 res1 = (t0 << 16) + (t1 >> 16); 2943 res2 = (t1 << 16) + (t2 >> 16); 2944 #endif /* _LITTLE_ENDIAN */ 2945 t0 = t2; 2946 s0 = sa[0]; 2947 s1 = sa[1]; 2948 da[0] = res1; 2949 da[1] = res2; 2950 } 2951 2952 t1 = tab[s0]; 2953 t2 = tab[s1]; 2954 #ifdef _LITTLE_ENDIAN 2955 res1 = (t0 >> 16) + (t1 << 16); 2956 res2 = (t1 >> 16) + (t2 << 16); 2957 #else 2958 res1 = (t0 << 16) + (t1 >> 16); 2959 res2 = (t1 << 16) + (t2 >> 16); 2960 #endif /* _LITTLE_ENDIAN */ 2961 da[0] = res1; 2962 da[1] = res2; 2963 da += 2; 2964 dp = (mlib_u16 *) da; 2965 #ifdef _LITTLE_ENDIAN 2966 dp[0] = (mlib_u16) (t2 >> 16); 2967 #else 2968 dp[0] = (mlib_u16) t2; 2969 #endif /* _LITTLE_ENDIAN */ 2970 2971 if ((size & 1) == 0) { 2972 t0 = tab[sa[0]]; 2973 #ifdef _LITTLE_ENDIAN 2974 dp[2] = (mlib_u16) (t0 >> 16); 2975 dp[1] = (mlib_u16) t0; 2976 #else 2977 dp[1] = (mlib_u16) (t0 >> 16); 2978 dp[2] = (mlib_u16) t0; 2979 #endif /* _LITTLE_ENDIAN */ 2980 } 2981 } 2982 } 2983 2984 } 2985 else if (csize == 3) { 2986 mlib_u32 tab[512]; 2987 mlib_u16 *tab0 = (mlib_u16 *) table[0]; 2988 mlib_u16 *tab1 = (mlib_u16 *) table[1]; 2989 mlib_u16 *tab2 = (mlib_u16 *) table[2]; 2990 mlib_s32 i, j; 2991 mlib_u32 s0, s1, s2, s3, s4; 2992 2993 s0 = tab0[0]; 2994 s1 = tab1[0]; 2995 s2 = tab2[0]; 2996 for (i = 1; i < 256; i++) { 2997 #ifdef _LITTLE_ENDIAN 2998 s3 = (s0 << 16); 2999 s4 = (s2 << 16) + s1; 3000 #else 3001 s3 = s0; 3002 s4 = (s1 << 16) + s2; 3003 #endif /* _LITTLE_ENDIAN */ 3004 s0 = tab0[i]; 3005 s1 = tab1[i]; 3006 s2 = tab2[i]; 3007 tab[2 * i - 2] = s3; 3008 tab[2 * i - 1] = s4; 3009 } 3010 3011 #ifdef _LITTLE_ENDIAN 3012 s4 = (s2 << 16) + s1; 3013 tab[510] = s0 << 16; 3014 #else 3015 s4 = (s1 << 16) + s2; 3016 tab[510] = s0; 3017 #endif /* _LITTLE_ENDIAN */ 3018 tab[511] = s4; 3019 3020 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 3021 mlib_u32 *da; 3022 mlib_u16 *dp = (mlib_u16 *) dst, *ptr; 3023 mlib_u8 *sa = (void *)src; 3024 mlib_u32 s0, s1, t0, t1, t2, t3; 3025 mlib_u32 res1, res2; 3026 mlib_s32 size = xsize, off; 3027 3028 off = (mlib_s32) ((mlib_addr) dp & 3); 3029 3030 if (off != 0) { 3031 ptr = (mlib_u16 *) (tab + 2 * sa[0]); 3032 dp[0] = ptr[1]; 3033 dp[1] = ptr[2]; 3034 dp[2] = ptr[3]; 3035 dp += 3; 3036 sa++; 3037 size--; 3038 } 3039 3040 da = (mlib_u32 *) dp; 3041 s0 = sa[0] << 3; 3042 s1 = sa[1] << 3; 3043 sa += 2; 3044 3045 #ifdef __SUNPRO_C 3046 #pragma pipeloop(0) 3047 #endif /* __SUNPRO_C */ 3048 for (i = 0; i < size - 3; i += 2, da += 3, sa += 2) { 3049 t0 = *(mlib_u32 *) ((mlib_u8 *) tab + s0); 3050 t1 = *(mlib_u32 *) ((mlib_u8 *) tab + s0 + 4); 3051 t2 = *(mlib_u32 *) ((mlib_u8 *) tab + s1); 3052 t3 = *(mlib_u32 *) ((mlib_u8 *) tab + s1 + 4); 3053 #ifdef _LITTLE_ENDIAN 3054 res1 = (t0 >> 16) + (t1 << 16); 3055 res2 = (t1 >> 16) + t2; 3056 #else 3057 res1 = (t0 << 16) + (t1 >> 16); 3058 res2 = (t1 << 16) + t2; 3059 #endif /* _LITTLE_ENDIAN */ 3060 s0 = sa[0] << 3; 3061 s1 = sa[1] << 3; 3062 da[0] = res1; 3063 da[1] = res2; 3064 da[2] = t3; 3065 } 3066 3067 t0 = *(mlib_u32 *) ((mlib_u8 *) tab + s0); 3068 t1 = *(mlib_u32 *) ((mlib_u8 *) tab + s0 + 4); 3069 t2 = *(mlib_u32 *) ((mlib_u8 *) tab + s1); 3070 t3 = *(mlib_u32 *) ((mlib_u8 *) tab + s1 + 4); 3071 #ifdef _LITTLE_ENDIAN 3072 res1 = (t0 >> 16) + (t1 << 16); 3073 res2 = (t1 >> 16) + t2; 3074 #else 3075 res1 = (t0 << 16) + (t1 >> 16); 3076 res2 = (t1 << 16) + t2; 3077 #endif /* _LITTLE_ENDIAN */ 3078 da[0] = res1; 3079 da[1] = res2; 3080 da[2] = t3; 3081 da += 3; 3082 dp = (mlib_u16 *) da; 3083 i += 2; 3084 3085 if (i < size) { 3086 ptr = (mlib_u16 *) (tab + 2 * sa[0]); 3087 dp[0] = ptr[1]; 3088 dp[1] = ptr[2]; 3089 dp[2] = ptr[3]; 3090 } 3091 } 3092 3093 } 3094 else if (csize == 4) { 3095 mlib_u32 tab[512]; 3096 mlib_u16 *tab0 = (mlib_u16 *) table[0]; 3097 mlib_u16 *tab1 = (mlib_u16 *) table[1]; 3098 mlib_u16 *tab2 = (mlib_u16 *) table[2]; 3099 mlib_u16 *tab3 = (mlib_u16 *) table[3]; 3100 mlib_s32 i, j; 3101 mlib_u32 s0, s1, s2, s3, s4, s5; 3102 3103 s0 = tab0[0]; 3104 s1 = tab1[0]; 3105 s2 = tab2[0]; 3106 s3 = tab3[0]; 3107 for (i = 1; i < 256; i++) { 3108 #ifdef _LITTLE_ENDIAN 3109 s4 = (s1 << 16) + s0; 3110 s5 = (s3 << 16) + s2; 3111 #else 3112 s4 = (s0 << 16) + s1; 3113 s5 = (s2 << 16) + s3; 3114 #endif /* _LITTLE_ENDIAN */ 3115 s0 = tab0[i]; 3116 s1 = tab1[i]; 3117 s2 = tab2[i]; 3118 s3 = tab3[i]; 3119 tab[2 * i - 2] = s4; 3120 tab[2 * i - 1] = s5; 3121 } 3122 3123 #ifdef _LITTLE_ENDIAN 3124 s4 = (s1 << 16) + s0; 3125 s5 = (s3 << 16) + s2; 3126 #else 3127 s4 = (s0 << 16) + s1; 3128 s5 = (s2 << 16) + s3; 3129 #endif /* _LITTLE_ENDIAN */ 3130 tab[510] = s4; 3131 tab[511] = s5; 3132 3133 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 3134 mlib_u32 *da; 3135 mlib_u16 *dp = (mlib_u16 *) dst; 3136 mlib_u8 *sa = (void *)src; 3137 mlib_u32 s0, t0, s1, t1, t2, t3, t4, t5; 3138 mlib_s32 size = xsize; 3139 mlib_u32 res1, res2, res3, res4; 3140 3141 if (((mlib_addr) dp & 3) == 0) { 3142 3143 da = (mlib_u32 *) dp; 3144 3145 s0 = sa[0] << 3; 3146 s1 = sa[1] << 3; 3147 sa += 2; 3148 3149 #ifdef __SUNPRO_C 3150 #pragma pipeloop(0) 3151 #endif /* __SUNPRO_C */ 3152 for (i = 0; i < size - 3; i += 2, da += 4, sa += 2) { 3153 t0 = *(mlib_u32 *) ((mlib_u8 *) tab + s0); 3154 t1 = *(mlib_u32 *) ((mlib_u8 *) tab + s0 + 4); 3155 t2 = *(mlib_u32 *) ((mlib_u8 *) tab + s1); 3156 t3 = *(mlib_u32 *) ((mlib_u8 *) tab + s1 + 4); 3157 s0 = sa[0] << 3; 3158 s1 = sa[1] << 3; 3159 da[0] = t0; 3160 da[1] = t1; 3161 da[2] = t2; 3162 da[3] = t3; 3163 } 3164 3165 t0 = *(mlib_u32 *) ((mlib_u8 *) tab + s0); 3166 t1 = *(mlib_u32 *) ((mlib_u8 *) tab + s0 + 4); 3167 t2 = *(mlib_u32 *) ((mlib_u8 *) tab + s1); 3168 t3 = *(mlib_u32 *) ((mlib_u8 *) tab + s1 + 4); 3169 da[0] = t0; 3170 da[1] = t1; 3171 da[2] = t2; 3172 da[3] = t3; 3173 3174 if (size & 1) { 3175 da[4] = tab[2 * sa[0]]; 3176 da[5] = tab[2 * sa[0] + 1]; 3177 } 3178 3179 } 3180 else { 3181 3182 t4 = tab[2 * sa[0]]; 3183 t5 = tab[2 * sa[0] + 1]; 3184 #ifdef _LITTLE_ENDIAN 3185 *dp++ = (mlib_u16) (t4); 3186 #else 3187 *dp++ = (mlib_u16) (t4 >> 16); 3188 #endif /* _LITTLE_ENDIAN */ 3189 sa++; 3190 da = (mlib_u32 *) dp; 3191 #ifdef _LITTLE_ENDIAN 3192 *da++ = (t4 >> 16) + (t5 << 16); 3193 #else 3194 *da++ = (t4 << 16) + (t5 >> 16); 3195 #endif /* _LITTLE_ENDIAN */ 3196 s0 = sa[0] << 3; 3197 s1 = sa[1] << 3; 3198 sa += 2; 3199 3200 #ifdef __SUNPRO_C 3201 #pragma pipeloop(0) 3202 #endif /* __SUNPRO_C */ 3203 for (i = 0; i < size - 4; i += 2, da += 4, sa += 2) { 3204 t0 = *(mlib_u32 *) ((mlib_u8 *) tab + s0); 3205 t1 = *(mlib_u32 *) ((mlib_u8 *) tab + s0 + 4); 3206 t2 = *(mlib_u32 *) ((mlib_u8 *) tab + s1); 3207 t3 = *(mlib_u32 *) ((mlib_u8 *) tab + s1 + 4); 3208 #ifdef _LITTLE_ENDIAN 3209 res1 = (t5 >> 16) + (t0 << 16); 3210 res2 = (t0 >> 16) + (t1 << 16); 3211 res3 = (t1 >> 16) + (t2 << 16); 3212 res4 = (t2 >> 16) + (t3 << 16); 3213 #else 3214 res1 = (t5 << 16) + (t0 >> 16); 3215 res2 = (t0 << 16) + (t1 >> 16); 3216 res3 = (t1 << 16) + (t2 >> 16); 3217 res4 = (t2 << 16) + (t3 >> 16); 3218 #endif /* _LITTLE_ENDIAN */ 3219 s0 = sa[0] << 3; 3220 s1 = sa[1] << 3; 3221 da[0] = res1; 3222 da[1] = res2; 3223 da[2] = res3; 3224 da[3] = res4; 3225 t5 = t3; 3226 } 3227 3228 t0 = *(mlib_u32 *) ((mlib_u8 *) tab + s0); 3229 t1 = *(mlib_u32 *) ((mlib_u8 *) tab + s0 + 4); 3230 t2 = *(mlib_u32 *) ((mlib_u8 *) tab + s1); 3231 t3 = *(mlib_u32 *) ((mlib_u8 *) tab + s1 + 4); 3232 #ifdef _LITTLE_ENDIAN 3233 res1 = (t5 >> 16) + (t0 << 16); 3234 res2 = (t0 >> 16) + (t1 << 16); 3235 res3 = (t1 >> 16) + (t2 << 16); 3236 res4 = (t2 >> 16) + (t3 << 16); 3237 #else 3238 res1 = (t5 << 16) + (t0 >> 16); 3239 res2 = (t0 << 16) + (t1 >> 16); 3240 res3 = (t1 << 16) + (t2 >> 16); 3241 res4 = (t2 << 16) + (t3 >> 16); 3242 #endif /* _LITTLE_ENDIAN */ 3243 da[0] = res1; 3244 da[1] = res2; 3245 da[2] = res3; 3246 da[3] = res4; 3247 da += 4; 3248 dp = (mlib_u16 *) da; 3249 #ifdef _LITTLE_ENDIAN 3250 dp[0] = (mlib_u16) (t3 >> 16); 3251 #else 3252 dp[0] = (mlib_u16) t3; 3253 #endif /* _LITTLE_ENDIAN */ 3254 3255 if ((size & 1) == 0) { 3256 t0 = tab[2 * sa[0]]; 3257 #ifdef _LITTLE_ENDIAN 3258 dp[2] = (mlib_u16) (t0 >> 16); 3259 dp[1] = (mlib_u16) t0; 3260 #else 3261 dp[1] = (mlib_u16) (t0 >> 16); 3262 dp[2] = (mlib_u16) t0; 3263 #endif /* _LITTLE_ENDIAN */ 3264 t0 = tab[2 * sa[0] + 1]; 3265 #ifdef _LITTLE_ENDIAN 3266 dp[4] = (mlib_u16) (t0 >> 16); 3267 dp[3] = (mlib_u16) t0; 3268 #else 3269 dp[3] = (mlib_u16) (t0 >> 16); 3270 dp[4] = (mlib_u16) t0; 3271 #endif /* _LITTLE_ENDIAN */ 3272 } 3273 } 3274 } 3275 } 3276 } 3277 3278 /***************************************************************/ 3279 void mlib_c_ImageLookUpSI_S16_S16(const mlib_s16 *src, 3280 mlib_s32 slb, 3281 mlib_s16 *dst, 3282 mlib_s32 dlb, 3283 mlib_s32 xsize, 3284 mlib_s32 ysize, 3285 mlib_s32 csize, 3286 const mlib_s16 **table) 3287 { 3288 const mlib_s16 *table_base[4]; 3289 mlib_s32 c; 3290 3291 for (c = 0; c < csize; c++) { 3292 table_base[c] = &table[c][32768]; 3293 } 3294 3295 MLIB_C_IMAGELOOKUPSI(mlib_s16, mlib_s16, table_base); 3296 } 3297 3298 /***************************************************************/ 3299 void mlib_c_ImageLookUpSI_U16_S16(const mlib_u16 *src, 3300 mlib_s32 slb, 3301 mlib_s16 *dst, 3302 mlib_s32 dlb, 3303 mlib_s32 xsize, 3304 mlib_s32 ysize, 3305 mlib_s32 csize, 3306 const mlib_s16 **table) 3307 { 3308 const mlib_s16 *table_base[4]; 3309 mlib_s32 c; 3310 3311 for (c = 0; c < csize; c++) { 3312 table_base[c] = &table[c][0]; 3313 } 3314 3315 MLIB_C_IMAGELOOKUPSI(mlib_s16, mlib_u16, table_base); 3316 } 3317 3318 /***************************************************************/ 3319 void mlib_c_ImageLookUpSI_S32_S16(const mlib_s32 *src, 3320 mlib_s32 slb, 3321 mlib_s16 *dst, 3322 mlib_s32 dlb, 3323 mlib_s32 xsize, 3324 mlib_s32 ysize, 3325 mlib_s32 csize, 3326 const mlib_s16 **table) 3327 { 3328 const mlib_s16 *table_base[4]; 3329 mlib_s32 c; 3330 3331 for (c = 0; c < csize; c++) { 3332 table_base[c] = &table[c][TABLE_SHIFT_S32]; 3333 } 3334 3335 MLIB_C_IMAGELOOKUPSI(mlib_s16, mlib_s32, table_base); 3336 } 3337 3338 /***************************************************************/ 3339 void mlib_c_ImageLookUpSI_S16_U16(const mlib_s16 *src, 3340 mlib_s32 slb, 3341 mlib_u16 *dst, 3342 mlib_s32 dlb, 3343 mlib_s32 xsize, 3344 mlib_s32 ysize, 3345 mlib_s32 csize, 3346 const mlib_u16 **table) 3347 { 3348 const mlib_u16 *table_base[4]; 3349 mlib_s32 c; 3350 3351 for (c = 0; c < csize; c++) { 3352 table_base[c] = &table[c][32768]; 3353 } 3354 3355 MLIB_C_IMAGELOOKUPSI(mlib_u16, mlib_s16, table_base); 3356 } 3357 3358 /***************************************************************/ 3359 void mlib_c_ImageLookUpSI_U16_U16(const mlib_u16 *src, 3360 mlib_s32 slb, 3361 mlib_u16 *dst, 3362 mlib_s32 dlb, 3363 mlib_s32 xsize, 3364 mlib_s32 ysize, 3365 mlib_s32 csize, 3366 const mlib_u16 **table) 3367 { 3368 const mlib_u16 *table_base[4]; 3369 mlib_s32 c; 3370 3371 for (c = 0; c < csize; c++) { 3372 table_base[c] = &table[c][0]; 3373 } 3374 3375 MLIB_C_IMAGELOOKUPSI(mlib_u16, mlib_u16, table_base); 3376 } 3377 3378 /***************************************************************/ 3379 void mlib_c_ImageLookUpSI_S32_U16(const mlib_s32 *src, 3380 mlib_s32 slb, 3381 mlib_u16 *dst, 3382 mlib_s32 dlb, 3383 mlib_s32 xsize, 3384 mlib_s32 ysize, 3385 mlib_s32 csize, 3386 const mlib_u16 **table) 3387 { 3388 const mlib_u16 *table_base[4]; 3389 mlib_s32 c; 3390 3391 for (c = 0; c < csize; c++) { 3392 table_base[c] = &table[c][TABLE_SHIFT_S32]; 3393 } 3394 3395 MLIB_C_IMAGELOOKUPSI(mlib_u16, mlib_s32, table_base); 3396 } 3397 3398 /***************************************************************/ 3399 void mlib_c_ImageLookUpSI_U8_S32(const mlib_u8 *src, 3400 mlib_s32 slb, 3401 mlib_s32 *dst, 3402 mlib_s32 dlb, 3403 mlib_s32 xsize, 3404 mlib_s32 ysize, 3405 mlib_s32 csize, 3406 const mlib_s32 **table) 3407 { 3408 3409 if (xsize < 7) { 3410 MLIB_C_IMAGELOOKUPSI(mlib_s32, mlib_u8, table); 3411 } 3412 else if (csize == 2) { 3413 mlib_s32 i, j; 3414 3415 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 3416 mlib_u32 *sa; 3417 mlib_u32 *tab0 = (mlib_u32 *) table[0]; 3418 mlib_u32 *tab1 = (mlib_u32 *) table[1]; 3419 mlib_u32 s0, t0, t1, t2, t3; 3420 mlib_s32 off; 3421 mlib_s32 size = xsize; 3422 mlib_u32 *dp = (mlib_u32 *) dst; 3423 mlib_u8 *sp = (void *)src; 3424 3425 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 3426 3427 for (i = 0; i < off; i++, sp++) { 3428 *dp++ = tab0[sp[0]]; 3429 *dp++ = tab1[sp[0]]; 3430 size--; 3431 } 3432 3433 sa = (mlib_u32 *) sp; 3434 3435 s0 = sa[0]; 3436 sa++; 3437 3438 #ifdef __SUNPRO_C 3439 #pragma pipeloop(0) 3440 #endif /* __SUNPRO_C */ 3441 for (i = 0; i < size - 7; i += 4, dp += 8, sa++) { 3442 #ifdef _LITTLE_ENDIAN 3443 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3444 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3445 t2 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3446 t3 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3447 #else 3448 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3449 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3450 t2 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3451 t3 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3452 #endif /* _LITTLE_ENDIAN */ 3453 dp[0] = t0; 3454 dp[1] = t1; 3455 dp[2] = t2; 3456 dp[3] = t3; 3457 #ifdef _LITTLE_ENDIAN 3458 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3459 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3460 t2 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3461 t3 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3462 #else 3463 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3464 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3465 t2 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3466 t3 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3467 #endif /* _LITTLE_ENDIAN */ 3468 s0 = sa[0]; 3469 dp[4] = t0; 3470 dp[5] = t1; 3471 dp[6] = t2; 3472 dp[7] = t3; 3473 } 3474 3475 #ifdef _LITTLE_ENDIAN 3476 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3477 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3478 t2 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3479 t3 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3480 #else 3481 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3482 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3483 t2 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3484 t3 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3485 #endif /* _LITTLE_ENDIAN */ 3486 dp[0] = t0; 3487 dp[1] = t1; 3488 dp[2] = t2; 3489 dp[3] = t3; 3490 #ifdef _LITTLE_ENDIAN 3491 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3492 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3493 t2 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3494 t3 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3495 #else 3496 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3497 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3498 t2 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3499 t3 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3500 #endif /* _LITTLE_ENDIAN */ 3501 dp[4] = t0; 3502 dp[5] = t1; 3503 dp[6] = t2; 3504 dp[7] = t3; 3505 dp += 8; 3506 sp = (mlib_u8 *) sa; 3507 i += 4; 3508 3509 for (; i < size; i++, sp++) { 3510 *dp++ = tab0[sp[0]]; 3511 *dp++ = tab1[sp[0]]; 3512 } 3513 } 3514 3515 } 3516 else if (csize == 3) { 3517 mlib_s32 i, j; 3518 3519 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 3520 mlib_u32 *sa; 3521 mlib_u32 *tab0 = (mlib_u32 *) table[0]; 3522 mlib_u32 *tab1 = (mlib_u32 *) table[1]; 3523 mlib_u32 *tab2 = (mlib_u32 *) table[2]; 3524 mlib_u32 s0, t0, t1, t2, t3, t4, t5; 3525 mlib_s32 off; 3526 mlib_s32 size = xsize; 3527 mlib_u32 *dp = (mlib_u32 *) dst; 3528 mlib_u8 *sp = (void *)src; 3529 3530 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 3531 3532 for (i = 0; i < off; i++, sp++) { 3533 *dp++ = tab0[sp[0]]; 3534 *dp++ = tab1[sp[0]]; 3535 *dp++ = tab2[sp[0]]; 3536 size--; 3537 } 3538 3539 sa = (mlib_u32 *) sp; 3540 3541 s0 = sa[0]; 3542 sa++; 3543 3544 #ifdef __SUNPRO_C 3545 #pragma pipeloop(0) 3546 #endif /* __SUNPRO_C */ 3547 for (i = 0; i < size - 7; i += 4, dp += 12, sa++) { 3548 #ifdef _LITTLE_ENDIAN 3549 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3550 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3551 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 << 2) & 0x3FC)); 3552 t3 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3553 t4 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3554 t5 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 6) & 0x3FC)); 3555 #else 3556 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3557 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3558 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 22) & 0x3FC)); 3559 t3 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3560 t4 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3561 t5 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 14) & 0x3FC)); 3562 #endif /* _LITTLE_ENDIAN */ 3563 dp[0] = t0; 3564 dp[1] = t1; 3565 dp[2] = t2; 3566 dp[3] = t3; 3567 dp[4] = t4; 3568 dp[5] = t5; 3569 #ifdef _LITTLE_ENDIAN 3570 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3571 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3572 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 14) & 0x3FC)); 3573 t3 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3574 t4 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3575 t5 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 22) & 0x3FC)); 3576 #else 3577 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3578 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3579 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 6) & 0x3FC)); 3580 t3 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3581 t4 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3582 t5 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 << 2) & 0x3FC)); 3583 #endif /* _LITTLE_ENDIAN */ 3584 s0 = sa[0]; 3585 dp[6] = t0; 3586 dp[7] = t1; 3587 dp[8] = t2; 3588 dp[9] = t3; 3589 dp[10] = t4; 3590 dp[11] = t5; 3591 } 3592 3593 #ifdef _LITTLE_ENDIAN 3594 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3595 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3596 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 << 2) & 0x3FC)); 3597 t3 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3598 t4 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3599 t5 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 6) & 0x3FC)); 3600 #else 3601 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3602 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3603 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 22) & 0x3FC)); 3604 t3 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3605 t4 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3606 t5 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 14) & 0x3FC)); 3607 #endif /* _LITTLE_ENDIAN */ 3608 dp[0] = t0; 3609 dp[1] = t1; 3610 dp[2] = t2; 3611 dp[3] = t3; 3612 dp[4] = t4; 3613 dp[5] = t5; 3614 #ifdef _LITTLE_ENDIAN 3615 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3616 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3617 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 14) & 0x3FC)); 3618 t3 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3619 t4 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3620 t5 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 22) & 0x3FC)); 3621 #else 3622 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3623 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3624 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 6) & 0x3FC)); 3625 t3 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3626 t4 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3627 t5 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 << 2) & 0x3FC)); 3628 #endif /* _LITTLE_ENDIAN */ 3629 dp[6] = t0; 3630 dp[7] = t1; 3631 dp[8] = t2; 3632 dp[9] = t3; 3633 dp[10] = t4; 3634 dp[11] = t5; 3635 dp += 12; 3636 sp = (mlib_u8 *) sa; 3637 i += 4; 3638 3639 for (; i < size; i++, sp++) { 3640 *dp++ = tab0[sp[0]]; 3641 *dp++ = tab1[sp[0]]; 3642 *dp++ = tab2[sp[0]]; 3643 } 3644 } 3645 3646 } 3647 else if (csize == 4) { 3648 mlib_s32 i, j; 3649 3650 for (j = 0; j < ysize; j++, dst += dlb, src += slb) { 3651 mlib_u32 *sa; 3652 mlib_u32 *tab0 = (mlib_u32 *) table[0]; 3653 mlib_u32 *tab1 = (mlib_u32 *) table[1]; 3654 mlib_u32 *tab2 = (mlib_u32 *) table[2]; 3655 mlib_u32 *tab3 = (mlib_u32 *) table[3]; 3656 mlib_u32 s0, t0, t1, t2, t3; 3657 mlib_s32 off; 3658 mlib_s32 size = xsize; 3659 mlib_u32 *dp = (mlib_u32 *) dst; 3660 mlib_u8 *sp = (void *)src; 3661 3662 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3); 3663 3664 for (i = 0; i < off; i++, sp++) { 3665 *dp++ = tab0[sp[0]]; 3666 *dp++ = tab1[sp[0]]; 3667 *dp++ = tab2[sp[0]]; 3668 *dp++ = tab3[sp[0]]; 3669 size--; 3670 } 3671 3672 sa = (mlib_u32 *) sp; 3673 3674 s0 = sa[0]; 3675 sa++; 3676 3677 #ifdef __SUNPRO_C 3678 #pragma pipeloop(0) 3679 #endif /* __SUNPRO_C */ 3680 for (i = 0; i < size - 7; i += 4, dp += 16, sa++) { 3681 #ifdef _LITTLE_ENDIAN 3682 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3683 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3684 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 << 2) & 0x3FC)); 3685 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 << 2) & 0x3FC)); 3686 #else 3687 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3688 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3689 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 22) & 0x3FC)); 3690 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 22) & 0x3FC)); 3691 #endif /* _LITTLE_ENDIAN */ 3692 dp[0] = t0; 3693 dp[1] = t1; 3694 dp[2] = t2; 3695 dp[3] = t3; 3696 #ifdef _LITTLE_ENDIAN 3697 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3698 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3699 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 6) & 0x3FC)); 3700 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 6) & 0x3FC)); 3701 #else 3702 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3703 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3704 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 14) & 0x3FC)); 3705 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 14) & 0x3FC)); 3706 #endif /* _LITTLE_ENDIAN */ 3707 dp[4] = t0; 3708 dp[5] = t1; 3709 dp[6] = t2; 3710 dp[7] = t3; 3711 #ifdef _LITTLE_ENDIAN 3712 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3713 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3714 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 14) & 0x3FC)); 3715 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 14) & 0x3FC)); 3716 #else 3717 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3718 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3719 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 6) & 0x3FC)); 3720 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 6) & 0x3FC)); 3721 #endif /* _LITTLE_ENDIAN */ 3722 dp[8] = t0; 3723 dp[9] = t1; 3724 dp[10] = t2; 3725 dp[11] = t3; 3726 #ifdef _LITTLE_ENDIAN 3727 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3728 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3729 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 22) & 0x3FC)); 3730 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 22) & 0x3FC)); 3731 #else 3732 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3733 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3734 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 << 2) & 0x3FC)); 3735 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 << 2) & 0x3FC)); 3736 #endif /* _LITTLE_ENDIAN */ 3737 s0 = sa[0]; 3738 dp[12] = t0; 3739 dp[13] = t1; 3740 dp[14] = t2; 3741 dp[15] = t3; 3742 } 3743 3744 #ifdef _LITTLE_ENDIAN 3745 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3746 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3747 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 << 2) & 0x3FC)); 3748 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 << 2) & 0x3FC)); 3749 #else 3750 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3751 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3752 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 22) & 0x3FC)); 3753 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 22) & 0x3FC)); 3754 #endif /* _LITTLE_ENDIAN */ 3755 dp[0] = t0; 3756 dp[1] = t1; 3757 dp[2] = t2; 3758 dp[3] = t3; 3759 #ifdef _LITTLE_ENDIAN 3760 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3761 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3762 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 6) & 0x3FC)); 3763 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 6) & 0x3FC)); 3764 #else 3765 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3766 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3767 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 14) & 0x3FC)); 3768 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 14) & 0x3FC)); 3769 #endif /* _LITTLE_ENDIAN */ 3770 dp[4] = t0; 3771 dp[5] = t1; 3772 dp[6] = t2; 3773 dp[7] = t3; 3774 #ifdef _LITTLE_ENDIAN 3775 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 14) & 0x3FC)); 3776 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 14) & 0x3FC)); 3777 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 14) & 0x3FC)); 3778 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 14) & 0x3FC)); 3779 #else 3780 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 6) & 0x3FC)); 3781 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 6) & 0x3FC)); 3782 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 6) & 0x3FC)); 3783 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 6) & 0x3FC)); 3784 #endif /* _LITTLE_ENDIAN */ 3785 dp[8] = t0; 3786 dp[9] = t1; 3787 dp[10] = t2; 3788 dp[11] = t3; 3789 #ifdef _LITTLE_ENDIAN 3790 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 >> 22) & 0x3FC)); 3791 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 >> 22) & 0x3FC)); 3792 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 >> 22) & 0x3FC)); 3793 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 >> 22) & 0x3FC)); 3794 #else 3795 t0 = *(mlib_u32 *) ((mlib_u8 *) tab0 + ((s0 << 2) & 0x3FC)); 3796 t1 = *(mlib_u32 *) ((mlib_u8 *) tab1 + ((s0 << 2) & 0x3FC)); 3797 t2 = *(mlib_u32 *) ((mlib_u8 *) tab2 + ((s0 << 2) & 0x3FC)); 3798 t3 = *(mlib_u32 *) ((mlib_u8 *) tab3 + ((s0 << 2) & 0x3FC)); 3799 #endif /* _LITTLE_ENDIAN */ 3800 dp[12] = t0; 3801 dp[13] = t1; 3802 dp[14] = t2; 3803 dp[15] = t3; 3804 dp += 16; 3805 sp = (mlib_u8 *) sa; 3806 i += 4; 3807 3808 for (; i < size; i++, sp++) { 3809 *dp++ = tab0[sp[0]]; 3810 *dp++ = tab1[sp[0]]; 3811 *dp++ = tab2[sp[0]]; 3812 *dp++ = tab3[sp[0]]; 3813 } 3814 } 3815 } 3816 } 3817 3818 /***************************************************************/ 3819 void mlib_c_ImageLookUpSI_S16_S32(const mlib_s16 *src, 3820 mlib_s32 slb, 3821 mlib_s32 *dst, 3822 mlib_s32 dlb, 3823 mlib_s32 xsize, 3824 mlib_s32 ysize, 3825 mlib_s32 csize, 3826 const mlib_s32 **table) 3827 { 3828 const mlib_s32 *table_base[4]; 3829 mlib_s32 c; 3830 3831 for (c = 0; c < csize; c++) { 3832 table_base[c] = &table[c][32768]; 3833 } 3834 3835 MLIB_C_IMAGELOOKUPSI(mlib_s32, mlib_s16, table_base); 3836 } 3837 3838 /***************************************************************/ 3839 void mlib_c_ImageLookUpSI_U16_S32(const mlib_u16 *src, 3840 mlib_s32 slb, 3841 mlib_s32 *dst, 3842 mlib_s32 dlb, 3843 mlib_s32 xsize, 3844 mlib_s32 ysize, 3845 mlib_s32 csize, 3846 const mlib_s32 **table) 3847 { 3848 const mlib_s32 *table_base[4]; 3849 mlib_s32 c; 3850 3851 for (c = 0; c < csize; c++) { 3852 table_base[c] = &table[c][0]; 3853 } 3854 3855 MLIB_C_IMAGELOOKUPSI(mlib_s32, mlib_u16, table_base); 3856 } 3857 3858 /***************************************************************/ 3859 void mlib_c_ImageLookUpSI_S32_S32(const mlib_s32 *src, 3860 mlib_s32 slb, 3861 mlib_s32 *dst, 3862 mlib_s32 dlb, 3863 mlib_s32 xsize, 3864 mlib_s32 ysize, 3865 mlib_s32 csize, 3866 const mlib_s32 **table) 3867 { 3868 const mlib_s32 *table_base[4]; 3869 mlib_s32 c; 3870 3871 for (c = 0; c < csize; c++) { 3872 table_base[c] = &table[c][TABLE_SHIFT_S32]; 3873 } 3874 3875 MLIB_C_IMAGELOOKUPSI(mlib_s32, mlib_s32, table_base); 3876 } 3877 3878 /***************************************************************/