CoCalc -- mlib_ImageAffine.h

GitHub Repository: PojavLauncherTeam/openjdk-multiarch-jdk8u
Path: blob/aarch64-shenandoah-jdk8u272-b10/jdk/src/share/native/sun/awt/medialib/mlib_ImageAffine.h
³⁸⁹¹⁸ views
1
/*
2
 * Copyright (c) 2003, 2012, 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
#ifndef __MLIB_IMAGEAFFINE_H
28
#define __MLIB_IMAGEAFFINE_H
29

30
#include "mlib_image.h"
31
#include "mlib_ImageDivTables.h"
32
#include "mlib_ImageFilters.h"
33

34
#ifdef __cplusplus
35
extern "C" {
36
#endif /* __cplusplus */
37

38
/*
39
 * DESCRIPTION
40
 *   Internal macro for mlib_ImageAffine.
41
 *
42
 *   DTYPE define must be set to data type of image.
43
 *   FTYPE define must be set to type of floating-point operations.
44
 */
45

46
/***************************************************************/
47
typedef struct {
48
  mlib_image *src;
49
  mlib_image *dst;
50
  mlib_u8  *buff_malloc;
51
  mlib_u8  **lineAddr;
52
  mlib_u8  *dstData;
53
  mlib_s32 *leftEdges;
54
  mlib_s32 *rightEdges;
55
  mlib_s32 *xStarts;
56
  mlib_s32 *yStarts;
57
  mlib_s32 yStart;
58
  mlib_s32 yFinish;
59
  mlib_s32 dX;
60
  mlib_s32 dY;
61
  mlib_s32 max_xsize;
62
  mlib_s32 srcYStride;
63
  mlib_s32 dstYStride;
64
  mlib_s32 *warp_tbl;
65
  mlib_filter filter;
66
} mlib_affine_param;
67

68
/***************************************************************/
69

70
#define LOAD_PARAM(param, x)  x = param->x
71
#define STORE_PARAM(param, x) param->x=x
72

73
/***************************************************************/
74
mlib_status mlib_AffineEdges(mlib_affine_param *param,
75
                             const mlib_image  *dst,
76
                             const mlib_image  *src,
77
                             void              *buff_lcl,
78
                             mlib_s32          buff_size,
79
                             mlib_s32          kw,
80
                             mlib_s32          kh,
81
                             mlib_s32          kw1,
82
                             mlib_s32          kh1,
83
                             mlib_edge         edge,
84
                             const mlib_d64    *mtx,
85
                             mlib_s32          shiftx,
86
                             mlib_s32          shifty);
87

88
/***************************************************************/
89
typedef mlib_status (*type_affine_fun)(mlib_affine_param *param);
90

91
/***************************************************************/
92
void mlib_ImageAffine_bit_1ch_nn(mlib_affine_param *param,
93
                                 mlib_s32          s_bitoff,
94
                                 mlib_s32          d_bitoff);
95

96
mlib_status mlib_ImageAffine_u8_1ch_nn(mlib_affine_param *param);
97
mlib_status mlib_ImageAffine_u8_2ch_nn(mlib_affine_param *param);
98
mlib_status mlib_ImageAffine_u8_3ch_nn(mlib_affine_param *param);
99
mlib_status mlib_ImageAffine_u8_4ch_nn(mlib_affine_param *param);
100
mlib_status mlib_ImageAffine_s16_1ch_nn(mlib_affine_param *param);
101
mlib_status mlib_ImageAffine_s16_2ch_nn(mlib_affine_param *param);
102
mlib_status mlib_ImageAffine_s16_3ch_nn(mlib_affine_param *param);
103
mlib_status mlib_ImageAffine_s16_4ch_nn(mlib_affine_param *param);
104
mlib_status mlib_ImageAffine_s32_1ch_nn(mlib_affine_param *param);
105
mlib_status mlib_ImageAffine_s32_2ch_nn(mlib_affine_param *param);
106
mlib_status mlib_ImageAffine_s32_3ch_nn(mlib_affine_param *param);
107
mlib_status mlib_ImageAffine_s32_4ch_nn(mlib_affine_param *param);
108
mlib_status mlib_ImageAffine_d64_1ch_nn(mlib_affine_param *param);
109
mlib_status mlib_ImageAffine_d64_2ch_nn(mlib_affine_param *param);
110
mlib_status mlib_ImageAffine_d64_3ch_nn(mlib_affine_param *param);
111
mlib_status mlib_ImageAffine_d64_4ch_nn(mlib_affine_param *param);
112

113
mlib_status mlib_ImageAffine_u8_1ch_bl(mlib_affine_param *param);
114
mlib_status mlib_ImageAffine_u8_2ch_bl(mlib_affine_param *param);
115
mlib_status mlib_ImageAffine_u8_3ch_bl(mlib_affine_param *param);
116
mlib_status mlib_ImageAffine_u8_4ch_bl(mlib_affine_param *param);
117
mlib_status mlib_ImageAffine_s16_1ch_bl(mlib_affine_param *param);
118
mlib_status mlib_ImageAffine_s16_2ch_bl(mlib_affine_param *param);
119
mlib_status mlib_ImageAffine_s16_3ch_bl(mlib_affine_param *param);
120
mlib_status mlib_ImageAffine_s16_4ch_bl(mlib_affine_param *param);
121
mlib_status mlib_ImageAffine_u16_1ch_bl(mlib_affine_param *param);
122
mlib_status mlib_ImageAffine_u16_2ch_bl(mlib_affine_param *param);
123
mlib_status mlib_ImageAffine_u16_3ch_bl(mlib_affine_param *param);
124
mlib_status mlib_ImageAffine_u16_4ch_bl(mlib_affine_param *param);
125
mlib_status mlib_ImageAffine_s32_1ch_bl(mlib_affine_param *param);
126
mlib_status mlib_ImageAffine_s32_2ch_bl(mlib_affine_param *param);
127
mlib_status mlib_ImageAffine_s32_3ch_bl(mlib_affine_param *param);
128
mlib_status mlib_ImageAffine_s32_4ch_bl(mlib_affine_param *param);
129
mlib_status mlib_ImageAffine_f32_1ch_bl(mlib_affine_param *param);
130
mlib_status mlib_ImageAffine_f32_2ch_bl(mlib_affine_param *param);
131
mlib_status mlib_ImageAffine_f32_3ch_bl(mlib_affine_param *param);
132
mlib_status mlib_ImageAffine_f32_4ch_bl(mlib_affine_param *param);
133
mlib_status mlib_ImageAffine_d64_1ch_bl(mlib_affine_param *param);
134
mlib_status mlib_ImageAffine_d64_2ch_bl(mlib_affine_param *param);
135
mlib_status mlib_ImageAffine_d64_3ch_bl(mlib_affine_param *param);
136
mlib_status mlib_ImageAffine_d64_4ch_bl(mlib_affine_param *param);
137

138
mlib_status mlib_ImageAffine_u8_1ch_bc(mlib_affine_param *param);
139
mlib_status mlib_ImageAffine_u8_2ch_bc(mlib_affine_param *param);
140
mlib_status mlib_ImageAffine_u8_3ch_bc(mlib_affine_param *param);
141
mlib_status mlib_ImageAffine_u8_4ch_bc(mlib_affine_param *param);
142
mlib_status mlib_ImageAffine_s16_1ch_bc(mlib_affine_param *param);
143
mlib_status mlib_ImageAffine_s16_2ch_bc(mlib_affine_param *param);
144
mlib_status mlib_ImageAffine_s16_3ch_bc(mlib_affine_param *param);
145
mlib_status mlib_ImageAffine_s16_4ch_bc(mlib_affine_param *param);
146
mlib_status mlib_ImageAffine_u16_1ch_bc(mlib_affine_param *param);
147
mlib_status mlib_ImageAffine_u16_2ch_bc(mlib_affine_param *param);
148
mlib_status mlib_ImageAffine_u16_3ch_bc(mlib_affine_param *param);
149
mlib_status mlib_ImageAffine_u16_4ch_bc(mlib_affine_param *param);
150
mlib_status mlib_ImageAffine_s32_1ch_bc(mlib_affine_param *param);
151
mlib_status mlib_ImageAffine_s32_2ch_bc(mlib_affine_param *param);
152
mlib_status mlib_ImageAffine_s32_3ch_bc(mlib_affine_param *param);
153
mlib_status mlib_ImageAffine_s32_4ch_bc(mlib_affine_param *param);
154
mlib_status mlib_ImageAffine_f32_1ch_bc(mlib_affine_param *param);
155
mlib_status mlib_ImageAffine_f32_2ch_bc(mlib_affine_param *param);
156
mlib_status mlib_ImageAffine_f32_3ch_bc(mlib_affine_param *param);
157
mlib_status mlib_ImageAffine_f32_4ch_bc(mlib_affine_param *param);
158
mlib_status mlib_ImageAffine_d64_1ch_bc(mlib_affine_param *param);
159
mlib_status mlib_ImageAffine_d64_2ch_bc(mlib_affine_param *param);
160
mlib_status mlib_ImageAffine_d64_3ch_bc(mlib_affine_param *param);
161
mlib_status mlib_ImageAffine_d64_4ch_bc(mlib_affine_param *param);
162

163
/***************************************************************/
164
void mlib_ImageAffineEdgeZero(mlib_affine_param *param,
165
                              mlib_affine_param *param_e,
166
                              const void        *colormap);
167

168
void mlib_ImageAffineEdgeNearest(mlib_affine_param *param,
169
                                 mlib_affine_param *param_e);
170

171
mlib_status mlib_ImageAffineEdgeExtend_BL(mlib_affine_param *param,
172
                                          mlib_affine_param *param_e,
173
                                          const void        *colormap);
174

175
mlib_status mlib_ImageAffineEdgeExtend_BC(mlib_affine_param *param,
176
                                          mlib_affine_param *param_e,
177
                                          const void        *colormap);
178

179
mlib_status mlib_ImageAffineEdgeExtend_BC2(mlib_affine_param *param,
180
                                           mlib_affine_param *param_e,
181
                                           const void        *colormap);
182

183
/***************************************************************/
184
typedef mlib_status (*type_affine_i_fun)(mlib_affine_param *param, const void *colormap);
185

186
mlib_status mlib_ImageAffine_u8_u8_i_bl(mlib_affine_param *param,
187
                                        const void        *colormap);
188
mlib_status mlib_ImageAffine_u8_s16_i_bl(mlib_affine_param *param,
189
                                         const void        *colormap);
190
mlib_status mlib_ImageAffine_s16_u8_i_bl(mlib_affine_param *param,
191
                                         const void        *colormap);
192
mlib_status mlib_ImageAffine_s16_s16_i_bl(mlib_affine_param *param,
193
                                          const void        *colormap);
194

195
mlib_status mlib_ImageAffine_u8_u8_i_bc(mlib_affine_param *param,
196
                                        const void        *colormap);
197
mlib_status mlib_ImageAffine_u8_s16_i_bc(mlib_affine_param *param,
198
                                         const void        *colormap);
199
mlib_status mlib_ImageAffine_s16_u8_i_bc(mlib_affine_param *param,
200
                                         const void        *colormap);
201
mlib_status mlib_ImageAffine_s16_s16_i_bc(mlib_affine_param *param,
202
                                          const void        *colormap);
203

204
void mlib_ImageAffineEdgeZeroIndex(mlib_affine_param *param,
205
                                   mlib_affine_param *param_e,
206
                                   const void        *colormap);
207

208
void mlib_ImageAffineEdgeExtendIndex_BL(mlib_affine_param *param,
209
                                        mlib_affine_param *param_e,
210
                                        const void        *colormap);
211

212
void mlib_ImageAffineEdgeExtendIndex_BC(mlib_affine_param *param,
213
                                        mlib_affine_param *param_e,
214
                                        const void        *colormap);
215

216
void mlib_ImageAffineEdgeExtendIndex_BC2(mlib_affine_param *param,
217
                                         mlib_affine_param *param_e,
218
                                         const void        *colormap);
219

220
/***************************************************************/
221
#define PROT_AFFINEINDEX_BC(ITYPE, LTYPE, NCHAN)                                                 \
222
  mlib_status mlib_ImageAffineIndex_##ITYPE##_##LTYPE##_##NCHAN##CH_BC(mlib_affine_param *param, \
223
                                                                       const void        *colormap)
224

225
PROT_AFFINEINDEX_BC(U8, U8, 3);
226
PROT_AFFINEINDEX_BC(U8, S16, 3);
227
PROT_AFFINEINDEX_BC(U8, U8, 4);
228
PROT_AFFINEINDEX_BC(U8, S16, 4);
229
PROT_AFFINEINDEX_BC(S16, U8, 3);
230
PROT_AFFINEINDEX_BC(S16, S16, 3);
231
PROT_AFFINEINDEX_BC(S16, U8, 4);
232
PROT_AFFINEINDEX_BC(S16, S16, 4);
233

234
/***************************************************************/
235
#define PROT_AFFINEINDEX_BL(ITYPE, LTYPE, NCHAN)                                                 \
236
  mlib_status mlib_ImageAffineIndex_##ITYPE##_##LTYPE##_##NCHAN##CH_BL(mlib_affine_param *param, \
237
                                                                       const void        *colormap)
238

239
PROT_AFFINEINDEX_BL(U8, U8, 3);
240
PROT_AFFINEINDEX_BL(U8, S16, 3);
241
PROT_AFFINEINDEX_BL(U8, U8, 4);
242
PROT_AFFINEINDEX_BL(U8, S16, 4);
243
PROT_AFFINEINDEX_BL(S16, U8, 3);
244
PROT_AFFINEINDEX_BL(S16, S16, 3);
245
PROT_AFFINEINDEX_BL(S16, U8, 4);
246
PROT_AFFINEINDEX_BL(S16, S16, 4);
247

248
/***************************************************************/
249
mlib_status mlib_ImageAffine_alltypes(mlib_image       *dst,
250
                                      const mlib_image *src,
251
                                      const mlib_d64   *mtx,
252
                                      mlib_filter      filter,
253
                                      mlib_edge        edge,
254
                                      const void       *colormap);
255

256
/***************************************************************/
257
extern const type_affine_i_fun mlib_AffineFunArr_bl_i[];
258
extern const type_affine_fun mlib_AffineFunArr_nn[];
259
extern const type_affine_fun mlib_AffineFunArr_bl[];
260
extern const type_affine_fun mlib_AffineFunArr_bc[];
261

262
/***************************************************************/
263
typedef union {
264
  mlib_d64 d64;
265
  struct {
266
    mlib_f32 f0;
267
    mlib_f32 f1;
268
  } f32s;
269
} d64_2x32;
270

271
/***************************************************************/
272
#define MLIB_SHIFT  16
273
#define MLIB_PREC   (1 << MLIB_SHIFT)
274
#define MLIB_MASK   (MLIB_PREC - 1)
275

276
/***************************************************************/
277
#define ONE  (FTYPE)1.0
278

279
/***************************************************************/
280
#ifdef MLIB_USE_FTOI_CLAMPING
281

282
#define SAT_32(DST, SRC)                                              \
283
  DST = (mlib_s32) SRC
284

285
#else
286

287
#define SAT_32(DST, SRC)                                              \
288
  if (SRC >= MLIB_S32_MAX)                                     \
289
    SRC = MLIB_S32_MAX;                                        \
290
  if (SRC <= MLIB_S32_MIN)                                     \
291
    SRC = MLIB_S32_MIN;                                        \
292
    DST = (mlib_s32) SRC
293

294
#endif /* MLIB_USE_FTOI_CLAMPING */
295

296
//we still need this for mlib_ImageAffine_BC_S32.c
297
#define SAT32(DST) SAT_32(DST, val0)
298

299
/***************************************************************/
300
#if defined(MLIB_OS64BIT) || (defined(MACOSX) && defined(_LP64))
301
#define PBITS  3
302
#define MLIB_POINTER_SHIFT(P)  (((P) >> (MLIB_SHIFT - 3)) &~ 7)
303
#define MLIB_POINTER_GET(A, P) (*(DTYPE**)((mlib_u8*)(A) + (P)))
304
#else
305
#define PBITS  2
306
#define MLIB_POINTER_SHIFT(P)  (((P) >> (MLIB_SHIFT - 2)) &~ 3)
307
#define MLIB_POINTER_GET(A, P) (*(DTYPE**)((mlib_addr)(A) + (P)))
308
#endif /* MLIB_OS64BIT */
309

310
#define PTR_SHIFT MLIB_POINTER_SHIFT
311

312
/***************************************************************/
313
#define SHIFT(X, SH, LO_BITS)                                   \
314
  (((X) >> (SH - LO_BITS)) & ((1 << (15 + LO_BITS)) - (1 << LO_BITS)))
315

316
/***************************************************************/
317
#define S_PTRl(Y, SH)                                           \
318
  (*(DTYPE**)((mlib_u8*)lineAddr + SHIFT(Y, SH, PBITS)))
319

320
#define S_PTR(Y) S_PTRl(Y, 16)
321

322
/***************************************************************/
323
#define AL_ADDR(sp, ind) (mlib_d64*)((mlib_addr)(sp + ind) &~ 7)
324

325
/***************************************************************/
326
#define FILTER_ELEM_BITS  3
327

328
/***************************************************************/
329
#define FILTER_SHIFT (MLIB_SHIFT - FILTER_BITS - FILTER_ELEM_BITS)
330
#define FILTER_SIZE  (1 << FILTER_BITS)
331
#define FILTER_MASK  ((FILTER_SIZE - 1) << FILTER_ELEM_BITS)
332

333
/***************************************************************/
334
#define DECLAREVAR0()                                           \
335
  mlib_s32  *leftEdges  = param -> leftEdges;                   \
336
  mlib_s32  *rightEdges = param -> rightEdges;                  \
337
  mlib_s32  *xStarts    = param -> xStarts;                     \
338
  mlib_s32  *yStarts    = param -> yStarts;                     \
339
  mlib_u8   *dstData    = param -> dstData;                     \
340
  mlib_u8   **lineAddr  = param -> lineAddr;                    \
341
  mlib_s32  dstYStride  = param -> dstYStride;                  \
342
  mlib_s32  xLeft, xRight, X, Y;                                \
343
  mlib_s32  yStart  = param -> yStart;                          \
344
  mlib_s32  yFinish = param -> yFinish;                         \
345
  mlib_s32  dX = param -> dX;                                   \
346
  mlib_s32  dY = param -> dY;                                   \
347
  mlib_s32  j
348

349
/***************************************************************/
350
#define DECLAREVAR()                                            \
351
  DECLAREVAR0();                                                \
352
  mlib_s32 *warp_tbl   = param -> warp_tbl;                     \
353
  DTYPE    *dstPixelPtr
354

355
/***************************************************************/
356
#define DECLAREVAR_NN()                                         \
357
  DECLAREVAR();                                                 \
358
  DTYPE    *srcPixelPtr;                                        \
359
  mlib_s32 xSrc, ySrc
360

361
/***************************************************************/
362
#define DECLAREVAR_BL()                                         \
363
  DECLAREVAR_NN();                                              \
364
  mlib_s32 srcYStride = param -> srcYStride
365

366
/***************************************************************/
367
#define DECLAREVAR_BC()                                         \
368
  DECLAREVAR_BL();                                              \
369
  mlib_filter filter = param -> filter
370

371
/***************************************************************/
372
#define PREPARE_DELTAS                                          \
373
  if (warp_tbl != NULL) {                                       \
374
    dX = warp_tbl[2*j];                                         \
375
    dY = warp_tbl[2*j + 1];                                     \
376
  }
377

378
/***************************************************************/
379
#define CLIP(N)                                                 \
380
  dstData += dstYStride;                                        \
381
  xLeft  = leftEdges[j];                                        \
382
  xRight = rightEdges[j];                                       \
383
  X = xStarts[j];                                               \
384
  Y = yStarts[j];                                               \
385
  PREPARE_DELTAS;                                               \
386
  if (xLeft > xRight) continue;                                 \
387
  dstPixelPtr = (DTYPE*)dstData + N * xLeft
388

389
/***************************************************************/
390
#define NEW_LINE(NCHAN)                                         \
391
  dstData += dstYStride;                                        \
392
  xLeft  = leftEdges[j];                                        \
393
  xRight = rightEdges[j];                                       \
394
  X = xStarts[j];                                               \
395
  Y = yStarts[j];                                               \
396
  PREPARE_DELTAS                                                \
397
  dl = (void*)((DTYPE*)dstData + NCHAN*xLeft);                  \
398
  size = xRight - xLeft + 1;                                    \
399
  if (size <= 0) continue
400

401
/***************************************************************/
402

403
#ifdef __cplusplus
404
}
405
#endif /* __cplusplus */
406
#endif /* __MLIB_IMAGEAFFINE_H */
407

408
Product

Resources

Company
