1 /*
2 * Copyright (c) 1998, 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
28 /*
29 * The functions step along the lines from xLeft to xRight and apply
30 * the bilinear filtering.
31 *
32 */
33
34 #include "vis_proto.h"
35 #include "mlib_image.h"
36 #include "mlib_ImageColormap.h"
37 #include "mlib_ImageCopy.h"
38 #include "mlib_ImageAffine.h"
39 #include "mlib_v_ImageFilters.h"
40 #include "mlib_v_ImageChannelExtract.h"
41
42 /***************************************************************/
43 /*#define MLIB_VIS2*/
44
45 /***************************************************************/
46 #define DTYPE mlib_u8
47
48 #define FUN_NAME(CHAN) mlib_ImageAffine_u8_##CHAN##_bl
49
50 /***************************************************************/
51 static mlib_status FUN_NAME(2ch_na)(mlib_affine_param *param);
52 static mlib_status FUN_NAME(4ch_na)(mlib_affine_param *param);
53
54 /***************************************************************/
55 #ifdef MLIB_VIS2
56 #define MLIB_WRITE_BMASK(bmask) vis_write_bmask(bmask, 0)
57 #else
58 #define MLIB_WRITE_BMASK(bmask)
59 #endif /* MLIB_VIS2 */
60
61 /***************************************************************/
62 #define FILTER_BITS 8
63
64 /***************************************************************/
65 #undef DECLAREVAR
66 #define DECLAREVAR() \
67 DECLAREVAR0(); \
68 mlib_s32 *warp_tbl = param -> warp_tbl; \
69 mlib_s32 srcYStride = param -> srcYStride; \
70 mlib_u8 *dl; \
71 mlib_s32 i, size; \
72 mlib_d64 k05 = vis_to_double_dup(0x00080008); \
73 mlib_d64 d0, d1, d2, d3, dd
74
75 /***************************************************************/
76 #define FMUL_16x16(x, y) \
77 vis_fpadd16(vis_fmul8sux16(x, y), vis_fmul8ulx16(x, y))
78
79 /***************************************************************/
80 #define BUF_SIZE 512
81
82 /***************************************************************/
83 const mlib_u32 mlib_fmask_arr[] = {
84 0x00000000, 0x000000FF, 0x0000FF00, 0x0000FFFF,
85 0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00FFFFFF,
86 0xFF000000, 0xFF0000FF, 0xFF00FF00, 0xFF00FFFF,
87 0xFFFF0000, 0xFFFF00FF, 0xFFFFFF00, 0xFFFFFFFF
88 };
89
90 /***************************************************************/
91 #define DOUBLE_4U16(x0, x1, x2, x3) \
92 vis_to_double((((x0 & 0xFFFE) << 15) | ((x1 & 0xFFFE) >> 1)), \
93 (((x2 & 0xFFFE) << 15) | ((x3 & 0xFFFE) >> 1)))
94
95 /***************************************************************/
96 #define BL_SUM(HL) \
97 delta1_x = vis_fpsub16(mask_7fff, deltax); \
98 delta1_y = vis_fpsub16(mask_7fff, deltay); \
99 \
100 d0 = vis_fmul8x16(vis_read_##HL(s0), delta1_x); \
101 d1 = vis_fmul8x16(vis_read_##HL(s1), deltax); \
102 d0 = vis_fpadd16(d0, d1); \
103 d0 = FMUL_16x16(d0, delta1_y); \
104 d2 = vis_fmul8x16(vis_read_##HL(s2), delta1_x); \
105 d3 = vis_fmul8x16(vis_read_##HL(s3), deltax); \
106 d2 = vis_fpadd16(d2, d3); \
107 d2 = FMUL_16x16(d2, deltay); \
108 dd = vis_fpadd16(d0, d2); \
109 dd = vis_fpadd16(dd, k05); \
110 df = vis_fpack16(dd); \
111 \
112 deltax = vis_fpadd16(deltax, dx64); \
113 deltay = vis_fpadd16(deltay, dy64); \
114 deltax = vis_fand(deltax, mask_7fff); \
115 deltay = vis_fand(deltay, mask_7fff)
116
117 /***************************************************************/
118 #define GET_FILTER_XY() \
119 mlib_d64 filterx, filtery, filterxy; \
120 mlib_s32 filterpos; \
121 filterpos = (X >> FILTER_SHIFT) & FILTER_MASK; \
122 filterx = *((mlib_d64 *) ((mlib_u8 *) mlib_filters_u8_bl + \
123 filterpos)); \
124 filterpos = (Y >> FILTER_SHIFT) & FILTER_MASK; \
125 filtery = *((mlib_d64 *) ((mlib_u8 *) mlib_filters_u8_bl + \
126 filterpos + 8*FILTER_SIZE)); \
127 filterxy = FMUL_16x16(filterx, filtery)
128
129 /***************************************************************/
130 #define LD_U8(sp, ind) vis_read_lo(vis_ld_u8(sp + ind))
131 #define LD_U16(sp, ind) vis_ld_u16(sp + ind)
132
133 /***************************************************************/
134 #define LOAD_1CH() \
135 s0 = vis_fpmerge(LD_U8(sp0, 0), LD_U8(sp2, 0)); \
136 s1 = vis_fpmerge(LD_U8(sp0, 1), LD_U8(sp2, 1)); \
137 s2 = vis_fpmerge(LD_U8(sp0, srcYStride), LD_U8(sp2, srcYStride)); \
138 s3 = vis_fpmerge(LD_U8(sp0, srcYStride + 1), \
139 LD_U8(sp2, srcYStride + 1)); \
140 \
141 t0 = vis_fpmerge(LD_U8(sp1, 0), LD_U8(sp3, 0)); \
142 t1 = vis_fpmerge(LD_U8(sp1, 1), LD_U8(sp3, 1)); \
143 t2 = vis_fpmerge(LD_U8(sp1, srcYStride), LD_U8(sp3, srcYStride)); \
144 t3 = vis_fpmerge(LD_U8(sp1, srcYStride + 1), \
145 LD_U8(sp3, srcYStride + 1)); \
146 \
147 s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(t0)); \
148 s1 = vis_fpmerge(vis_read_lo(s1), vis_read_lo(t1)); \
149 s2 = vis_fpmerge(vis_read_lo(s2), vis_read_lo(t2)); \
150 s3 = vis_fpmerge(vis_read_lo(s3), vis_read_lo(t3))
151
152 /***************************************************************/
153 #define GET_POINTER(sp) \
154 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + \
155 (X >> MLIB_SHIFT); \
156 X += dX; \
157 Y += dY
158
159 /***************************************************************/
160 #undef PREPARE_DELTAS
161 #define PREPARE_DELTAS \
162 if (warp_tbl != NULL) { \
163 dX = warp_tbl[2*j ]; \
164 dY = warp_tbl[2*j + 1]; \
165 dx64 = vis_to_double_dup((((dX << 1) & 0xFFFF) << 16) | ((dX << 1) & 0xFFFF)); \
166 dy64 = vis_to_double_dup((((dY << 1) & 0xFFFF) << 16) | ((dY << 1) & 0xFFFF)); \
167 }
168
169 /***************************************************************/
170 mlib_status FUN_NAME(1ch)(mlib_affine_param *param)
171 {
172 DECLAREVAR();
173 mlib_d64 mask_7fff = vis_to_double_dup(0x7FFF7FFF);
174 mlib_d64 dx64, dy64, deltax, deltay, delta1_x, delta1_y;
175 mlib_s32 off, x0, x1, x2, x3, y0, y1, y2, y3;
176 mlib_f32 *dp, fmask;
177
178 vis_write_gsr((1 << 3) | 7);
179
180 dx64 = vis_to_double_dup((((dX << 1) & 0xFFFF) << 16) | ((dX << 1) & 0xFFFF));
181 dy64 = vis_to_double_dup((((dY << 1) & 0xFFFF) << 16) | ((dY << 1) & 0xFFFF));
182
183 for (j = yStart; j <= yFinish; j++) {
184 mlib_u8 *sp0, *sp1, *sp2, *sp3;
185 mlib_d64 s0, s1, s2, s3, t0, t1, t2, t3;
186 mlib_f32 df;
187
188 NEW_LINE(1);
189
190 off = (mlib_s32)dl & 3;
191 dp = (mlib_f32*)(dl - off);
192
193 x0 = X - off*dX; y0 = Y - off*dY;
194 x1 = x0 + dX; y1 = y0 + dY;
195 x2 = x1 + dX; y2 = y1 + dY;
196 x3 = x2 + dX; y3 = y2 + dY;
197
198 deltax = DOUBLE_4U16(x0, x1, x2, x3);
199 deltay = DOUBLE_4U16(y0, y1, y2, y3);
200
201 if (off) {
202 mlib_s32 emask = vis_edge16((void*)(2*off), (void*)(2*(off + size - 1)));
203
204 off = 4 - off;
205 GET_POINTER(sp3);
206 sp0 = sp1 = sp2 = sp3;
207
208 if (off > 1 && size > 1) {
209 GET_POINTER(sp3);
210 }
211
212 if (off > 2) {
213 sp2 = sp3;
214
215 if (size > 2) {
216 GET_POINTER(sp3);
217 }
218 }
219
220 LOAD_1CH();
221 BL_SUM(lo);
222
223 fmask = ((mlib_f32*)mlib_fmask_arr)[emask];
224 *dp++ = vis_fors(vis_fands(fmask, df), vis_fandnots(fmask, dp[0]));
225
226 size -= off;
227
228 if (size < 0) size = 0;
229 }
230
231 #pragma pipeloop(0)
232 for (i = 0; i < size/4; i++) {
233 GET_POINTER(sp0);
234 GET_POINTER(sp1);
235 GET_POINTER(sp2);
236 GET_POINTER(sp3);
237
238 LOAD_1CH();
239 BL_SUM(lo);
240
241 dp[i] = df;
242 }
243
244 off = size & 3;
245
246 if (off) {
247 GET_POINTER(sp0);
248 sp1 = sp2 = sp3 = sp0;
249
250 if (off > 1) {
251 GET_POINTER(sp1);
252 }
253
254 if (off > 2) {
255 GET_POINTER(sp2);
256 }
257
258 LOAD_1CH();
259 BL_SUM(lo);
260
261 fmask = ((mlib_f32*)mlib_fmask_arr)[(0xF0 >> off) & 0x0F];
262 dp[i] = vis_fors(vis_fands(fmask, df), vis_fandnots(fmask, dp[i]));
263 }
264 }
265
266 return MLIB_SUCCESS;
267 }
268
269 /***************************************************************/
270 #undef GET_POINTER
271 #define GET_POINTER(sp) \
272 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + \
273 2*(X >> MLIB_SHIFT); \
274 X += dX; \
275 Y += dY
276
277 /***************************************************************/
278 #ifndef MLIB_VIS2
279
280 #define LOAD_2CH() \
281 s0 = vis_faligndata(LD_U16(sp1, 0), k05); \
282 s1 = vis_faligndata(LD_U16(sp1, 2), k05); \
283 s2 = vis_faligndata(LD_U16(sp1, srcYStride), k05); \
284 s3 = vis_faligndata(LD_U16(sp1, srcYStride + 2), k05); \
285 \
286 s0 = vis_faligndata(LD_U16(sp0, 0), s0); \
287 s1 = vis_faligndata(LD_U16(sp0, 2), s1); \
288 s2 = vis_faligndata(LD_U16(sp0, srcYStride), s2); \
289 s3 = vis_faligndata(LD_U16(sp0, srcYStride + 2), s3)
290
291 #define BL_SUM_2CH() BL_SUM(hi)
292
293 #else
294
295 #define LOAD_2CH() \
296 s0 = vis_bshuffle(LD_U16(sp0, 0), LD_U16(sp1, 0)); \
297 s1 = vis_bshuffle(LD_U16(sp0, 2), LD_U16(sp1, 2)); \
298 s2 = vis_bshuffle(LD_U16(sp0, srcYStride), \
299 LD_U16(sp1, srcYStride)); \
300 s3 = vis_bshuffle(LD_U16(sp0, srcYStride + 2), \
301 LD_U16(sp1, srcYStride + 2))
302
303 #define BL_SUM_2CH() BL_SUM(lo)
304
305 #endif /* MLIB_VIS2 */
306
307 /***************************************************************/
308 #undef PREPARE_DELTAS
309 #define PREPARE_DELTAS \
310 if (warp_tbl != NULL) { \
311 dX = warp_tbl[2*j ]; \
312 dY = warp_tbl[2*j + 1]; \
313 dx64 = vis_to_double_dup(((dX & 0xFFFF) << 16) | (dX & 0xFFFF)); \
314 dy64 = vis_to_double_dup(((dY & 0xFFFF) << 16) | (dY & 0xFFFF)); \
315 }
316
317 /***************************************************************/
318 mlib_status FUN_NAME(2ch)(mlib_affine_param *param)
319 {
320 DECLAREVAR();
321 mlib_d64 mask_7fff = vis_to_double_dup(0x7FFF7FFF);
322 mlib_d64 dx64, dy64, deltax, deltay, delta1_x, delta1_y;
323 mlib_s32 off, x0, x1, y0, y1;
324
325 if (((mlib_s32)lineAddr[0] | (mlib_s32)dstData | srcYStride | dstYStride) & 1) {
326 return FUN_NAME(2ch_na)(param);
327 }
328
329 vis_write_gsr((1 << 3) | 6);
330 MLIB_WRITE_BMASK(0x45cd67ef);
331
332 dx64 = vis_to_double_dup(((dX & 0xFFFF) << 16) | (dX & 0xFFFF));
333 dy64 = vis_to_double_dup(((dY & 0xFFFF) << 16) | (dY & 0xFFFF));
334
335 for (j = yStart; j <= yFinish; j++) {
336 mlib_u8 *sp0, *sp1;
337 mlib_d64 s0, s1, s2, s3;
338 mlib_f32 *dp, df, fmask;
339
340 NEW_LINE(2);
341
342 off = (mlib_s32)dl & 3;
343 dp = (mlib_f32*)(dl - off);
344
345 if (off) {
346 x0 = X - dX; y0 = Y - dY;
347 x1 = X; y1 = Y;
348 } else {
349 x0 = X; y0 = Y;
350 x1 = X + dX; y1 = Y + dY;
351 }
352
353 deltax = DOUBLE_4U16(x0, x0, x1, x1);
354 deltay = DOUBLE_4U16(y0, y0, y1, y1);
355
356 if (off) {
357 GET_POINTER(sp1);
358 sp0 = sp1;
359 LOAD_2CH();
360
361 BL_SUM_2CH();
362
363 fmask = ((mlib_f32*)mlib_fmask_arr)[0x3];
364 *dp++ = vis_fors(vis_fands(fmask, df), vis_fandnots(fmask, dp[0]));
365
366 size--;
367 }
368
369 if (size >= 2) {
370 GET_POINTER(sp0);
371 GET_POINTER(sp1);
372 LOAD_2CH();
373
374 #pragma pipeloop(0)
375 for (i = 0; i < (size - 2)/2; i++) {
376 BL_SUM_2CH();
377
378 GET_POINTER(sp0);
379 GET_POINTER(sp1);
380 LOAD_2CH();
381
382 *dp++ = df;
383 }
384
385 BL_SUM_2CH();
386 *dp++ = df;
387 }
388
389 if (size & 1) {
390 GET_POINTER(sp0);
391 sp1 = sp0;
392 LOAD_2CH();
393
394 BL_SUM_2CH();
395
396 fmask = ((mlib_f32*)mlib_fmask_arr)[0x0C];
397 *dp = vis_fors(vis_fands(fmask, df), vis_fandnots(fmask, *dp));
398 }
399 }
400
401 return MLIB_SUCCESS;
402 }
403
404 /***************************************************************/
405 #ifndef MLIB_VIS2
406
407 #define LOAD_2CH_NA() \
408 s0 = vis_fpmerge(LD_U8(sp0, 0), LD_U8(sp1, 0)); \
409 s1 = vis_fpmerge(LD_U8(sp0, 2), LD_U8(sp1, 2)); \
410 s2 = vis_fpmerge(LD_U8(sp0, srcYStride), \
411 LD_U8(sp1, srcYStride)); \
412 s3 = vis_fpmerge(LD_U8(sp0, srcYStride + 2), \
413 LD_U8(sp1, srcYStride + 2)); \
414 \
415 t0 = vis_fpmerge(LD_U8(sp0, 1), LD_U8(sp1, 1)); \
416 t1 = vis_fpmerge(LD_U8(sp0, 3), LD_U8(sp1, 3)); \
417 t2 = vis_fpmerge(LD_U8(sp0, srcYStride + 1), \
418 LD_U8(sp1, srcYStride + 1)); \
419 t3 = vis_fpmerge(LD_U8(sp0, srcYStride + 3), \
420 LD_U8(sp1, srcYStride + 3)); \
421 \
422 s0 = vis_fpmerge(vis_read_lo(s0), vis_read_lo(t0)); \
423 s1 = vis_fpmerge(vis_read_lo(s1), vis_read_lo(t1)); \
424 s2 = vis_fpmerge(vis_read_lo(s2), vis_read_lo(t2)); \
425 s3 = vis_fpmerge(vis_read_lo(s3), vis_read_lo(t3))
426
427 #define BL_SUM_2CH_NA() BL_SUM(lo)
428
429 #else
430
431 #define LOAD_2CH_NA() \
432 vis_alignaddr(sp0, 0); \
433 spa = AL_ADDR(sp0, 0); \
434 s0 = vis_faligndata(spa[0], spa[1]); \
435 \
436 vis_alignaddr(sp1, 0); \
437 spa = AL_ADDR(sp1, 0); \
438 s1 = vis_faligndata(spa[0], spa[1]); \
439 \
440 vis_alignaddr(sp0, srcYStride); \
441 spa = AL_ADDR(sp0, srcYStride); \
442 s2 = vis_faligndata(spa[0], spa[1]); \
443 \
444 vis_alignaddr(sp1, srcYStride); \
445 spa = AL_ADDR(sp1, srcYStride); \
446 s3 = vis_faligndata(spa[0], spa[1]); \
447 \
448 s0 = vis_bshuffle(s0, s1); \
449 s2 = vis_bshuffle(s2, s3)
450
451 #define BL_SUM_2CH_NA() \
452 delta1_x = vis_fpsub16(mask_7fff, deltax); \
453 delta1_y = vis_fpsub16(mask_7fff, deltay); \
454 \
455 d0 = vis_fmul8x16(vis_read_hi(s0), delta1_x); \
456 d1 = vis_fmul8x16(vis_read_lo(s0), deltax); \
457 d0 = vis_fpadd16(d0, d1); \
458 d0 = FMUL_16x16(d0, delta1_y); \
459 d2 = vis_fmul8x16(vis_read_hi(s2), delta1_x); \
460 d3 = vis_fmul8x16(vis_read_lo(s2), deltax); \
461 d2 = vis_fpadd16(d2, d3); \
462 d2 = FMUL_16x16(d2, deltay); \
463 dd = vis_fpadd16(d0, d2); \
464 dd = vis_fpadd16(dd, k05); \
465 df = vis_fpack16(dd); \
466 \
467 deltax = vis_fpadd16(deltax, dx64); \
468 deltay = vis_fpadd16(deltay, dy64); \
469 deltax = vis_fand(deltax, mask_7fff); \
470 deltay = vis_fand(deltay, mask_7fff)
471
472 #endif /* MLIB_VIS2 */
473
474 /***************************************************************/
475 mlib_status FUN_NAME(2ch_na)(mlib_affine_param *param)
476 {
477 DECLAREVAR();
478 mlib_d64 mask_7fff = vis_to_double_dup(0x7FFF7FFF);
479 mlib_d64 dx64, dy64, deltax, deltay, delta1_x, delta1_y;
480 mlib_s32 max_xsize = param -> max_xsize, bsize;
481 mlib_s32 x0, x1, y0, y1;
482 mlib_f32 buff[BUF_SIZE], *pbuff = buff;
483
484 bsize = (max_xsize + 1)/2;
485
486 if (bsize > BUF_SIZE) {
487 pbuff = mlib_malloc(bsize*sizeof(mlib_f32));
488
489 if (pbuff == NULL) return MLIB_FAILURE;
490 }
491
492 vis_write_gsr((1 << 3) | 6);
493 MLIB_WRITE_BMASK(0x018923AB);
494
495 dx64 = vis_to_double_dup(((dX & 0xFFFF) << 16) | (dX & 0xFFFF));
496 dy64 = vis_to_double_dup(((dY & 0xFFFF) << 16) | (dY & 0xFFFF));
497
498 for (j = yStart; j <= yFinish; j++) {
499 mlib_u8 *sp0, *sp1;
500 mlib_d64 s0, s1, s2, s3;
501 #ifndef MLIB_VIS2
502 mlib_d64 t0, t1, t2, t3;
503 #else
504 mlib_d64 *spa;
505 #endif /* MLIB_VIS2 */
506 mlib_f32 *dp, df;
507
508 NEW_LINE(2);
509
510 dp = pbuff;
511
512 x0 = X; y0 = Y;
513 x1 = X + dX; y1 = Y + dY;
514
515 deltax = DOUBLE_4U16(x0, x0, x1, x1);
516 deltay = DOUBLE_4U16(y0, y0, y1, y1);
517
518 #pragma pipeloop(0)
519 for (i = 0; i < size/2; i++) {
520 GET_POINTER(sp0);
521 GET_POINTER(sp1);
522 LOAD_2CH_NA();
523
524 BL_SUM_2CH_NA();
525
526 *dp++ = df;
527 }
528
529 if (size & 1) {
530 GET_POINTER(sp0);
531 sp1 = sp0;
532 LOAD_2CH_NA();
533
534 BL_SUM_2CH_NA();
535
536 *dp++ = df;
537 }
538
539 mlib_ImageCopy_na((mlib_u8*)pbuff, dl, 2*size);
540 }
541
542 if (pbuff != buff) {
543 mlib_free(pbuff);
544 }
545
546 return MLIB_SUCCESS;
547 }
548
549 /***************************************************************/
550 #undef PREPARE_DELTAS
551 #define PREPARE_DELTAS \
552 if (warp_tbl != NULL) { \
553 dX = warp_tbl[2*j ]; \
554 dY = warp_tbl[2*j + 1]; \
555 }
556
557 /***************************************************************/
558 mlib_status FUN_NAME(3ch)(mlib_affine_param *param)
559 {
560 DECLAREVAR();
561 mlib_s32 max_xsize = param -> max_xsize;
562 mlib_f32 buff[BUF_SIZE], *pbuff = buff;
563
564 if (max_xsize > BUF_SIZE) {
565 pbuff = mlib_malloc(max_xsize*sizeof(mlib_f32));
566
567 if (pbuff == NULL) return MLIB_FAILURE;
568 }
569
570 vis_write_gsr(3 << 3);
571
572 for (j = yStart; j <= yFinish; j++) {
573 mlib_d64 *sp0, *sp1, s0, s1;
574 mlib_u8 *sp;
575
576 NEW_LINE(3);
577
578 #pragma pipeloop(0)
579 for (i = 0; i < size; i++) {
580 GET_FILTER_XY();
581
582 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + 3*(X >> MLIB_SHIFT) - 1;
583
584 vis_alignaddr(sp, 0);
585 sp0 = AL_ADDR(sp, 0);
586 s0 = vis_faligndata(sp0[0], sp0[1]);
587 d0 = vis_fmul8x16au(vis_read_hi(s0), vis_read_hi(filterxy));
588 d1 = vis_fmul8x16al(vis_read_lo(s0), vis_read_hi(filterxy));
589
590 vis_alignaddr(sp, srcYStride);
591 sp1 = AL_ADDR(sp, srcYStride);
592 s1 = vis_faligndata(sp1[0], sp1[1]);
593 d2 = vis_fmul8x16au(vis_read_hi(s1), vis_read_lo(filterxy));
594 d3 = vis_fmul8x16al(vis_read_lo(s1), vis_read_lo(filterxy));
595
596 vis_alignaddr((void*)0, 2);
597 d0 = vis_fpadd16(d0, d2);
598 dd = vis_fpadd16(k05, d1);
599 dd = vis_fpadd16(dd, d3);
600 d0 = vis_faligndata(d0, d0);
601 dd = vis_fpadd16(dd, d0);
602
603 pbuff[i] = vis_fpack16(dd);
604 X += dX;
605 Y += dY;
606 }
607
608 mlib_v_ImageChannelExtract_U8_43L_D1((mlib_u8*)pbuff, dl, size);
609 }
610
611 if (pbuff != buff) {
612 mlib_free(pbuff);
613 }
614
615 return MLIB_SUCCESS;
616 }
617
618 /***************************************************************/
619 #define PROCESS_4CH(s0, s1, s2, s3) \
620 d0 = vis_fmul8x16au(s0, vis_read_hi(filterxy)); \
621 d1 = vis_fmul8x16al(s1, vis_read_hi(filterxy)); \
622 d2 = vis_fmul8x16au(s2, vis_read_lo(filterxy)); \
623 d3 = vis_fmul8x16al(s3, vis_read_lo(filterxy)); \
624 \
625 dd = vis_fpadd16(d0, k05); \
626 d1 = vis_fpadd16(d1, d2); \
627 dd = vis_fpadd16(dd, d3); \
628 dd = vis_fpadd16(dd, d1)
629
630 /***************************************************************/
631 mlib_status FUN_NAME(4ch)(mlib_affine_param *param)
632 {
633 DECLAREVAR();
634
635 if (((mlib_s32)lineAddr[0] | (mlib_s32)dstData | srcYStride | dstYStride) & 3) {
636 return FUN_NAME(4ch_na)(param);
637 }
638
639 vis_write_gsr(3 << 3);
640
641 srcYStride >>= 2;
642
643 for (j = yStart; j <= yFinish; j++) {
644 mlib_f32 *sp, s0, s1, s2, s3;
645
646 NEW_LINE(4);
647
648 #pragma pipeloop(0)
649 for (i = 0; i < size; i++) {
650 GET_FILTER_XY();
651
652 sp = *(mlib_f32**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + (X >> MLIB_SHIFT);
653 s0 = sp[0];
654 s1 = sp[1];
655 s2 = sp[srcYStride];
656 s3 = sp[srcYStride + 1];
657
658 PROCESS_4CH(s0, s1, s2, s3);
659
660 ((mlib_f32*)dl)[i] = vis_fpack16(dd);
661 X += dX;
662 Y += dY;
663 }
664 }
665
666 return MLIB_SUCCESS;
667 }
668
669 /***************************************************************/
670 mlib_status FUN_NAME(4ch_na)(mlib_affine_param *param)
671 {
672 DECLAREVAR();
673 mlib_s32 max_xsize = param -> max_xsize;
674 mlib_f32 buff[BUF_SIZE], *pbuff = buff;
675
676 if (max_xsize > BUF_SIZE) {
677 pbuff = mlib_malloc(max_xsize*sizeof(mlib_f32));
678
679 if (pbuff == NULL) return MLIB_FAILURE;
680 }
681
682 vis_write_gsr(3 << 3);
683
684 for (j = yStart; j <= yFinish; j++) {
685 mlib_d64 *sp0, *sp1, s0, s1;
686 mlib_u8 *sp;
687
688 NEW_LINE(4);
689
690 #pragma pipeloop(0)
691 for (i = 0; i < size; i++) {
692 GET_FILTER_XY();
693
694 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + 4*(X >> MLIB_SHIFT);
695
696 vis_alignaddr(sp, 0);
697 sp0 = AL_ADDR(sp, 0);
698 s0 = vis_faligndata(sp0[0], sp0[1]);
699
700 vis_alignaddr(sp, srcYStride);
701 sp1 = AL_ADDR(sp, srcYStride);
702 s1 = vis_faligndata(sp1[0], sp1[1]);
703
704 PROCESS_4CH(vis_read_hi(s0), vis_read_lo(s0), vis_read_hi(s1), vis_read_lo(s1));
705
706 pbuff[i] = vis_fpack16(dd);
707 X += dX;
708 Y += dY;
709 }
710
711 mlib_ImageCopy_na((mlib_u8*)pbuff, dl, 4*size);
712 }
713
714 if (pbuff != buff) {
715 mlib_free(pbuff);
716 }
717
718 return MLIB_SUCCESS;
719 }
720
721 /***************************************************************/
722 #define LUT(x) plut[x]
723
FUN_NAME(u8_i)724 mlib_status FUN_NAME(u8_i)(mlib_affine_param *param,
725 const void *colormap)
726 {
727 DECLAREVAR();
728 mlib_s32 nchan = mlib_ImageGetLutChannels(colormap);
729 mlib_s32 lut_off = mlib_ImageGetLutOffset(colormap);
730 mlib_f32 *plut = (mlib_f32*)mlib_ImageGetLutNormalTable(colormap) - lut_off;
731 mlib_s32 max_xsize = param -> max_xsize;
732 mlib_f32 buff[BUF_SIZE], *pbuff = buff;
733
734 if (max_xsize > BUF_SIZE) {
735 pbuff = mlib_malloc(max_xsize*sizeof(mlib_f32));
736
737 if (pbuff == NULL) return MLIB_FAILURE;
738 }
739
740 vis_write_gsr(3 << 3);
741
742 for (j = yStart; j <= yFinish; j++) {
743 mlib_f32 s0, s1, s2, s3;
744 DTYPE *sp;
745
746 NEW_LINE(1);
747
748 #pragma pipeloop(0)
749 for (i = 0; i < size; i++) {
750 GET_FILTER_XY();
751
752 sp = *(DTYPE**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + (X >> MLIB_SHIFT);
753 s0 = LUT(sp[0]);
754 s1 = LUT(sp[1]);
755 s2 = LUT(sp[srcYStride]);
756 s3 = LUT(sp[srcYStride + 1]);
757
758 PROCESS_4CH(s0, s1, s2, s3);
759
760 pbuff[i] = vis_fpack16(dd);
761 X += dX;
762 Y += dY;
763 }
764
765 if (nchan == 3) {
766 mlib_ImageColorTrue2IndexLine_U8_U8_3_in_4((void*)pbuff, (void*)dl, size, colormap);
767 } else {
768 mlib_ImageColorTrue2IndexLine_U8_U8_4((void*)pbuff, (void*)dl, size, colormap);
769 }
770 }
771
772 if (pbuff != buff) {
773 mlib_free(pbuff);
774 }
775
776 return MLIB_SUCCESS;
777 }
778
779 /***************************************************************/
780 #undef DTYPE
781 #define DTYPE mlib_s16
782
FUN_NAME(s16_i)783 mlib_status FUN_NAME(s16_i)(mlib_affine_param *param,
784 const void *colormap)
785 {
786 DECLAREVAR();
787 mlib_s32 nchan = mlib_ImageGetLutChannels(colormap);
788 mlib_s32 lut_off = mlib_ImageGetLutOffset(colormap);
789 mlib_f32 *plut = (mlib_f32*)mlib_ImageGetLutNormalTable(colormap) - lut_off;
790 mlib_s32 max_xsize = param -> max_xsize;
791 mlib_f32 buff[BUF_SIZE], *pbuff = buff;
792
793 srcYStride /= sizeof(DTYPE);
794
795 if (max_xsize > BUF_SIZE) {
796 pbuff = mlib_malloc(max_xsize*sizeof(mlib_f32));
797
798 if (pbuff == NULL) return MLIB_FAILURE;
799 }
800
801 vis_write_gsr(3 << 3);
802
803 for (j = yStart; j <= yFinish; j++) {
804 mlib_f32 s0, s1, s2, s3;
805 DTYPE *sp;
806
807 NEW_LINE(1);
808
809 #pragma pipeloop(0)
810 for (i = 0; i < size; i++) {
811 GET_FILTER_XY();
812
813 sp = *(DTYPE**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + (X >> MLIB_SHIFT);
814 s0 = LUT(sp[0]);
815 s1 = LUT(sp[1]);
816 s2 = LUT(sp[srcYStride]);
817 s3 = LUT(sp[srcYStride + 1]);
818
819 PROCESS_4CH(s0, s1, s2, s3);
820
821 pbuff[i] = vis_fpack16(dd);
822 X += dX;
823 Y += dY;
824 }
825
826 if (nchan == 3) {
827 mlib_ImageColorTrue2IndexLine_U8_S16_3_in_4((void*)pbuff, (void*)dl, size, colormap);
828 } else {
829 mlib_ImageColorTrue2IndexLine_U8_S16_4((void*)pbuff, (void*)dl, size, colormap);
830 }
831 }
832
833 if (pbuff != buff) {
834 mlib_free(pbuff);
835 }
836
837 return MLIB_SUCCESS;
838 }
839
840 /***************************************************************/
841 const type_affine_i_fun mlib_AffineFunArr_bl_i[] = {
842 mlib_ImageAffine_u8_u8_i_bl,
843 mlib_ImageAffine_u8_u8_i_bl,
844 mlib_ImageAffine_u8_s16_i_bl,
845 mlib_ImageAffine_u8_s16_i_bl,
846 mlib_ImageAffine_s16_u8_i_bl,
847 mlib_ImageAffine_s16_u8_i_bl,
848 mlib_ImageAffine_s16_s16_i_bl,
849 mlib_ImageAffine_s16_s16_i_bl
850 };
851
852 /***************************************************************/
853