Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / libcore / 319a3b994703aac84df7bcde272adfcb3cdbbbf0 / . / jdk / src / share / native / sun / awt / medialib / mlib_ImageLookUp_64.c
blob: 10ca4e06d965ea4b5570b1e02713c2ed4ea1874e [file] [log] [blame]
J. Duke319a3b92007-12-01 00:00:00 +0000[diff] [blame^]1/*
2 * Copyright 1999-2003 Sun Microsystems, Inc. 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. Sun designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22 * CA 95054 USA or visit www.sun.com if you need additional information or
23 * have any questions.
24 */
25
26
27/*
28 * FUNCTION
29 * mlib_ImageLookUp_U8D64 - table lookup
30 * mlib_ImageLookUp_S16D64 - table lookup
31 * mlib_ImageLookUp_U16D64 - table lookup
32 * mlib_ImageLookUp_S32D64 - table lookup
33 *
34 * SYNOPSIS
35 * void mlib_ImageLookUp_U8_D64(src, slb,
36 * dst, dlb,
37 * xsize, ysize,
38 * csize, table)
39 *
40 * void mlib_ImageLookUp_S16_D64(src, slb,
41 * dst, dlb,
42 * xsize, ysize,
43 * csize, table)
44 *
45 * void mlib_ImageLookUp_U16_D64(src, slb,
46 * dst, dlb,
47 * xsize, ysize,
48 * csize, table)
49 *
50 * void mlib_ImageLookUp_S32_D64(src, slb,
51 * dst, dlb,
52 * xsize, ysize,
53 * csize, table)
54 *
55 * ARGUMENT
56 * src pointer to input image (BYTE, SHORT, USHORT, INT)
57 * slb stride of input image (in pixels)
58 * dst pointer to output image (DOUBLE)
59 * dlb stride of output image (in pixels)
60 * xsize image width
61 * ysize image height
62 * csize number of channels
63 * table lookup table
64 *
65 * DESCRIPTION
66 * dst = table[src] (c, vis version)
67 */
68
69#include "mlib_image.h"
70#include "mlib_ImageLookUp.h"
71
72/***************************************************************/
73#define MLIB_C_IMAGELOOKUP(DTYPE, STYPE, TABLE) \
74{ \
75 mlib_s32 i, j, k; \
76 \
77 if (xsize < 2) { \
78 for(j = 0; j < ysize; j++, dst += dlb, src += slb){ \
79 for(k = 0; k < csize; k++) { \
80 DTYPE *da = dst + k; \
81 const STYPE *sa = src + k; \
82 DTYPE *tab = (DTYPE*) TABLE[k]; \
83 \
84 for(i = 0; i < xsize; i++, da += csize, sa += csize) \
85 *da=tab[*sa]; \
86 } \
87 } \
88 } else { \
89 for(j = 0; j < ysize; j++, dst += dlb, src += slb) { \
90 for(k = 0; k < csize; k++) { \
91 DTYPE *da = dst + k; \
92 const STYPE *sa = src + k; \
93 DTYPE *tab = (DTYPE*) TABLE[k]; \
94 mlib_s32 s0, s1; \
95 DTYPE t0, t1; \
96 \
97 s0 = (mlib_s32)sa[0]; \
98 s1 = (mlib_s32)sa[csize]; \
99 sa += 2*csize; \
100 \
101 for(i = 0; \
102 i < xsize - 3; \
103 i+=2, da += 2*csize, sa += 2*csize) { \
104 t0 = tab[s0]; \
105 t1 = tab[s1]; \
106 s0 = (mlib_s32)sa[0]; \
107 s1 = (mlib_s32)sa[csize]; \
108 da[0] = (DTYPE)t0; \
109 da[csize] = (DTYPE)t1; \
110 } \
111 t0 = tab[s0]; \
112 t1 = tab[s1]; \
113 da[0] = (DTYPE)t0; \
114 da[csize] = (DTYPE)t1; \
115 if (xsize & 1) da[2*csize] = tab[sa[0]]; \
116 } \
117 } \
118 } \
119}
120
121/***************************************************************/
122#define MLIB_C_IMAGELOOKUPSI(DTYPE, STYPE, TABLE) \
123{ \
124 mlib_s32 i, j, k; \
125 \
126 if (xsize < 2) { \
127 for(j = 0; j < ysize; j++, dst += dlb, src += slb){ \
128 for(k = 0; k < csize; k++) { \
129 DTYPE *da = dst + k; \
130 const STYPE *sa = (void *)src; \
131 DTYPE *tab = (DTYPE*) TABLE[k]; \
132 \
133 for(i = 0; i < xsize; i++, da += csize, sa ++) \
134 *da=tab[*sa]; \
135 } \
136 } \
137 } else { \
138 for(j = 0; j < ysize; j++, dst += dlb, src += slb) { \
139 for(k = 0; k < csize; k++) { \
140 DTYPE *da = dst + k; \
141 const STYPE *sa = (void *)src; \
142 DTYPE *tab = (DTYPE*) TABLE[k]; \
143 mlib_s32 s0, s1; \
144 DTYPE t0, t1; \
145 \
146 s0 = (mlib_s32)sa[0]; \
147 s1 = (mlib_s32)sa[1]; \
148 sa += 2; \
149 \
150 for(i = 0; \
151 i < xsize - 3; \
152 i+=2, da += 2*csize, sa += 2) { \
153 t0 = tab[s0]; \
154 t1 = tab[s1]; \
155 s0 = (mlib_s32)sa[0]; \
156 s1 = (mlib_s32)sa[1]; \
157 da[0] = (DTYPE)t0; \
158 da[csize] = (DTYPE)t1; \
159 } \
160 t0 = tab[s0]; \
161 t1 = tab[s1]; \
162 da[0] = (DTYPE)t0; \
163 da[csize] = (DTYPE)t1; \
164 if (xsize & 1) da[2*csize] = tab[sa[0]]; \
165 } \
166 } \
167 } \
168}
169
170/***************************************************************/
171#ifdef _LITTLE_ENDIAN
172
173#define READ_U8_D64(table0, table1, table2, table3) \
174 t0 = *(mlib_d64*)((mlib_u8*)table0 + ((s0 << 3) & 0x7F8)); \
175 t1 = *(mlib_d64*)((mlib_u8*)table1 + ((s0 >> 5) & 0x7F8)); \
176 t2 = *(mlib_d64*)((mlib_u8*)table2 + ((s0 >> 13) & 0x7F8)); \
177 t3 = *(mlib_d64*)((mlib_u8*)table3 + ((s0 >> 21) & 0x7F8))
178
179#else
180
181#define READ_U8_D64(table0, table1, table2, table3) \
182 t0 = *(mlib_d64*)((mlib_u8*)table0 + ((s0 >> 21) & 0x7F8)); \
183 t1 = *(mlib_d64*)((mlib_u8*)table1 + ((s0 >> 13) & 0x7F8)); \
184 t2 = *(mlib_d64*)((mlib_u8*)table2 + ((s0 >> 5) & 0x7F8)); \
185 t3 = *(mlib_d64*)((mlib_u8*)table3 + ((s0 << 3) & 0x7F8))
186
187#endif /* _LITTLE_ENDIAN */
188
189/***************************************************************/
190void mlib_ImageLookUp_U8_D64(const mlib_u8 *src,
191 mlib_s32 slb,
192 mlib_d64 *dst,
193 mlib_s32 dlb,
194 mlib_s32 xsize,
195 mlib_s32 ysize,
196 mlib_s32 csize,
197 const mlib_d64 **table)
198{
199
200 if (xsize * csize < 7) {
201 MLIB_C_IMAGELOOKUP(mlib_d64, mlib_u8, table);
202 }
203 else if (csize == 1) {
204 mlib_s32 i, j;
205
206 for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
207 mlib_u32 *sa;
208 mlib_d64 *tab = (mlib_d64 *) table[0];
209 mlib_u32 s0;
210 mlib_d64 t0, t1, t2, t3;
211 mlib_s32 off;
212 mlib_s32 size = xsize;
213 mlib_d64 *dp = (mlib_d64 *) dst;
214 mlib_u8 *sp = (void *)src;
215
216 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
217
218 for (i = 0; i < off; i++, sp++) {
219 *dp++ = tab[sp[0]];
220 size--;
221 }
222
223 sa = (mlib_u32 *) sp;
224
225 s0 = sa[0];
226 sa++;
227
228#ifdef __SUNPRO_C
229#pragma pipeloop(0)
230#endif /* __SUNPRO_C */
231 for (i = 0; i < size - 7; i += 4, dp += 4, sa++) {
232 READ_U8_D64(tab, tab, tab, tab);
233 s0 = sa[0];
234 dp[0] = t0;
235 dp[1] = t1;
236 dp[2] = t2;
237 dp[3] = t3;
238 }
239
240 READ_U8_D64(tab, tab, tab, tab);
241 dp[0] = t0;
242 dp[1] = t1;
243 dp[2] = t2;
244 dp[3] = t3;
245 dp += 4;
246 sp = (mlib_u8 *) sa;
247 i += 4;
248 for (; i < size; i++, dp++, sp++)
249 dp[0] = tab[sp[0]];
250 }
251 }
252 else if (csize == 2) {
253 mlib_s32 i, j;
254
255 for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
256 mlib_u32 *sa;
257 mlib_d64 *tab0 = (mlib_d64 *) table[0];
258 mlib_d64 *tab1 = (mlib_d64 *) table[1];
259 mlib_d64 *tab;
260 mlib_u32 s0;
261 mlib_d64 t0, t1, t2, t3;
262 mlib_s32 off;
263 mlib_s32 size = xsize * 2;
264 mlib_d64 *dp = (mlib_d64 *) dst;
265 mlib_u8 *sp = (void *)src;
266
267 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
268
269 for (i = 0; i < off - 1; i += 2, sp += 2) {
270 *dp++ = tab0[sp[0]];
271 *dp++ = tab1[sp[1]];
272 size -= 2;
273 }
274
275 if ((off & 1) != 0) {
276 *dp++ = tab0[*sp];
277 size--;
278 sp++;
279 tab = tab0;
280 tab0 = tab1;
281 tab1 = tab;
282 }
283
284 sa = (mlib_u32 *) sp;
285
286 s0 = sa[0];
287 sa++;
288
289#ifdef __SUNPRO_C
290#pragma pipeloop(0)
291#endif /* __SUNPRO_C */
292 for (i = 0; i < size - 7; i += 4, dp += 4, sa++) {
293 READ_U8_D64(tab0, tab1, tab0, tab1);
294 s0 = sa[0];
295 dp[0] = t0;
296 dp[1] = t1;
297 dp[2] = t2;
298 dp[3] = t3;
299 }
300
301 READ_U8_D64(tab0, tab1, tab0, tab1);
302 dp[0] = t0;
303 dp[1] = t1;
304 dp[2] = t2;
305 dp[3] = t3;
306 dp += 4;
307 sp = (mlib_u8 *) sa;
308 i += 4;
309
310 for (; i < size - 1; i += 2, sp += 2) {
311 *dp++ = tab0[sp[0]];
312 *dp++ = tab1[sp[1]];
313 }
314
315 if (i < size)
316 *dp = tab0[(*sp)];
317 }
318 }
319 else if (csize == 3) {
320 mlib_s32 i, j;
321
322 for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
323 mlib_u32 *sa;
324 mlib_d64 *tab0 = (mlib_d64 *) table[0];
325 mlib_d64 *tab1 = (mlib_d64 *) table[1];
326 mlib_d64 *tab2 = (mlib_d64 *) table[2];
327 mlib_d64 *tab;
328 mlib_u32 s0;
329 mlib_d64 t0, t1, t2, t3;
330 mlib_s32 off;
331 mlib_s32 size = xsize * 3;
332 mlib_d64 *dp = (mlib_d64 *) dst;
333 mlib_u8 *sp = (void *)src;
334
335 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
336
337 if (off == 1) {
338 *dp++ = tab0[(*sp)];
339 tab = tab0;
340 tab0 = tab1;
341 tab1 = tab2;
342 tab2 = tab;
343 size--;
344 sp++;
345 }
346 else if (off == 2) {
347 *dp++ = tab0[sp[0]];
348 *dp++ = tab1[sp[1]];
349 tab = tab2;
350 tab2 = tab1;
351 tab1 = tab0;
352 tab0 = tab;
353 size -= 2;
354 sp += 2;
355 }
356 else if (off == 3) {
357 *dp++ = tab0[sp[0]];
358 *dp++ = tab1[sp[1]];
359 *dp++ = tab2[sp[2]];
360 size -= 3;
361 sp += 3;
362 }
363
364 sa = (mlib_u32 *) sp;
365
366 s0 = sa[0];
367 sa++;
368
369#ifdef __SUNPRO_C
370#pragma pipeloop(0)
371#endif /* __SUNPRO_C */
372 for (i = 0; i < size - 7; i += 4, dp += 4, sa++) {
373 READ_U8_D64(tab0, tab1, tab2, tab0);
374 tab = tab0;
375 tab0 = tab1;
376 tab1 = tab2;
377 tab2 = tab;
378 s0 = sa[0];
379 dp[0] = t0;
380 dp[1] = t1;
381 dp[2] = t2;
382 dp[3] = t3;
383 }
384
385 READ_U8_D64(tab0, tab1, tab2, tab0);
386 dp[0] = t0;
387 dp[1] = t1;
388 dp[2] = t2;
389 dp[3] = t3;
390 dp += 4;
391 sp = (mlib_u8 *) sa;
392 i += 4;
393
394 if (i < size) {
395 *dp++ = tab1[(*sp)];
396 i++;
397 sp++;
398 }
399
400 if (i < size) {
401 *dp++ = tab2[(*sp)];
402 i++;
403 sp++;
404 }
405
406 if (i < size) {
407 *dp = tab0[(*sp)];
408 }
409 }
410 }
411 else if (csize == 4) {
412 mlib_s32 i, j;
413
414 for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
415 mlib_u32 *sa;
416 mlib_d64 *tab0 = (mlib_d64 *) table[0];
417 mlib_d64 *tab1 = (mlib_d64 *) table[1];
418 mlib_d64 *tab2 = (mlib_d64 *) table[2];
419 mlib_d64 *tab3 = (mlib_d64 *) table[3];
420 mlib_d64 *tab;
421 mlib_u32 s0;
422 mlib_d64 t0, t1, t2, t3;
423 mlib_s32 off;
424 mlib_s32 size = xsize * 4;
425 mlib_d64 *dp = (mlib_d64 *) dst;
426 mlib_u8 *sp = (void *)src;
427
428 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
429
430 if (off == 1) {
431 *dp++ = tab0[(*sp)];
432 tab = tab0;
433 tab0 = tab1;
434 tab1 = tab2;
435 tab2 = tab3;
436 tab3 = tab;
437 size--;
438 sp++;
439 }
440 else if (off == 2) {
441 *dp++ = tab0[sp[0]];
442 *dp++ = tab1[sp[1]];
443 tab = tab0;
444 tab0 = tab2;
445 tab2 = tab;
446 tab = tab1;
447 tab1 = tab3;
448 tab3 = tab;
449 size -= 2;
450 sp += 2;
451 }
452 else if (off == 3) {
453 *dp++ = tab0[sp[0]];
454 *dp++ = tab1[sp[1]];
455 *dp++ = tab2[sp[2]];
456 tab = tab3;
457 tab3 = tab2;
458 tab2 = tab1;
459 tab1 = tab0;
460 tab0 = tab;
461 size -= 3;
462 sp += 3;
463 }
464
465 sa = (mlib_u32 *) sp;
466
467 s0 = sa[0];
468 sa++;
469
470#ifdef __SUNPRO_C
471#pragma pipeloop(0)
472#endif /* __SUNPRO_C */
473 for (i = 0; i < size - 7; i += 4, dp += 4, sa++) {
474 READ_U8_D64(tab0, tab1, tab2, tab3);
475 s0 = sa[0];
476 dp[0] = t0;
477 dp[1] = t1;
478 dp[2] = t2;
479 dp[3] = t3;
480 }
481
482 READ_U8_D64(tab0, tab1, tab2, tab3);
483 dp[0] = t0;
484 dp[1] = t1;
485 dp[2] = t2;
486 dp[3] = t3;
487 dp += 4;
488 sp = (mlib_u8 *) sa;
489 i += 4;
490
491 if (i < size) {
492 *dp++ = tab0[(*sp)];
493 i++;
494 sp++;
495 }
496
497 if (i < size) {
498 *dp++ = tab1[(*sp)];
499 i++;
500 sp++;
501 }
502
503 if (i < size) {
504 *dp = tab2[(*sp)];
505 }
506 }
507 }
508}
509
510/***************************************************************/
511void mlib_ImageLookUp_S16_D64(const mlib_s16 *src,
512 mlib_s32 slb,
513 mlib_d64 *dst,
514 mlib_s32 dlb,
515 mlib_s32 xsize,
516 mlib_s32 ysize,
517 mlib_s32 csize,
518 const mlib_d64 **table)
519{
520 const mlib_d64 *table_base[4];
521 mlib_s32 c;
522
523 for (c = 0; c < csize; c++) {
524 table_base[c] = &table[c][32768];
525 }
526
527 MLIB_C_IMAGELOOKUP(mlib_d64, mlib_s16, table_base);
528}
529
530/***************************************************************/
531void mlib_ImageLookUp_U16_D64(const mlib_u16 *src,
532 mlib_s32 slb,
533 mlib_d64 *dst,
534 mlib_s32 dlb,
535 mlib_s32 xsize,
536 mlib_s32 ysize,
537 mlib_s32 csize,
538 const mlib_d64 **table)
539{
540 const mlib_d64 *table_base[4];
541 mlib_s32 c;
542
543 for (c = 0; c < csize; c++) {
544 table_base[c] = &table[c][0];
545 }
546
547 MLIB_C_IMAGELOOKUP(mlib_d64, mlib_u16, table_base);
548}
549
550/***************************************************************/
551void mlib_ImageLookUp_S32_D64(const mlib_s32 *src,
552 mlib_s32 slb,
553 mlib_d64 *dst,
554 mlib_s32 dlb,
555 mlib_s32 xsize,
556 mlib_s32 ysize,
557 mlib_s32 csize,
558 const mlib_d64 **table)
559{
560 const mlib_d64 *table_base[4];
561 mlib_s32 c;
562
563 for (c = 0; c < csize; c++) {
564 table_base[c] = &table[c][TABLE_SHIFT_S32];
565 }
566
567 MLIB_C_IMAGELOOKUP(mlib_d64, mlib_s32, table_base);
568}
569
570/***************************************************************/
571void mlib_ImageLookUpSI_U8_D64(const mlib_u8 *src,
572 mlib_s32 slb,
573 mlib_d64 *dst,
574 mlib_s32 dlb,
575 mlib_s32 xsize,
576 mlib_s32 ysize,
577 mlib_s32 csize,
578 const mlib_d64 **table)
579{
580
581 if (xsize < 7) {
582 MLIB_C_IMAGELOOKUPSI(mlib_d64, mlib_u8, table);
583 }
584 else if (csize == 2) {
585 mlib_s32 i, j;
586
587 for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
588 mlib_u32 *sa;
589 mlib_d64 *tab0 = (mlib_d64 *) table[0];
590 mlib_d64 *tab1 = (mlib_d64 *) table[1];
591 mlib_u32 s0;
592 mlib_d64 t0, t1, t2, t3;
593 mlib_s32 off;
594 mlib_s32 size = xsize;
595 mlib_d64 *dp = (mlib_d64 *) dst;
596 mlib_u8 *sp = (void *)src;
597
598 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
599
600 for (i = 0; i < off; i++, sp++) {
601 *dp++ = tab0[sp[0]];
602 *dp++ = tab1[sp[0]];
603 size--;
604 }
605
606 sa = (mlib_u32 *) sp;
607
608 s0 = sa[0];
609 sa++;
610
611#ifdef __SUNPRO_C
612#pragma pipeloop(0)
613#endif /* __SUNPRO_C */
614 for (i = 0; i < size - 7; i += 4, dp += 8, sa++) {
615#ifdef _LITTLE_ENDIAN
616 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
617 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
618 t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
619 t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
620#else
621 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
622 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
623 t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
624 t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
625#endif /* _LITTLE_ENDIAN */
626 dp[0] = t0;
627 dp[1] = t1;
628 dp[2] = t2;
629 dp[3] = t3;
630#ifdef _LITTLE_ENDIAN
631 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
632 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
633 t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
634 t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
635#else
636 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
637 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
638 t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
639 t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
640#endif /* _LITTLE_ENDIAN */
641 s0 = sa[0];
642 dp[4] = t0;
643 dp[5] = t1;
644 dp[6] = t2;
645 dp[7] = t3;
646 }
647
648#ifdef _LITTLE_ENDIAN
649 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
650 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
651 t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
652 t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
653#else
654 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
655 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
656 t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
657 t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
658#endif /* _LITTLE_ENDIAN */
659 dp[0] = t0;
660 dp[1] = t1;
661 dp[2] = t2;
662 dp[3] = t3;
663#ifdef _LITTLE_ENDIAN
664 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
665 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
666 t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
667 t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
668#else
669 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
670 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
671 t2 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
672 t3 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
673#endif /* _LITTLE_ENDIAN */
674 dp[4] = t0;
675 dp[5] = t1;
676 dp[6] = t2;
677 dp[7] = t3;
678 dp += 8;
679 sp = (mlib_u8 *) sa;
680 i += 4;
681
682 for (; i < size; i++, sp++) {
683 *dp++ = tab0[sp[0]];
684 *dp++ = tab1[sp[0]];
685 }
686 }
687 }
688 else if (csize == 3) {
689 mlib_s32 i, j;
690
691 for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
692 mlib_u32 *sa;
693 mlib_d64 *tab0 = (mlib_d64 *) table[0];
694 mlib_d64 *tab1 = (mlib_d64 *) table[1];
695 mlib_d64 *tab2 = (mlib_d64 *) table[2];
696 mlib_u32 s0;
697 mlib_d64 t0, t1, t2, t3, t4, t5;
698 mlib_s32 off;
699 mlib_s32 size = xsize;
700 mlib_d64 *dp = (mlib_d64 *) dst;
701 mlib_u8 *sp = (void *)src;
702
703 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
704
705 for (i = 0; i < off; i++, sp++) {
706 *dp++ = tab0[sp[0]];
707 *dp++ = tab1[sp[0]];
708 *dp++ = tab2[sp[0]];
709 size--;
710 }
711
712 sa = (mlib_u32 *) sp;
713
714 s0 = sa[0];
715 sa++;
716
717#ifdef __SUNPRO_C
718#pragma pipeloop(0)
719#endif /* __SUNPRO_C */
720 for (i = 0; i < size - 7; i += 4, dp += 12, sa++) {
721#ifdef _LITTLE_ENDIAN
722 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
723 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
724 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
725 t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
726 t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
727 t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
728#else
729 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
730 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
731 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
732 t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
733 t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
734 t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
735#endif /* _LITTLE_ENDIAN */
736 dp[0] = t0;
737 dp[1] = t1;
738 dp[2] = t2;
739 dp[3] = t3;
740 dp[4] = t4;
741 dp[5] = t5;
742#ifdef _LITTLE_ENDIAN
743 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
744 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
745 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
746 t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
747 t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
748 t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
749#else
750 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
751 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
752 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
753 t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
754 t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
755 t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
756#endif /* _LITTLE_ENDIAN */
757 s0 = sa[0];
758 dp[6] = t0;
759 dp[7] = t1;
760 dp[8] = t2;
761 dp[9] = t3;
762 dp[10] = t4;
763 dp[11] = t5;
764 }
765
766#ifdef _LITTLE_ENDIAN
767 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
768 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
769 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
770 t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
771 t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
772 t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
773#else
774 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
775 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
776 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
777 t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
778 t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
779 t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
780#endif /* _LITTLE_ENDIAN */
781 dp[0] = t0;
782 dp[1] = t1;
783 dp[2] = t2;
784 dp[3] = t3;
785 dp[4] = t4;
786 dp[5] = t5;
787#ifdef _LITTLE_ENDIAN
788 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
789 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
790 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
791 t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
792 t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
793 t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
794#else
795 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
796 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
797 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
798 t3 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
799 t4 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
800 t5 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
801#endif /* _LITTLE_ENDIAN */
802 dp[6] = t0;
803 dp[7] = t1;
804 dp[8] = t2;
805 dp[9] = t3;
806 dp[10] = t4;
807 dp[11] = t5;
808 dp += 12;
809 sp = (mlib_u8 *) sa;
810 i += 4;
811
812 for (; i < size; i++, sp++) {
813 *dp++ = tab0[sp[0]];
814 *dp++ = tab1[sp[0]];
815 *dp++ = tab2[sp[0]];
816 }
817 }
818 }
819 else if (csize == 4) {
820 mlib_s32 i, j;
821
822 for (j = 0; j < ysize; j++, dst += dlb, src += slb) {
823 mlib_u32 *sa;
824 mlib_d64 *tab0 = (mlib_d64 *) table[0];
825 mlib_d64 *tab1 = (mlib_d64 *) table[1];
826 mlib_d64 *tab2 = (mlib_d64 *) table[2];
827 mlib_d64 *tab3 = (mlib_d64 *) table[3];
828 mlib_u32 s0;
829 mlib_d64 t0, t1, t2, t3;
830 mlib_s32 off;
831 mlib_s32 size = xsize;
832 mlib_d64 *dp = (mlib_d64 *) dst;
833 mlib_u8 *sp = (void *)src;
834
835 off = (mlib_s32) ((4 - ((mlib_addr) src & 3)) & 3);
836
837 for (i = 0; i < off; i++, sp++) {
838 *dp++ = tab0[sp[0]];
839 *dp++ = tab1[sp[0]];
840 *dp++ = tab2[sp[0]];
841 *dp++ = tab3[sp[0]];
842 size--;
843 }
844
845 sa = (mlib_u32 *) sp;
846
847 s0 = sa[0];
848 sa++;
849
850#ifdef __SUNPRO_C
851#pragma pipeloop(0)
852#endif /* __SUNPRO_C */
853 for (i = 0; i < size - 7; i += 4, dp += 16, sa++) {
854#ifdef _LITTLE_ENDIAN
855 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
856 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
857 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
858 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 << 3) & 0x7F8));
859#else
860 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
861 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
862 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
863 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 21) & 0x7F8));
864#endif /* _LITTLE_ENDIAN */
865 dp[0] = t0;
866 dp[1] = t1;
867 dp[2] = t2;
868 dp[3] = t3;
869#ifdef _LITTLE_ENDIAN
870 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
871 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
872 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
873 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 5) & 0x7F8));
874#else
875 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
876 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
877 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
878 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 13) & 0x7F8));
879#endif /* _LITTLE_ENDIAN */
880 dp[4] = t0;
881 dp[5] = t1;
882 dp[6] = t2;
883 dp[7] = t3;
884#ifdef _LITTLE_ENDIAN
885 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
886 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
887 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
888 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 13) & 0x7F8));
889#else
890 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
891 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
892 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
893 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 5) & 0x7F8));
894#endif /* _LITTLE_ENDIAN */
895 dp[8] = t0;
896 dp[9] = t1;
897 dp[10] = t2;
898 dp[11] = t3;
899#ifdef _LITTLE_ENDIAN
900 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
901 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
902 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
903 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 21) & 0x7F8));
904#else
905 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
906 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
907 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
908 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 << 3) & 0x7F8));
909#endif /* _LITTLE_ENDIAN */
910 s0 = sa[0];
911 dp[12] = t0;
912 dp[13] = t1;
913 dp[14] = t2;
914 dp[15] = t3;
915 }
916
917#ifdef _LITTLE_ENDIAN
918 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
919 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
920 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
921 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 << 3) & 0x7F8));
922#else
923 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
924 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
925 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
926 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 21) & 0x7F8));
927#endif /* _LITTLE_ENDIAN */
928 dp[0] = t0;
929 dp[1] = t1;
930 dp[2] = t2;
931 dp[3] = t3;
932#ifdef _LITTLE_ENDIAN
933 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
934 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
935 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
936 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 5) & 0x7F8));
937#else
938 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
939 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
940 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
941 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 13) & 0x7F8));
942#endif /* _LITTLE_ENDIAN */
943 dp[4] = t0;
944 dp[5] = t1;
945 dp[6] = t2;
946 dp[7] = t3;
947#ifdef _LITTLE_ENDIAN
948 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 13) & 0x7F8));
949 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 13) & 0x7F8));
950 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 13) & 0x7F8));
951 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 13) & 0x7F8));
952#else
953 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 5) & 0x7F8));
954 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 5) & 0x7F8));
955 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 5) & 0x7F8));
956 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 5) & 0x7F8));
957#endif /* _LITTLE_ENDIAN */
958 dp[8] = t0;
959 dp[9] = t1;
960 dp[10] = t2;
961 dp[11] = t3;
962#ifdef _LITTLE_ENDIAN
963 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 >> 21) & 0x7F8));
964 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 >> 21) & 0x7F8));
965 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 >> 21) & 0x7F8));
966 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 >> 21) & 0x7F8));
967#else
968 t0 = *(mlib_d64 *) ((mlib_u8 *) tab0 + ((s0 << 3) & 0x7F8));
969 t1 = *(mlib_d64 *) ((mlib_u8 *) tab1 + ((s0 << 3) & 0x7F8));
970 t2 = *(mlib_d64 *) ((mlib_u8 *) tab2 + ((s0 << 3) & 0x7F8));
971 t3 = *(mlib_d64 *) ((mlib_u8 *) tab3 + ((s0 << 3) & 0x7F8));
972#endif /* _LITTLE_ENDIAN */
973 dp[12] = t0;
974 dp[13] = t1;
975 dp[14] = t2;
976 dp[15] = t3;
977 dp += 16;
978 sp = (mlib_u8 *) sa;
979 i += 4;
980
981 for (; i < size; i++, sp++) {
982 *dp++ = tab0[sp[0]];
983 *dp++ = tab1[sp[0]];
984 *dp++ = tab2[sp[0]];
985 *dp++ = tab3[sp[0]];
986 }
987 }
988 }
989}
990
991/***************************************************************/
992void mlib_ImageLookUpSI_S16_D64(const mlib_s16 *src,
993 mlib_s32 slb,
994 mlib_d64 *dst,
995 mlib_s32 dlb,
996 mlib_s32 xsize,
997 mlib_s32 ysize,
998 mlib_s32 csize,
999 const mlib_d64 **table)
1000{
1001 const mlib_d64 *table_base[4];
1002 mlib_s32 c;
1003
1004 for (c = 0; c < csize; c++) {
1005 table_base[c] = &table[c][32768];
1006 }
1007
1008 MLIB_C_IMAGELOOKUPSI(mlib_d64, mlib_s16, table_base);
1009}
1010
1011/***************************************************************/
1012void mlib_ImageLookUpSI_U16_D64(const mlib_u16 *src,
1013 mlib_s32 slb,
1014 mlib_d64 *dst,
1015 mlib_s32 dlb,
1016 mlib_s32 xsize,
1017 mlib_s32 ysize,
1018 mlib_s32 csize,
1019 const mlib_d64 **table)
1020{
1021 const mlib_d64 *table_base[4];
1022 mlib_s32 c;
1023
1024 for (c = 0; c < csize; c++) {
1025 table_base[c] = &table[c][0];
1026 }
1027
1028 MLIB_C_IMAGELOOKUPSI(mlib_d64, mlib_u16, table_base);
1029}
1030
1031/***************************************************************/
1032void mlib_ImageLookUpSI_S32_D64(const mlib_s32 *src,
1033 mlib_s32 slb,
1034 mlib_d64 *dst,
1035 mlib_s32 dlb,
1036 mlib_s32 xsize,
1037 mlib_s32 ysize,
1038 mlib_s32 csize,
1039 const mlib_d64 **table)
1040{
1041 const mlib_d64 *table_base[4];
1042 mlib_s32 c;
1043
1044 for (c = 0; c < csize; c++) {
1045 table_base[c] = &table[c][TABLE_SHIFT_S32];
1046 }
1047
1048 MLIB_C_IMAGELOOKUPSI(mlib_d64, mlib_s32, table_base);
1049}
1050
1051/***************************************************************/