162 /***************************************************************/
163 typedef union {
164 mlib_d64 d64;
165 struct {
166 mlib_s32 i0;
167 mlib_s32 i1;
168 } i32s;
169 } d64_2x32;
170
171 /***************************************************************/
172 #define GET_SRC_DST_PARAMETERS(type) \
173 hgt = mlib_ImageGetHeight(src); \
174 wid = mlib_ImageGetWidth(src); \
175 nchannel = mlib_ImageGetChannels(src); \
176 sll = mlib_ImageGetStride(src) / sizeof(type); \
177 dll = mlib_ImageGetStride(dst) / sizeof(type); \
178 adr_src = (type *)mlib_ImageGetData(src); \
179 adr_dst = (type *)mlib_ImageGetData(dst)
180
181 /***************************************************************/
182 #ifndef __sparc
183 #if IMG_TYPE == 1
184
185 /*
186 * Test for the presence of any "1" bit in bits
187 8 to 31 of val. If present, then val is either
188 negative or >255. If over/underflows of 8 bits
189 are uncommon, then this technique can be a win,
190 since only a single test, rather than two, is
191 necessary to determine if clamping is needed.
192 On the other hand, if over/underflows are common,
193 it adds an extra test.
194 */
195 #define CLAMP_STORE(dst, val) \
196 if (val & 0xffffff00) { \
197 if (val < MLIB_U8_MIN) \
198 dst = MLIB_U8_MIN; \
199 else \
200 dst = MLIB_U8_MAX; \
201 } else { \
202 dst = (mlib_u8)val; \
206
207 #define CLAMP_STORE(dst, val) \
208 if (val >= MLIB_S16_MAX) \
209 dst = MLIB_S16_MAX; \
210 else if (val <= MLIB_S16_MIN) \
211 dst = MLIB_S16_MIN; \
212 else \
213 dst = (mlib_s16)val
214
215 #elif IMG_TYPE == 3
216
217 #define CLAMP_STORE(dst, val) \
218 if (val >= MLIB_U16_MAX) \
219 dst = MLIB_U16_MAX; \
220 else if (val <= MLIB_U16_MIN) \
221 dst = MLIB_U16_MIN; \
222 else \
223 dst = (mlib_u16)val
224
225 #endif /* IMG_TYPE == 1 */
226 #endif /* __sparc */
227
228 /***************************************************************/
229 #define MAX_KER 7
230 #define MAX_N 15
231 #define BUFF_SIZE 1600
232 #define CACHE_SIZE (64*1024)
233
234 static mlib_status mlib_ImageConv1xN_ext(mlib_image *dst,
235 const mlib_image *src,
236 const mlib_d64 *k,
237 mlib_s32 n,
238 mlib_s32 dy_t,
239 mlib_s32 dy_b,
240 mlib_s32 cmask)
241 {
242 DTYPE *adr_src, *sl;
243 DTYPE *adr_dst, *dl, *dp;
244 FTYPE buff[BUFF_SIZE];
245 FTYPE *buffd;
246 FTYPE *pbuff = buff;
933 }
934
935 for (i = 0; i < dx_l; i++) buffn[i] = buffn[dx_l];
936 for (i = 0; i < dx_r; i++) buffn[swid + dx_l + i] = buffn[swid + dx_l - 1];
937
938 /* next line */
939
940 if (j < hgt - dy_b - 2) sl += sll;
941 dl += dll;
942
943 buff_ind++;
944
945 if (buff_ind >= n + 1) buff_ind = 0;
946 }
947 }
948
949 FREE_AND_RETURN_STATUS;
950 }
951
952 /***************************************************************/
953 #ifndef __sparc /* for x86, using integer multiplies is faster */
954
955 #define STORE_RES(res, x) \
956 x >>= shift2; \
957 CLAMP_STORE(res, x)
958
959 mlib_status CONV_FUNC_MxN_I
960 {
961 DTYPE *adr_src, *sl, *sp = NULL;
962 DTYPE *adr_dst, *dl, *dp = NULL;
963 mlib_s32 buff[BUFF_SIZE], *buffs_arr[2*(MAX_N + 1)];
964 mlib_s32 *pbuff = buff;
965 mlib_s32 **buffs = buffs_arr, *buffd;
966 mlib_s32 l, off, kw, bsize, buff_ind;
967 mlib_s32 d0, d1, shift1, shift2;
968 mlib_s32 k0, k1, k2, k3, k4, k5, k6;
969 mlib_s32 p0, p1, p2, p3, p4, p5, p6, p7;
970 mlib_s32 wid, hgt, sll, dll;
971 mlib_s32 nchannel, chan1;
972 mlib_s32 i, j, c, swid;
973 mlib_s32 chan2;
1411
1412 for (i = 0; i < dx_l; i++) buffn[i] = buffn[dx_l];
1413 for (i = 0; i < dx_r; i++) buffn[swid + dx_l + i] = buffn[swid + dx_l - 1];
1414
1415 /* next line */
1416
1417 if (j < hgt - dy_b - 2) sl += sll;
1418 dl += dll;
1419
1420 buff_ind++;
1421
1422 if (buff_ind >= n + 1) buff_ind = 0;
1423 }
1424 }
1425
1426 if (pbuff != buff) mlib_free(pbuff);
1427 if (k != k_locl) mlib_free(k);
1428
1429 return MLIB_SUCCESS;
1430 }
1431
1432 #endif /* __sparc ( for x86, using integer multiplies is faster ) */
1433
1434 /***************************************************************/
|
162 /***************************************************************/
163 typedef union {
164 mlib_d64 d64;
165 struct {
166 mlib_s32 i0;
167 mlib_s32 i1;
168 } i32s;
169 } d64_2x32;
170
171 /***************************************************************/
172 #define GET_SRC_DST_PARAMETERS(type) \
173 hgt = mlib_ImageGetHeight(src); \
174 wid = mlib_ImageGetWidth(src); \
175 nchannel = mlib_ImageGetChannels(src); \
176 sll = mlib_ImageGetStride(src) / sizeof(type); \
177 dll = mlib_ImageGetStride(dst) / sizeof(type); \
178 adr_src = (type *)mlib_ImageGetData(src); \
179 adr_dst = (type *)mlib_ImageGetData(dst)
180
181 /***************************************************************/
182 #if IMG_TYPE == 1
183
184 /*
185 * Test for the presence of any "1" bit in bits
186 8 to 31 of val. If present, then val is either
187 negative or >255. If over/underflows of 8 bits
188 are uncommon, then this technique can be a win,
189 since only a single test, rather than two, is
190 necessary to determine if clamping is needed.
191 On the other hand, if over/underflows are common,
192 it adds an extra test.
193 */
194 #define CLAMP_STORE(dst, val) \
195 if (val & 0xffffff00) { \
196 if (val < MLIB_U8_MIN) \
197 dst = MLIB_U8_MIN; \
198 else \
199 dst = MLIB_U8_MAX; \
200 } else { \
201 dst = (mlib_u8)val; \
205
206 #define CLAMP_STORE(dst, val) \
207 if (val >= MLIB_S16_MAX) \
208 dst = MLIB_S16_MAX; \
209 else if (val <= MLIB_S16_MIN) \
210 dst = MLIB_S16_MIN; \
211 else \
212 dst = (mlib_s16)val
213
214 #elif IMG_TYPE == 3
215
216 #define CLAMP_STORE(dst, val) \
217 if (val >= MLIB_U16_MAX) \
218 dst = MLIB_U16_MAX; \
219 else if (val <= MLIB_U16_MIN) \
220 dst = MLIB_U16_MIN; \
221 else \
222 dst = (mlib_u16)val
223
224 #endif /* IMG_TYPE == 1 */
225
226 /***************************************************************/
227 #define MAX_KER 7
228 #define MAX_N 15
229 #define BUFF_SIZE 1600
230 #define CACHE_SIZE (64*1024)
231
232 static mlib_status mlib_ImageConv1xN_ext(mlib_image *dst,
233 const mlib_image *src,
234 const mlib_d64 *k,
235 mlib_s32 n,
236 mlib_s32 dy_t,
237 mlib_s32 dy_b,
238 mlib_s32 cmask)
239 {
240 DTYPE *adr_src, *sl;
241 DTYPE *adr_dst, *dl, *dp;
242 FTYPE buff[BUFF_SIZE];
243 FTYPE *buffd;
244 FTYPE *pbuff = buff;
931 }
932
933 for (i = 0; i < dx_l; i++) buffn[i] = buffn[dx_l];
934 for (i = 0; i < dx_r; i++) buffn[swid + dx_l + i] = buffn[swid + dx_l - 1];
935
936 /* next line */
937
938 if (j < hgt - dy_b - 2) sl += sll;
939 dl += dll;
940
941 buff_ind++;
942
943 if (buff_ind >= n + 1) buff_ind = 0;
944 }
945 }
946
947 FREE_AND_RETURN_STATUS;
948 }
949
950 /***************************************************************/
951 /* for x86, using integer multiplies is faster */
952
953 #define STORE_RES(res, x) \
954 x >>= shift2; \
955 CLAMP_STORE(res, x)
956
957 mlib_status CONV_FUNC_MxN_I
958 {
959 DTYPE *adr_src, *sl, *sp = NULL;
960 DTYPE *adr_dst, *dl, *dp = NULL;
961 mlib_s32 buff[BUFF_SIZE], *buffs_arr[2*(MAX_N + 1)];
962 mlib_s32 *pbuff = buff;
963 mlib_s32 **buffs = buffs_arr, *buffd;
964 mlib_s32 l, off, kw, bsize, buff_ind;
965 mlib_s32 d0, d1, shift1, shift2;
966 mlib_s32 k0, k1, k2, k3, k4, k5, k6;
967 mlib_s32 p0, p1, p2, p3, p4, p5, p6, p7;
968 mlib_s32 wid, hgt, sll, dll;
969 mlib_s32 nchannel, chan1;
970 mlib_s32 i, j, c, swid;
971 mlib_s32 chan2;
1409
1410 for (i = 0; i < dx_l; i++) buffn[i] = buffn[dx_l];
1411 for (i = 0; i < dx_r; i++) buffn[swid + dx_l + i] = buffn[swid + dx_l - 1];
1412
1413 /* next line */
1414
1415 if (j < hgt - dy_b - 2) sl += sll;
1416 dl += dll;
1417
1418 buff_ind++;
1419
1420 if (buff_ind >= n + 1) buff_ind = 0;
1421 }
1422 }
1423
1424 if (pbuff != buff) mlib_free(pbuff);
1425 if (k != k_locl) mlib_free(k);
1426
1427 return MLIB_SUCCESS;
1428 }
1429
1430 /***************************************************************/
|