Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / libcore / 319a3b994703aac84df7bcde272adfcb3cdbbbf0 / . / jdk / src / solaris / native / sun / awt / medialib / mlib_v_ImageLookUpU8S32Func.c
blob: 0247932a3819cb57266fca709c2aca7420c88ffd [file] [log] [blame]
J. Duke319a3b92007-12-01 00:00:00 +0000[diff] [blame^]1/*
2 * Copyright 1998-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#include "vis_proto.h"
29#include "mlib_image.h"
30#include "mlib_v_ImageLookUpFunc.h"
31
32/***************************************************************/
33static void mlib_v_ImageLookUp_U8_S32_124_D1(const mlib_u8 *src,
34 mlib_f32 *dst,
35 mlib_s32 xsize,
36 const mlib_f32 *table0,
37 const mlib_f32 *table1,
38 const mlib_f32 *table2,
39 const mlib_f32 *table3);
40
41static void mlib_v_ImageLookUp_U8_S32_3_D1(const mlib_u8 *src,
42 mlib_f32 *dst,
43 mlib_s32 xsize,
44 const mlib_f32 *table0,
45 const mlib_f32 *table1,
46 const mlib_f32 *table2);
47
48/***************************************************************/
49void mlib_v_ImageLookUp_U8_S32_124_D1(const mlib_u8 *src,
50 mlib_f32 *dst,
51 mlib_s32 xsize,
52 const mlib_f32 *table0,
53 const mlib_f32 *table1,
54 const mlib_f32 *table2,
55 const mlib_f32 *table3)
56{
57 mlib_u32 *sa; /* aligned pointer to source data */
58 mlib_u8 *sp; /* pointer to source data */
59 mlib_u32 s0; /* source data */
60 mlib_f32 *dp; /* aligned pointer to destination */
61 mlib_f32 acc0, acc1; /* destination data */
62 mlib_f32 acc2, acc3; /* destination data */
63 mlib_s32 i; /* loop variable */
64 mlib_u32 s00, s01, s02, s03;
65
66 sa = (mlib_u32 *) src;
67 dp = dst;
68
69 i = 0;
70
71 if (xsize >= 4) {
72
73 s0 = *sa++;
74 s00 = (s0 >> 22) & 0x3FC;
75 s01 = (s0 >> 14) & 0x3FC;
76
77#pragma pipeloop(0)
78 for (i = 0; i <= xsize - 8; i += 4, dp += 4) {
79 s02 = (s0 >> 6) & 0x3FC;
80 s03 = (s0 << 2) & 0x3FC;
81 acc0 = *(mlib_f32 *) ((mlib_u8 *) table0 + s00);
82 acc1 = *(mlib_f32 *) ((mlib_u8 *) table1 + s01);
83 acc2 = *(mlib_f32 *) ((mlib_u8 *) table2 + s02);
84 acc3 = *(mlib_f32 *) ((mlib_u8 *) table3 + s03);
85 s0 = *sa++;
86 s00 = (s0 >> 22) & 0x3FC;
87 s01 = (s0 >> 14) & 0x3FC;
88 dp[0] = acc0;
89 dp[1] = acc1;
90 dp[2] = acc2;
91 dp[3] = acc3;
92 }
93
94 s02 = (s0 >> 6) & 0x3FC;
95 s03 = (s0 << 2) & 0x3FC;
96 acc0 = *(mlib_f32 *) ((mlib_u8 *) table0 + s00);
97 acc1 = *(mlib_f32 *) ((mlib_u8 *) table1 + s01);
98 acc2 = *(mlib_f32 *) ((mlib_u8 *) table2 + s02);
99 acc3 = *(mlib_f32 *) ((mlib_u8 *) table3 + s03);
100 dp[0] = acc0;
101 dp[1] = acc1;
102 dp[2] = acc2;
103 dp[3] = acc3;
104 dp += 4;
105 i += 4;
106 }
107
108 sp = (mlib_u8 *) sa;
109
110 if (i < xsize) {
111 *dp++ = table0[sp[0]];
112 i++;
113 sp++;
114 }
115
116 if (i < xsize) {
117 *dp++ = table1[sp[0]];
118 i++;
119 sp++;
120 }
121
122 if (i < xsize) {
123 *dp++ = table2[sp[0]];
124 }
125}
126
127/***************************************************************/
128void mlib_v_ImageLookUp_U8_S32_1(const mlib_u8 *src,
129 mlib_s32 slb,
130 mlib_s32 *dst,
131 mlib_s32 dlb,
132 mlib_s32 xsize,
133 mlib_s32 ysize,
134 const mlib_s32 **table)
135{
136 mlib_u8 *sl;
137 mlib_s32 *dl;
138 mlib_f32 *tab = (mlib_f32 *) table[0];
139 mlib_s32 j, i;
140
141 sl = (void *)src;
142 dl = dst;
143
144 /* row loop */
145 for (j = 0; j < ysize; j++) {
146 mlib_u8 *sp = sl;
147 mlib_f32 *dp = (mlib_f32 *) dl;
148 mlib_s32 off, size = xsize;
149
150 off = (mlib_s32) ((4 - ((mlib_addr) sp & 3)) & 3);
151
152 off = (off < size) ? off : size;
153
154 for (i = 0; i < off; i++) {
155 *dp++ = tab[(*sp++)];
156 size--;
157 }
158
159 if (size > 0) {
160 mlib_v_ImageLookUp_U8_S32_124_D1(sp, dp, size, tab, tab, tab, tab);
161 }
162
163 sl = (mlib_u8 *) ((mlib_u8 *) sl + slb);
164 dl = (mlib_s32 *) ((mlib_u8 *) dl + dlb);
165 }
166}
167
168/***************************************************************/
169void mlib_v_ImageLookUp_U8_S32_2(const mlib_u8 *src,
170 mlib_s32 slb,
171 mlib_s32 *dst,
172 mlib_s32 dlb,
173 mlib_s32 xsize,
174 mlib_s32 ysize,
175 const mlib_s32 **table)
176{
177 mlib_u8 *sl;
178 mlib_s32 *dl;
179 mlib_f32 *tab;
180 mlib_s32 j, i;
181
182 sl = (void *)src;
183 dl = dst;
184
185 /* row loop */
186 for (j = 0; j < ysize; j++) {
187 mlib_u8 *sp = sl;
188 mlib_f32 *dp = (mlib_f32 *) dl;
189 mlib_s32 off, size = xsize * 2;
190 mlib_f32 *tab0 = (mlib_f32 *) table[0];
191 mlib_f32 *tab1 = (mlib_f32 *) table[1];
192
193 off = (mlib_s32) ((4 - ((mlib_addr) sp & 3)) & 3);
194
195 off = (off < size) ? off : size;
196
197 for (i = 0; i < off - 1; i += 2) {
198 *dp++ = tab0[(*sp++)];
199 *dp++ = tab1[(*sp++)];
200 size -= 2;
201 }
202
203 if ((off & 1) != 0) {
204 *dp++ = tab0[(*sp++)];
205 size--;
206 tab = tab0;
207 tab0 = tab1;
208 tab1 = tab;
209 }
210
211 if (size > 0) {
212 mlib_v_ImageLookUp_U8_S32_124_D1(sp, dp, size, tab0, tab1, tab0, tab1);
213 }
214
215 sl = (mlib_u8 *) ((mlib_u8 *) sl + slb);
216 dl = (mlib_s32 *) ((mlib_u8 *) dl + dlb);
217 }
218}
219
220/***************************************************************/
221void mlib_v_ImageLookUp_U8_S32_4(const mlib_u8 *src,
222 mlib_s32 slb,
223 mlib_s32 *dst,
224 mlib_s32 dlb,
225 mlib_s32 xsize,
226 mlib_s32 ysize,
227 const mlib_s32 **table)
228{
229 mlib_u8 *sl;
230 mlib_s32 *dl;
231 mlib_f32 *tab;
232 mlib_s32 j;
233
234 sl = (void *)src;
235 dl = dst;
236
237 /* row loop */
238 for (j = 0; j < ysize; j++) {
239 mlib_u8 *sp = sl;
240 mlib_f32 *dp = (mlib_f32 *) dl;
241 mlib_f32 *tab0 = (mlib_f32 *) table[0];
242 mlib_f32 *tab1 = (mlib_f32 *) table[1];
243 mlib_f32 *tab2 = (mlib_f32 *) table[2];
244 mlib_f32 *tab3 = (mlib_f32 *) table[3];
245 mlib_s32 off, size = xsize * 4;
246
247 off = (mlib_s32) ((4 - ((mlib_addr) sp & 3)) & 3);
248
249 off = (off < size) ? off : size;
250
251 if (off == 1) {
252 *dp++ = tab0[(*sp++)];
253 tab = tab0;
254 tab0 = tab1;
255 tab1 = tab2;
256 tab2 = tab3;
257 tab3 = tab;
258 size--;
259 }
260 else if (off == 2) {
261 *dp++ = tab0[(*sp++)];
262 *dp++ = tab1[(*sp++)];
263 tab = tab0;
264 tab0 = tab2;
265 tab2 = tab;
266 tab = tab1;
267 tab1 = tab3;
268 tab3 = tab;
269 size -= 2;
270 }
271 else if (off == 3) {
272 *dp++ = tab0[(*sp++)];
273 *dp++ = tab1[(*sp++)];
274 *dp++ = tab2[(*sp++)];
275 tab = tab3;
276 tab3 = tab2;
277 tab2 = tab1;
278 tab1 = tab0;
279 tab0 = tab;
280 size -= 3;
281 }
282
283 if (size > 0) {
284 mlib_v_ImageLookUp_U8_S32_124_D1(sp, dp, size, tab0, tab1, tab2, tab3);
285 }
286
287 sl = (mlib_u8 *) ((mlib_u8 *) sl + slb);
288 dl = (mlib_s32 *) ((mlib_u8 *) dl + dlb);
289 }
290}
291
292/***************************************************************/
293void mlib_v_ImageLookUp_U8_S32_3_D1(const mlib_u8 *src,
294 mlib_f32 *dst,
295 mlib_s32 xsize,
296 const mlib_f32 *table0,
297 const mlib_f32 *table1,
298 const mlib_f32 *table2)
299{
300 mlib_u32 *sa; /* aligned pointer to source data */
301 mlib_u8 *sp; /* pointer to source data */
302 mlib_u32 s0; /* source data */
303 mlib_f32 *dp; /* aligned pointer to destination */
304 mlib_f32 acc0, acc1; /* destination data */
305 mlib_f32 acc2, acc3; /* destination data */
306 mlib_s32 i; /* loop variable */
307 const mlib_f32 *table;
308 mlib_u32 s00, s01, s02, s03;
309
310 sa = (mlib_u32 *) src;
311 dp = dst;
312
313 i = 0;
314
315 if (xsize >= 4) {
316
317 s0 = *sa++;
318 s00 = (s0 >> 22) & 0x3FC;
319 s01 = (s0 >> 14) & 0x3FC;
320
321#pragma pipeloop(0)
322 for (i = 0; i <= xsize - 8; i += 4, dp += 4) {
323 s02 = (s0 >> 6) & 0x3FC;
324 s03 = (s0 << 2) & 0x3FC;
325 acc0 = *(mlib_f32 *) ((mlib_u8 *) table0 + s00);
326 acc1 = *(mlib_f32 *) ((mlib_u8 *) table1 + s01);
327 acc2 = *(mlib_f32 *) ((mlib_u8 *) table2 + s02);
328 acc3 = *(mlib_f32 *) ((mlib_u8 *) table0 + s03);
329 s0 = *sa++;
330 s00 = (s0 >> 22) & 0x3FC;
331 s01 = (s0 >> 14) & 0x3FC;
332 table = table0;
333 table0 = table1;
334 table1 = table2;
335 table2 = table;
336 dp[0] = acc0;
337 dp[1] = acc1;
338 dp[2] = acc2;
339 dp[3] = acc3;
340 }
341
342 s02 = (s0 >> 6) & 0x3FC;
343 s03 = (s0 << 2) & 0x3FC;
344 acc0 = *(mlib_f32 *) ((mlib_u8 *) table0 + s00);
345 acc1 = *(mlib_f32 *) ((mlib_u8 *) table1 + s01);
346 acc2 = *(mlib_f32 *) ((mlib_u8 *) table2 + s02);
347 acc3 = *(mlib_f32 *) ((mlib_u8 *) table0 + s03);
348 dp[0] = acc0;
349 dp[1] = acc1;
350 dp[2] = acc2;
351 dp[3] = acc3;
352 table = table0;
353 table0 = table1;
354 table1 = table2;
355 table2 = table;
356 dp += 4;
357 i += 4;
358 }
359
360 sp = (mlib_u8 *) sa;
361
362 if (i < xsize) {
363 *dp++ = table0[sp[0]];
364 i++;
365 sp++;
366 }
367
368 if (i < xsize) {
369 *dp++ = table1[sp[0]];
370 i++;
371 sp++;
372 }
373
374 if (i < xsize) {
375 *dp++ = table2[sp[0]];
376 }
377}
378
379/***************************************************************/
380void mlib_v_ImageLookUp_U8_S32_3(const mlib_u8 *src,
381 mlib_s32 slb,
382 mlib_s32 *dst,
383 mlib_s32 dlb,
384 mlib_s32 xsize,
385 mlib_s32 ysize,
386 const mlib_s32 **table)
387{
388 mlib_u8 *sl;
389 mlib_s32 *dl;
390 mlib_f32 *tab;
391 mlib_s32 j;
392
393 sl = (void *)src;
394 dl = dst;
395
396 /* row loop */
397 for (j = 0; j < ysize; j++) {
398 mlib_u8 *sp = sl;
399 mlib_f32 *dp = (mlib_f32 *) dl;
400 mlib_f32 *tab0 = (mlib_f32 *) table[0];
401 mlib_f32 *tab1 = (mlib_f32 *) table[1];
402 mlib_f32 *tab2 = (mlib_f32 *) table[2];
403 mlib_s32 off, size = xsize * 3;
404
405 off = (mlib_s32) ((4 - ((mlib_addr) sp & 3)) & 3);
406
407 off = (off < size) ? off : size;
408
409 if (off == 1) {
410 *dp++ = tab0[(*sp++)];
411 tab = tab0;
412 tab0 = tab1;
413 tab1 = tab2;
414 tab2 = tab;
415 size--;
416 }
417 else if (off == 2) {
418 *dp++ = tab0[(*sp++)];
419 *dp++ = tab1[(*sp++)];
420 tab = tab2;
421 tab2 = tab1;
422 tab1 = tab0;
423 tab0 = tab;
424 size -= 2;
425 }
426 else if (off == 3) {
427 *dp++ = tab0[(*sp++)];
428 *dp++ = tab1[(*sp++)];
429 *dp++ = tab2[(*sp++)];
430 size -= 3;
431 }
432
433 if (size > 0) {
434 mlib_v_ImageLookUp_U8_S32_3_D1(sp, dp, size, tab0, tab1, tab2);
435 }
436
437 sl = (mlib_u8 *) ((mlib_u8 *) sl + slb);
438 dl = (mlib_s32 *) ((mlib_u8 *) dl + dlb);
439 }
440}
441
442/***************************************************************/