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
51 * lineAddr array[srcHeight] of pointers to the first pixel on
52 * the corresponding lines
53 * dstYStride stride of destination image
54 * is_affine indicator (Affine - GridWarp)
55 * srcYStride stride of source image
56 * filter type of resampling filter
57 *
58 * DESCRIPTION
59 * The functions step along the lines from xLeft to xRight and apply
60 * the bicubic filtering.
61 *
62 */
63
64 #include "mlib_ImageAffine.h"
65
66 #define DTYPE mlib_s16
67 #define FILTER_BITS 9
68 #define FUN_NAME(CHAN) mlib_ImageAffine_s16_##CHAN##_bc
69
70 /***************************************************************/
71 #ifdef __sparc /* for SPARC, using floating-point multiplies is faster */
72
73 #undef FILTER_ELEM_BITS
74 #define FILTER_ELEM_BITS 4
75
76 #ifdef MLIB_USE_FTOI_CLAMPING
77
78 #define SAT16(DST) \
79 DST = ((mlib_s32)val0) >> 16
80
81 #else
82
83 #define SAT16(DST) \
84 if (val0 >= MLIB_S32_MAX) \
85 DST = MLIB_S16_MAX; \
86 else if (val0 <= MLIB_S32_MIN) \
87 DST = MLIB_S16_MIN; \
88 else \
89 DST = ((mlib_s32)val0) >> 16
90
91 #endif /* MLIB_USE_FTOI_CLAMPING */
92
93 mlib_status FUN_NAME(1ch)(mlib_affine_param *param)
94 {
95 DECLAREVAR_BC();
96 DTYPE *dstLineEnd;
97 const mlib_f32 *mlib_filters_table;
98
99 if (filter == MLIB_BICUBIC) {
100 mlib_filters_table = mlib_filters_s16f_bc;
101 }
102 else {
103 mlib_filters_table = mlib_filters_s16f_bc2;
104 }
105
106 for (j = yStart; j <= yFinish; j++) {
107 mlib_d64 xf0, xf1, xf2, xf3;
108 mlib_d64 yf0, yf1, yf2, yf3;
109 mlib_d64 c0, c1, c2, c3, val0;
110 mlib_s32 filterpos;
111 mlib_f32 *fptr;
112 mlib_s32 s0, s1, s2, s3;
113 mlib_s32 s4, s5, s6, s7;
114
115 CLIP(1);
116 dstLineEnd = (DTYPE *) dstData + xRight;
117
118 filterpos = (X >> FILTER_SHIFT) & FILTER_MASK;
119 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
120
121 xf0 = fptr[0];
122 xf1 = fptr[1];
123 xf2 = fptr[2];
124 xf3 = fptr[3];
125
126 filterpos = (Y >> FILTER_SHIFT) & FILTER_MASK;
127 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
128
129 yf0 = fptr[0];
130 yf1 = fptr[1];
131 yf2 = fptr[2];
132 yf3 = fptr[3];
133
134 xSrc = (X >> MLIB_SHIFT) - 1;
135 ySrc = (Y >> MLIB_SHIFT) - 1;
136
137 srcPixelPtr = ((DTYPE **) lineAddr)[ySrc] + xSrc;
138 s0 = srcPixelPtr[0];
139 s1 = srcPixelPtr[1];
140 s2 = srcPixelPtr[2];
141 s3 = srcPixelPtr[3];
142
143 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
144 s4 = srcPixelPtr[0];
145 s5 = srcPixelPtr[1];
146 s6 = srcPixelPtr[2];
147 s7 = srcPixelPtr[3];
148
149 for (; dstPixelPtr <= (dstLineEnd - 1); dstPixelPtr++) {
150
151 X += dX;
152 Y += dY;
153
154 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3);
155 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3);
156 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
157 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[1] * xf1 +
158 srcPixelPtr[2] * xf2 + srcPixelPtr[3] * xf3);
159 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
160 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[1] * xf1 +
161 srcPixelPtr[2] * xf2 + srcPixelPtr[3] * xf3);
162
163 filterpos = (X >> FILTER_SHIFT) & FILTER_MASK;
164 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
165
166 xf0 = fptr[0];
167 xf1 = fptr[1];
168 xf2 = fptr[2];
169 xf3 = fptr[3];
170
171 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3);
172
173 filterpos = (Y >> FILTER_SHIFT) & FILTER_MASK;
174 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
175
176 yf0 = fptr[0];
177 yf1 = fptr[1];
178 yf2 = fptr[2];
179 yf3 = fptr[3];
180
181 SAT16(dstPixelPtr[0]);
182
183 xSrc = (X >> MLIB_SHIFT) - 1;
184 ySrc = (Y >> MLIB_SHIFT) - 1;
185
186 srcPixelPtr = ((DTYPE **) lineAddr)[ySrc] + xSrc;
187 s0 = srcPixelPtr[0];
188 s1 = srcPixelPtr[1];
189 s2 = srcPixelPtr[2];
190 s3 = srcPixelPtr[3];
191
192 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
193 s4 = srcPixelPtr[0];
194 s5 = srcPixelPtr[1];
195 s6 = srcPixelPtr[2];
196 s7 = srcPixelPtr[3];
197 }
198
199 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3);
200 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3);
201 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
202 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[1] * xf1 +
203 srcPixelPtr[2] * xf2 + srcPixelPtr[3] * xf3);
204 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
205 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[1] * xf1 +
206 srcPixelPtr[2] * xf2 + srcPixelPtr[3] * xf3);
207
208 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3);
209 SAT16(dstPixelPtr[0]);
210 }
211
212 return MLIB_SUCCESS;
213 }
214
215 mlib_status FUN_NAME(2ch)(mlib_affine_param *param)
216 {
217 DECLAREVAR_BC();
218 DTYPE *dstLineEnd;
219 const mlib_f32 *mlib_filters_table;
220
221 if (filter == MLIB_BICUBIC) {
222 mlib_filters_table = mlib_filters_s16f_bc;
223 }
224 else {
225 mlib_filters_table = mlib_filters_s16f_bc2;
226 }
227
228 for (j = yStart; j <= yFinish; j++) {
229 mlib_d64 xf0, xf1, xf2, xf3;
230 mlib_d64 yf0, yf1, yf2, yf3;
231 mlib_d64 c0, c1, c2, c3, val0;
232 mlib_s32 filterpos, k;
233 mlib_f32 *fptr;
234 mlib_s32 s0, s1, s2, s3;
235 mlib_s32 s4, s5, s6, s7;
236
237 CLIP(2);
238 dstLineEnd = (DTYPE *) dstData + 2 * xRight;
239
240 for (k = 0; k < 2; k++) {
241 mlib_s32 X1 = X;
242 mlib_s32 Y1 = Y;
243 DTYPE *dPtr = dstPixelPtr + k;
244
245 filterpos = (X1 >> FILTER_SHIFT) & FILTER_MASK;
246 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
247
248 xf0 = fptr[0];
249 xf1 = fptr[1];
250 xf2 = fptr[2];
251 xf3 = fptr[3];
252
253 filterpos = (Y1 >> FILTER_SHIFT) & FILTER_MASK;
254 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
255
256 yf0 = fptr[0];
257 yf1 = fptr[1];
258 yf2 = fptr[2];
259 yf3 = fptr[3];
260
261 xSrc = (X1 >> MLIB_SHIFT) - 1;
262 ySrc = (Y1 >> MLIB_SHIFT) - 1;
263
264 srcPixelPtr = ((DTYPE **) lineAddr)[ySrc] + 2 * xSrc + k;
265 s0 = srcPixelPtr[0];
266 s1 = srcPixelPtr[2];
267 s2 = srcPixelPtr[4];
268 s3 = srcPixelPtr[6];
269
270 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
271 s4 = srcPixelPtr[0];
272 s5 = srcPixelPtr[2];
273 s6 = srcPixelPtr[4];
274 s7 = srcPixelPtr[6];
275
276 for (; dPtr <= (dstLineEnd - 1); dPtr += 2) {
277
278 X1 += dX;
279 Y1 += dY;
280
281 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3);
282 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3);
283 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
284 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[2] * xf1 +
285 srcPixelPtr[4] * xf2 + srcPixelPtr[6] * xf3);
286 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
287 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[2] * xf1 +
288 srcPixelPtr[4] * xf2 + srcPixelPtr[6] * xf3);
289
290 filterpos = (X1 >> FILTER_SHIFT) & FILTER_MASK;
291 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
292
293 xf0 = fptr[0];
294 xf1 = fptr[1];
295 xf2 = fptr[2];
296 xf3 = fptr[3];
297
298 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3);
299
300 filterpos = (Y1 >> FILTER_SHIFT) & FILTER_MASK;
301 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
302
303 yf0 = fptr[0];
304 yf1 = fptr[1];
305 yf2 = fptr[2];
306 yf3 = fptr[3];
307
308 SAT16(dPtr[0]);
309
310 xSrc = (X1 >> MLIB_SHIFT) - 1;
311 ySrc = (Y1 >> MLIB_SHIFT) - 1;
312
313 srcPixelPtr = ((DTYPE **) lineAddr)[ySrc] + 2 * xSrc + k;
314 s0 = srcPixelPtr[0];
315 s1 = srcPixelPtr[2];
316 s2 = srcPixelPtr[4];
317 s3 = srcPixelPtr[6];
318
319 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
320 s4 = srcPixelPtr[0];
321 s5 = srcPixelPtr[2];
322 s6 = srcPixelPtr[4];
323 s7 = srcPixelPtr[6];
324 }
325
326 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3);
327 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3);
328 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
329 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[2] * xf1 +
330 srcPixelPtr[4] * xf2 + srcPixelPtr[6] * xf3);
331 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
332 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[2] * xf1 +
333 srcPixelPtr[4] * xf2 + srcPixelPtr[6] * xf3);
334
335 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3);
336 SAT16(dPtr[0]);
337 }
338 }
339
340 return MLIB_SUCCESS;
341 }
342
343 mlib_status FUN_NAME(3ch)(mlib_affine_param *param)
344 {
345 DECLAREVAR_BC();
346 DTYPE *dstLineEnd;
347 const mlib_f32 *mlib_filters_table;
348
349 if (filter == MLIB_BICUBIC) {
350 mlib_filters_table = mlib_filters_s16f_bc;
351 }
352 else {
353 mlib_filters_table = mlib_filters_s16f_bc2;
354 }
355
356 for (j = yStart; j <= yFinish; j++) {
357 mlib_d64 xf0, xf1, xf2, xf3;
358 mlib_d64 yf0, yf1, yf2, yf3;
359 mlib_d64 c0, c1, c2, c3, val0;
360 mlib_s32 filterpos, k;
361 mlib_f32 *fptr;
362 mlib_s32 s0, s1, s2, s3;
363 mlib_s32 s4, s5, s6, s7;
364
365 CLIP(3);
366 dstLineEnd = (DTYPE *) dstData + 3 * xRight;
367
368 for (k = 0; k < 3; k++) {
369 mlib_s32 X1 = X;
370 mlib_s32 Y1 = Y;
371 DTYPE *dPtr = dstPixelPtr + k;
372
373 filterpos = (X1 >> FILTER_SHIFT) & FILTER_MASK;
374 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
375
376 xf0 = fptr[0];
377 xf1 = fptr[1];
378 xf2 = fptr[2];
379 xf3 = fptr[3];
380
381 filterpos = (Y1 >> FILTER_SHIFT) & FILTER_MASK;
382 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
383
384 yf0 = fptr[0];
385 yf1 = fptr[1];
386 yf2 = fptr[2];
387 yf3 = fptr[3];
388
389 xSrc = (X1 >> MLIB_SHIFT) - 1;
390 ySrc = (Y1 >> MLIB_SHIFT) - 1;
391
392 srcPixelPtr = ((DTYPE **) lineAddr)[ySrc] + 3 * xSrc + k;
393 s0 = srcPixelPtr[0];
394 s1 = srcPixelPtr[3];
395 s2 = srcPixelPtr[6];
396 s3 = srcPixelPtr[9];
397
398 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
399 s4 = srcPixelPtr[0];
400 s5 = srcPixelPtr[3];
401 s6 = srcPixelPtr[6];
402 s7 = srcPixelPtr[9];
403
404 for (; dPtr <= (dstLineEnd - 1); dPtr += 3) {
405
406 X1 += dX;
407 Y1 += dY;
408
409 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3);
410 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3);
411 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
412 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[3] * xf1 +
413 srcPixelPtr[6] * xf2 + srcPixelPtr[9] * xf3);
414 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
415 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[3] * xf1 +
416 srcPixelPtr[6] * xf2 + srcPixelPtr[9] * xf3);
417
418 filterpos = (X1 >> FILTER_SHIFT) & FILTER_MASK;
419 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
420
421 xf0 = fptr[0];
422 xf1 = fptr[1];
423 xf2 = fptr[2];
424 xf3 = fptr[3];
425
426 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3);
427
428 filterpos = (Y1 >> FILTER_SHIFT) & FILTER_MASK;
429 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
430
431 yf0 = fptr[0];
432 yf1 = fptr[1];
433 yf2 = fptr[2];
434 yf3 = fptr[3];
435
436 SAT16(dPtr[0]);
437
438 xSrc = (X1 >> MLIB_SHIFT) - 1;
439 ySrc = (Y1 >> MLIB_SHIFT) - 1;
440
441 srcPixelPtr = ((DTYPE **) lineAddr)[ySrc] + 3 * xSrc + k;
442 s0 = srcPixelPtr[0];
443 s1 = srcPixelPtr[3];
444 s2 = srcPixelPtr[6];
445 s3 = srcPixelPtr[9];
446
447 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
448 s4 = srcPixelPtr[0];
449 s5 = srcPixelPtr[3];
450 s6 = srcPixelPtr[6];
451 s7 = srcPixelPtr[9];
452 }
453
454 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3);
455 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3);
456 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
457 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[3] * xf1 +
458 srcPixelPtr[6] * xf2 + srcPixelPtr[9] * xf3);
459 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
460 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[3] * xf1 +
461 srcPixelPtr[6] * xf2 + srcPixelPtr[9] * xf3);
462
463 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3);
464 SAT16(dPtr[0]);
465 }
466 }
467
468 return MLIB_SUCCESS;
469 }
470
471 mlib_status FUN_NAME(4ch)(mlib_affine_param *param)
472 {
473 DECLAREVAR_BC();
474 DTYPE *dstLineEnd;
475 const mlib_f32 *mlib_filters_table;
476
477 if (filter == MLIB_BICUBIC) {
478 mlib_filters_table = mlib_filters_s16f_bc;
479 }
480 else {
481 mlib_filters_table = mlib_filters_s16f_bc2;
482 }
483
484 for (j = yStart; j <= yFinish; j++) {
485 mlib_d64 xf0, xf1, xf2, xf3;
486 mlib_d64 yf0, yf1, yf2, yf3;
487 mlib_d64 c0, c1, c2, c3, val0;
488 mlib_s32 filterpos, k;
489 mlib_f32 *fptr;
490 mlib_s32 s0, s1, s2, s3;
491 mlib_s32 s4, s5, s6, s7;
492
493 CLIP(4);
494 dstLineEnd = (DTYPE *) dstData + 4 * xRight;
495
496 for (k = 0; k < 4; k++) {
497 mlib_s32 X1 = X;
498 mlib_s32 Y1 = Y;
499 DTYPE *dPtr = dstPixelPtr + k;
500
501 filterpos = (X1 >> FILTER_SHIFT) & FILTER_MASK;
502 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
503
504 xf0 = fptr[0];
505 xf1 = fptr[1];
506 xf2 = fptr[2];
507 xf3 = fptr[3];
508
509 filterpos = (Y1 >> FILTER_SHIFT) & FILTER_MASK;
510 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
511
512 yf0 = fptr[0];
513 yf1 = fptr[1];
514 yf2 = fptr[2];
515 yf3 = fptr[3];
516
517 xSrc = (X1 >> MLIB_SHIFT) - 1;
518 ySrc = (Y1 >> MLIB_SHIFT) - 1;
519
520 srcPixelPtr = ((DTYPE **) lineAddr)[ySrc] + 4 * xSrc + k;
521 s0 = srcPixelPtr[0];
522 s1 = srcPixelPtr[4];
523 s2 = srcPixelPtr[8];
524 s3 = srcPixelPtr[12];
525
526 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
527 s4 = srcPixelPtr[0];
528 s5 = srcPixelPtr[4];
529 s6 = srcPixelPtr[8];
530 s7 = srcPixelPtr[12];
531
532 for (; dPtr <= (dstLineEnd - 1); dPtr += 4) {
533
534 X1 += dX;
535 Y1 += dY;
536
537 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3);
538 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3);
539 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
540 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[4] * xf1 +
541 srcPixelPtr[8] * xf2 + srcPixelPtr[12] * xf3);
542 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
543 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[4] * xf1 +
544 srcPixelPtr[8] * xf2 + srcPixelPtr[12] * xf3);
545
546 filterpos = (X1 >> FILTER_SHIFT) & FILTER_MASK;
547 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
548
549 xf0 = fptr[0];
550 xf1 = fptr[1];
551 xf2 = fptr[2];
552 xf3 = fptr[3];
553
554 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3);
555
556 filterpos = (Y1 >> FILTER_SHIFT) & FILTER_MASK;
557 fptr = (mlib_f32 *) ((mlib_u8 *) mlib_filters_table + filterpos);
558
559 yf0 = fptr[0];
560 yf1 = fptr[1];
561 yf2 = fptr[2];
562 yf3 = fptr[3];
563
564 SAT16(dPtr[0]);
565
566 xSrc = (X1 >> MLIB_SHIFT) - 1;
567 ySrc = (Y1 >> MLIB_SHIFT) - 1;
568
569 srcPixelPtr = ((DTYPE **) lineAddr)[ySrc] + 4 * xSrc + k;
570 s0 = srcPixelPtr[0];
571 s1 = srcPixelPtr[4];
572 s2 = srcPixelPtr[8];
573 s3 = srcPixelPtr[12];
574
575 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
576 s4 = srcPixelPtr[0];
577 s5 = srcPixelPtr[4];
578 s6 = srcPixelPtr[8];
579 s7 = srcPixelPtr[12];
580 }
581
582 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3);
583 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3);
584 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
585 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[4] * xf1 +
586 srcPixelPtr[8] * xf2 + srcPixelPtr[12] * xf3);
587 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
588 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[4] * xf1 +
589 srcPixelPtr[8] * xf2 + srcPixelPtr[12] * xf3);
590
591 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3);
592 SAT16(dPtr[0]);
593 }
594 }
595
596 return MLIB_SUCCESS;
597 }
598
599 #else /* for x86, using integer multiplies is faster */
600
601 #define SHIFT_X 15
602 #define ROUND_X 0 /* (1 << (SHIFT_X - 1)) */
603
604 #define SHIFT_Y (15 + 15 - SHIFT_X)
605 #define ROUND_Y (1 << (SHIFT_Y - 1))
606
607 #define S32_TO_S16_SAT(DST) \
608 if (val0 >= MLIB_S16_MAX) \
609 DST = MLIB_S16_MAX; \
610 else if (val0 <= MLIB_S16_MIN) \
611 DST = MLIB_S16_MIN; \
612 else \
613 DST = (mlib_s16)val0
614
615 mlib_status FUN_NAME(1ch)(mlib_affine_param *param)
616 {
617 DECLAREVAR_BC();
618 DTYPE *dstLineEnd;
619 const mlib_s16 *mlib_filters_table;
1100 s6 = srcPixelPtr[8];
1101 s7 = srcPixelPtr[12];
1102 }
1103
1104 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3 + ROUND_X) >> SHIFT_X;
1105 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3 + ROUND_X) >> SHIFT_X;
1106 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
1107 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[4] * xf1 +
1108 srcPixelPtr[8] * xf2 + srcPixelPtr[12] * xf3 + ROUND_X) >> SHIFT_X;
1109 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
1110 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[4] * xf1 +
1111 srcPixelPtr[8] * xf2 + srcPixelPtr[12] * xf3 + ROUND_X) >> SHIFT_X;
1112
1113 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3 + ROUND_Y) >> SHIFT_Y;
1114 S32_TO_S16_SAT(dPtr[0]);
1115 }
1116 }
1117
1118 return MLIB_SUCCESS;
1119 }
1120
1121 #endif /* __sparc ( for SPARC, using floating-point multiplies is faster ) */
1122
1123 /***************************************************************/
|
1 /*
2 * Copyright (c) 2003, 2020, 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
51 * lineAddr array[srcHeight] of pointers to the first pixel on
52 * the corresponding lines
53 * dstYStride stride of destination image
54 * is_affine indicator (Affine - GridWarp)
55 * srcYStride stride of source image
56 * filter type of resampling filter
57 *
58 * DESCRIPTION
59 * The functions step along the lines from xLeft to xRight and apply
60 * the bicubic filtering.
61 *
62 */
63
64 #include "mlib_ImageAffine.h"
65
66 #define DTYPE mlib_s16
67 #define FILTER_BITS 9
68 #define FUN_NAME(CHAN) mlib_ImageAffine_s16_##CHAN##_bc
69
70 /***************************************************************/
71 /* for x86, using integer multiplies is faster */
72
73 #define SHIFT_X 15
74 #define ROUND_X 0 /* (1 << (SHIFT_X - 1)) */
75
76 #define SHIFT_Y (15 + 15 - SHIFT_X)
77 #define ROUND_Y (1 << (SHIFT_Y - 1))
78
79 #define S32_TO_S16_SAT(DST) \
80 if (val0 >= MLIB_S16_MAX) \
81 DST = MLIB_S16_MAX; \
82 else if (val0 <= MLIB_S16_MIN) \
83 DST = MLIB_S16_MIN; \
84 else \
85 DST = (mlib_s16)val0
86
87 mlib_status FUN_NAME(1ch)(mlib_affine_param *param)
88 {
89 DECLAREVAR_BC();
90 DTYPE *dstLineEnd;
91 const mlib_s16 *mlib_filters_table;
572 s6 = srcPixelPtr[8];
573 s7 = srcPixelPtr[12];
574 }
575
576 c0 = (s0 * xf0 + s1 * xf1 + s2 * xf2 + s3 * xf3 + ROUND_X) >> SHIFT_X;
577 c1 = (s4 * xf0 + s5 * xf1 + s6 * xf2 + s7 * xf3 + ROUND_X) >> SHIFT_X;
578 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
579 c2 = (srcPixelPtr[0] * xf0 + srcPixelPtr[4] * xf1 +
580 srcPixelPtr[8] * xf2 + srcPixelPtr[12] * xf3 + ROUND_X) >> SHIFT_X;
581 srcPixelPtr = (DTYPE *) ((mlib_addr) srcPixelPtr + srcYStride);
582 c3 = (srcPixelPtr[0] * xf0 + srcPixelPtr[4] * xf1 +
583 srcPixelPtr[8] * xf2 + srcPixelPtr[12] * xf3 + ROUND_X) >> SHIFT_X;
584
585 val0 = (c0 * yf0 + c1 * yf1 + c2 * yf2 + c3 * yf3 + ROUND_Y) >> SHIFT_Y;
586 S32_TO_S16_SAT(dPtr[0]);
587 }
588 }
589
590 return MLIB_SUCCESS;
591 }
592
593 /***************************************************************/
|