1/*
2 * Copyright (c) 2000, 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 * FUNCTION
29 * Internal functions for mlib_ImageAffine with Nearest Neighbor filtering.
30 */
31
32#include "mlib_ImageAffine.h"
33
34/***************************************************************/
35#define sp srcPixelPtr
36#define dp dstPixelPtr
37
38/***************************************************************/
39#undef DTYPE
40#define DTYPE mlib_s32
41
42#ifdef _MSC_VER
43/* Workaround for MSC optimizer bug (known affected versions
44 12.00.8168-12.00.8804). See bug 4893435 for details. */
45#pragma optimize("gs", off)
46#endif /* _MSC_VER */
47#ifdef i386 /* do not perform the coping by mlib_d64 data type for x86 */
48
49mlib_status mlib_ImageAffine_s32_1ch_nn(mlib_affine_param *param)
50{
51 DECLAREVAR();
52 DTYPE *srcPixelPtr;
53 DTYPE *dstLineEnd;
54
55 for (j = yStart; j <= yFinish; j++) {
56 CLIP(1);
57 dstLineEnd = (DTYPE *) dstData + xRight;
58
59#ifdef __SUNPRO_C
60#pragma pipeloop(0)
61#endif /* __SUNPRO_C */
62 for (; dp <= dstLineEnd; dp++) {
63 sp = S_PTR(Y) + (X >> MLIB_SHIFT);
64 dp[0] = sp[0];
65
66 X += dX;
67 Y += dY;
68 }
69 }
70
71 return MLIB_SUCCESS;
72}
73
74#else
75
76mlib_status mlib_ImageAffine_s32_1ch_nn(mlib_affine_param *param)
77{
78 DECLAREVAR();
79 DTYPE *srcPixelPtr;
80 mlib_s32 i, size;
81
82 for (j = yStart; j <= yFinish; j++) {
83 d64_2x32 dd;
84
85 CLIP(1);
86 size = xRight - xLeft + 1;
87
88 if ((mlib_addr) dp & 7) {
89 sp = S_PTR(Y);
90 *dp++ = sp[X >> MLIB_SHIFT];
91 X += dX;
92 Y += dY;
93 size--;
94 }
95
96#ifdef __SUNPRO_C
97#pragma pipeloop(0)
98#endif /* __SUNPRO_C */
99 for (i = 0; i <= (size - 2); i += 2) {
100 mlib_f32 *sp0, *sp1;
101
102 sp0 = (mlib_f32 *) S_PTR(Y);
103 sp1 = (mlib_f32 *) S_PTR(Y + dY);
104
105 dd.f32s.f0 = sp0[X >> MLIB_SHIFT];
106 dd.f32s.f1 = sp1[(X + dX) >> MLIB_SHIFT];
107
108 *(mlib_d64 *) dp = dd.d64;
109
110 dp += 2;
111 X += 2 * dX;
112 Y += 2 * dY;
113 }
114
115 if (size & 1) {
116 sp = S_PTR(Y);
117 *dp = sp[X >> MLIB_SHIFT];
118 }
119 }
120
121 return MLIB_SUCCESS;
122}
123
124#endif /* i386 ( do not perform the coping by mlib_d64 data type for x86 ) */
125
126/***************************************************************/
127mlib_status mlib_ImageAffine_s32_2ch_nn(mlib_affine_param *param)
128{
129 DECLAREVAR();
130 DTYPE *srcPixelPtr;
131 DTYPE *dstLineEnd;
132
133 for (j = yStart; j <= yFinish; j++) {
134 CLIP(2);
135 dstLineEnd = (DTYPE *) dstData + 2 * xRight;
136
137#ifdef __SUNPRO_C
138#pragma pipeloop(0)
139#endif /* __SUNPRO_C */
140 for (; dp <= dstLineEnd; dp += 2) {
141 sp = S_PTR(Y) + 2 * (X >> MLIB_SHIFT);
142 dp[0] = sp[0];
143 dp[1] = sp[1];
144
145 X += dX;
146 Y += dY;
147 }
148 }
149
150 return MLIB_SUCCESS;
151}
152
153/***************************************************************/
154mlib_status mlib_ImageAffine_s32_3ch_nn(mlib_affine_param *param)
155{
156 DECLAREVAR();
157 DTYPE *srcPixelPtr;
158 DTYPE *dstLineEnd;
159
160 for (j = yStart; j <= yFinish; j++) {
161 CLIP(3);
162 dstLineEnd = (DTYPE *) dstData + 3 * xRight;
163
164#ifdef __SUNPRO_C
165#pragma pipeloop(0)
166#endif /* __SUNPRO_C */
167 for (; dp <= dstLineEnd; dp += 3) {
168 sp = S_PTR(Y) + 3 * (X >> MLIB_SHIFT);
169 dp[0] = sp[0];
170 dp[1] = sp[1];
171 dp[2] = sp[2];
172
173 X += dX;
174 Y += dY;
175 }
176 }
177
178 return MLIB_SUCCESS;
179}
180
181/***************************************************************/
182mlib_status mlib_ImageAffine_s32_4ch_nn(mlib_affine_param *param)
183{
184 DECLAREVAR();
185 DTYPE *srcPixelPtr;
186 DTYPE *dstLineEnd;
187
188 for (j = yStart; j <= yFinish; j++) {
189 CLIP(4);
190 dstLineEnd = (DTYPE *) dstData + 4 * xRight;
191
192#ifdef __SUNPRO_C
193#pragma pipeloop(0)
194#endif /* __SUNPRO_C */
195 for (; dp <= dstLineEnd; dp += 4) {
196 sp = S_PTR(Y) + 4 * (X >> MLIB_SHIFT);
197 dp[0] = sp[0];
198 dp[1] = sp[1];
199 dp[2] = sp[2];
200 dp[3] = sp[3];
201
202 X += dX;
203 Y += dY;
204 }
205 }
206
207 return MLIB_SUCCESS;
208}
209
210/***************************************************************/
211#undef DTYPE
212#define DTYPE mlib_d64
213
214mlib_status mlib_ImageAffine_d64_1ch_nn(mlib_affine_param *param)
215{
216 DECLAREVAR();
217 DTYPE *srcPixelPtr;
218 DTYPE *dstLineEnd;
219
220 for (j = yStart; j <= yFinish; j++) {
221 CLIP(1);
222 dstLineEnd = (DTYPE *) dstData + xRight;
223
224#ifdef __SUNPRO_C
225#pragma pipeloop(0)
226#endif /* __SUNPRO_C */
227 for (; dp <= dstLineEnd; dp++) {
228 sp = S_PTR(Y);
229 dp[0] = sp[X >> MLIB_SHIFT];
230
231 X += dX;
232 Y += dY;
233 }
234 }
235
236 return MLIB_SUCCESS;
237}
238
239/***************************************************************/
240mlib_status mlib_ImageAffine_d64_2ch_nn(mlib_affine_param *param)
241{
242 DECLAREVAR();
243 DTYPE *srcPixelPtr;
244 DTYPE *dstLineEnd;
245
246 for (j = yStart; j <= yFinish; j++) {
247 CLIP(2);
248 dstLineEnd = (DTYPE *) dstData + 2 * xRight;
249
250#ifdef __SUNPRO_C
251#pragma pipeloop(0)
252#endif /* __SUNPRO_C */
253 for (; dp <= dstLineEnd; dp += 2) {
254 sp = S_PTR(Y) + 2 * (X >> MLIB_SHIFT);
255 dp[0] = sp[0];
256 dp[1] = sp[1];
257
258 X += dX;
259 Y += dY;
260 }
261 }
262
263 return MLIB_SUCCESS;
264}
265
266/***************************************************************/
267mlib_status mlib_ImageAffine_d64_3ch_nn(mlib_affine_param *param)
268{
269 DECLAREVAR();
270 DTYPE *srcPixelPtr;
271 DTYPE *dstLineEnd;
272
273 for (j = yStart; j <= yFinish; j++) {
274 CLIP(3);
275 dstLineEnd = (DTYPE *) dstData + 3 * xRight;
276
277#ifdef __SUNPRO_C
278#pragma pipeloop(0)
279#endif /* __SUNPRO_C */
280 for (; dp <= dstLineEnd; dp += 3) {
281 sp = S_PTR(Y) + 3 * (X >> MLIB_SHIFT);
282 dp[0] = sp[0];
283 dp[1] = sp[1];
284 dp[2] = sp[2];
285
286 X += dX;
287 Y += dY;
288 }
289 }
290
291 return MLIB_SUCCESS;
292}
293
294/***************************************************************/
295mlib_status mlib_ImageAffine_d64_4ch_nn(mlib_affine_param *param)
296{
297 DECLAREVAR();
298 DTYPE *srcPixelPtr;
299 DTYPE *dstLineEnd;
300
301 for (j = yStart; j <= yFinish; j++) {
302 CLIP(4);
303 dstLineEnd = (DTYPE *) dstData + 4 * xRight;
304
305#ifdef __SUNPRO_C
306#pragma pipeloop(0)
307#endif /* __SUNPRO_C */
308 for (; dp <= dstLineEnd; dp += 4) {
309 sp = S_PTR(Y) + 4 * (X >> MLIB_SHIFT);
310 dp[0] = sp[0];
311 dp[1] = sp[1];
312 dp[2] = sp[2];
313 dp[3] = sp[3];
314
315 X += dX;
316 Y += dY;
317 }
318 }
319
320 return MLIB_SUCCESS;
321}
322
323/***************************************************************/
324#ifdef _MSC_VER
325/* Workaround for MSC optimizer bug (known affected versions
326 12.00.8168-12.00.8804). See bug 4893435 for details. */
327#pragma optimize("gs", on)
328#endif /* _MSC_VER */
329