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 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_ImageCopy.h" 37#include "mlib_ImageAffine.h" 38#include "mlib_v_ImageFilters.h" 39#include "mlib_v_ImageChannelExtract.h" 40 41/*#define MLIB_VIS2*/ 42 43/***************************************************************/ 44#define DTYPE mlib_s16 45 46#define FUN_NAME(CHAN) mlib_ImageAffine_s16_##CHAN##_bl 47 48/***************************************************************/ 49static mlib_status FUN_NAME(2ch_na)(mlib_affine_param *param); 50static mlib_status FUN_NAME(4ch_na)(mlib_affine_param *param); 51 52/***************************************************************/ 53const mlib_u64 mlib_dmask_arr[] = { 54 0x0000000000000000, 0x000000000000FFFF, 0x00000000FFFF0000, 0x00000000FFFFFFFF, 55 0x0000FFFF00000000, 0x0000FFFF0000FFFF, 0x0000FFFFFFFF0000, 0x0000FFFFFFFFFFFF, 56 0xFFFF000000000000, 0xFFFF00000000FFFF, 0xFFFF0000FFFF0000, 0xFFFF0000FFFFFFFF, 57 0xFFFFFFFF00000000, 0xFFFFFFFF0000FFFF, 0xFFFFFFFFFFFF0000, 0xFFFFFFFFFFFFFFFF 58}; 59 60/***************************************************************/ 61#define XOR_8000(x) 62 63/***************************************************************/ 64#ifdef MLIB_VIS2 65#define MLIB_WRITE_BMASK(bmask) vis_write_bmask(bmask, 0) 66#else 67#define MLIB_WRITE_BMASK(bmask) 68#endif 69 70/***************************************************************/ 71#undef DECLAREVAR 72#define DECLAREVAR() \ 73 DECLAREVAR0(); \ 74 mlib_s32 *warp_tbl = param -> warp_tbl; \ 75 mlib_s32 srcYStride = param -> srcYStride; \ 76 mlib_u8 *dl; \ 77 mlib_s32 i, size; \ 78 /*mlib_d64 mask_8000 = vis_to_double_dup(0x80008000);*/ \ 79 mlib_d64 mask_7fff = vis_to_double_dup(0x7FFF7FFF); \ 80 mlib_d64 dx64, dy64, deltax, deltay, delta1_x, delta1_y; \ 81 mlib_d64 s0, s1, s2, s3; \ 82 mlib_d64 d0, d1, d2, d3, dd 83 84/***************************************************************/ 85 86/* arguments (x, y) are swapped to prevent overflow */ 87#define FMUL_16x16(x, y) \ 88 vis_fpadd16(vis_fmul8sux16(y, x), \ 89 vis_fmul8ulx16(y, x)) 90 91/***************************************************************/ 92#define BUF_SIZE 512 93 94/***************************************************************/ 95#define DOUBLE_4U16(x0, x1, x2, x3) \ 96 vis_to_double(((((x0) & 0xFFFE) << 15) | (((x1) & 0xFFFE) >> 1)), \ 97 ((((x2) & 0xFFFE) << 15) | (((x3) & 0xFFFE) >> 1))) 98 99/***************************************************************/ 100#define BL_SUM() \ 101 XOR_8000(s0); \ 102 XOR_8000(s1); \ 103 XOR_8000(s2); \ 104 XOR_8000(s3); \ 105 \ 106 delta1_x = vis_fpsub16(mask_7fff, deltax); \ 107 delta1_y = vis_fpsub16(mask_7fff, deltay); \ 108 \ 109 d0 = FMUL_16x16(s0, delta1_x); \ 110 d1 = FMUL_16x16(s1, deltax); \ 111 d0 = vis_fpadd16(d0, d1); \ 112 d0 = vis_fpadd16(d0, d0); \ 113 d0 = FMUL_16x16(d0, delta1_y); \ 114 \ 115 d2 = FMUL_16x16(s2, delta1_x); \ 116 d3 = FMUL_16x16(s3, deltax); \ 117 d2 = vis_fpadd16(d2, d3); \ 118 d2 = vis_fpadd16(d2, d2); \ 119 d2 = FMUL_16x16(d2, deltay); \ 120 \ 121 dd = vis_fpadd16(d0, d2); \ 122 dd = vis_fpadd16(dd, dd); \ 123 XOR_8000(dd); \ 124 \ 125 deltax = vis_fpadd16(deltax, dx64); \ 126 deltay = vis_fpadd16(deltay, dy64); \ 127 deltax = vis_fand(deltax, mask_7fff); \ 128 deltay = vis_fand(deltay, mask_7fff) 129 130/***************************************************************/ 131#define BL_SUM_3CH() \ 132 XOR_8000(s0); \ 133 XOR_8000(s1); \ 134 XOR_8000(s2); \ 135 XOR_8000(s3); \ 136 \ 137 delta1_x = vis_fpsub16(mask_7fff, deltax); \ 138 delta1_y = vis_fpsub16(mask_7fff, deltay); \ 139 \ 140 d0 = FMUL_16x16(s0, delta1_y); \ 141 d2 = FMUL_16x16(s2, deltay); \ 142 d0 = vis_fpadd16(d0, d2); \ 143 d0 = vis_fpadd16(d0, d0); \ 144 d0 = FMUL_16x16(d0, delta1_x); \ 145 \ 146 d1 = FMUL_16x16(s1, delta1_y); \ 147 d3 = FMUL_16x16(s3, deltay); \ 148 d1 = vis_fpadd16(d1, d3); \ 149 d1 = vis_fpadd16(d1, d1); \ 150 d1 = FMUL_16x16(d1, deltax); \ 151 \ 152 vis_alignaddr((void*)0, 2); \ 153 d0 = vis_faligndata(d0, d0); \ 154 dd = vis_fpadd16(d0, d1); \ 155 dd = vis_fpadd16(dd, dd); \ 156 XOR_8000(dd); \ 157 \ 158 deltax = vis_fpadd16(deltax, dx64); \ 159 deltay = vis_fpadd16(deltay, dy64); \ 160 deltax = vis_fand(deltax, mask_7fff); \ 161 deltay = vis_fand(deltay, mask_7fff) 162 163/***************************************************************/ 164#define LD_U16(sp, ind) vis_ld_u16(sp + ind) 165 166/***************************************************************/ 167#ifndef MLIB_VIS2 168 169#define LOAD_1CH() \ 170 s0 = vis_faligndata(LD_U16(sp3, 0), mask_7fff); \ 171 s1 = vis_faligndata(LD_U16(sp3, 2), mask_7fff); \ 172 s2 = vis_faligndata(LD_U16(sp3, srcYStride), mask_7fff); \ 173 s3 = vis_faligndata(LD_U16(sp3, srcYStride + 2), mask_7fff); \ 174 \ 175 s0 = vis_faligndata(LD_U16(sp2, 0), s0); \ 176 s1 = vis_faligndata(LD_U16(sp2, 2), s1); \ 177 s2 = vis_faligndata(LD_U16(sp2, srcYStride), s2); \ 178 s3 = vis_faligndata(LD_U16(sp2, srcYStride + 2), s3); \ 179 \ 180 s0 = vis_faligndata(LD_U16(sp1, 0), s0); \ 181 s1 = vis_faligndata(LD_U16(sp1, 2), s1); \ 182 s2 = vis_faligndata(LD_U16(sp1, srcYStride), s2); \ 183 s3 = vis_faligndata(LD_U16(sp1, srcYStride + 2), s3); \ 184 \ 185 s0 = vis_faligndata(LD_U16(sp0, 0), s0); \ 186 s1 = vis_faligndata(LD_U16(sp0, 2), s1); \ 187 s2 = vis_faligndata(LD_U16(sp0, srcYStride), s2); \ 188 s3 = vis_faligndata(LD_U16(sp0, srcYStride + 2), s3) 189 190#else 191 192#define LOAD_1CH() \ 193 s0 = vis_bshuffle(LD_U16(sp0, 0), LD_U16(sp2, 0)); \ 194 s1 = vis_bshuffle(LD_U16(sp0, 2), LD_U16(sp2, 2)); \ 195 s2 = vis_bshuffle(LD_U16(sp0, srcYStride), LD_U16(sp2, srcYStride)); \ 196 s3 = vis_bshuffle(LD_U16(sp0, srcYStride + 2), LD_U16(sp2, srcYStride + 2)); \ 197 \ 198 t0 = vis_bshuffle(LD_U16(sp1, 0), LD_U16(sp3, 0)); \ 199 t1 = vis_bshuffle(LD_U16(sp1, 2), LD_U16(sp3, 2)); \ 200 t2 = vis_bshuffle(LD_U16(sp1, srcYStride), LD_U16(sp3, srcYStride)); \ 201 t3 = vis_bshuffle(LD_U16(sp1, srcYStride + 2), LD_U16(sp3, srcYStride + 2)); \ 202 \ 203 s0 = vis_bshuffle(s0, t0); \ 204 s1 = vis_bshuffle(s1, t1); \ 205 s2 = vis_bshuffle(s2, t2); \ 206 s3 = vis_bshuffle(s3, t3) 207 208#endif 209 210/***************************************************************/ 211#define GET_POINTER(sp) \ 212 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + 2*(X >> MLIB_SHIFT); \ 213 X += dX; \ 214 Y += dY 215 216/***************************************************************/ 217#undef PREPARE_DELTAS 218#define PREPARE_DELTAS \ 219 if (warp_tbl != NULL) { \ 220 dX = warp_tbl[2*j ]; \ 221 dY = warp_tbl[2*j + 1]; \ 222 dx64 = vis_to_double_dup((((dX << 1) & 0xFFFF) << 16) | ((dX << 1) & 0xFFFF)); \ 223 dy64 = vis_to_double_dup((((dY << 1) & 0xFFFF) << 16) | ((dY << 1) & 0xFFFF)); \ 224 } 225 226/***************************************************************/ 227mlib_status FUN_NAME(1ch)(mlib_affine_param *param) 228{ 229 DECLAREVAR(); 230 mlib_s32 off; 231 mlib_s32 x0, x1, x2, x3, y0, y1, y2, y3; 232#ifdef MLIB_VIS2 233 mlib_d64 t0, t1, t2, t3; 234 vis_write_bmask(0x45CD67EF, 0); 235#else 236 vis_alignaddr((void*)0, 6); 237#endif 238 239 dx64 = vis_to_double_dup((((dX << 1) & 0xFFFF) << 16) | ((dX << 1) & 0xFFFF)); 240 dy64 = vis_to_double_dup((((dY << 1) & 0xFFFF) << 16) | ((dY << 1) & 0xFFFF)); 241 242 for (j = yStart; j <= yFinish; j++) { 243 mlib_u8 *sp0, *sp1, *sp2, *sp3; 244 mlib_d64 *dp, dmask; 245 246 NEW_LINE(1); 247 248 off = (mlib_s32)dl & 7; 249 dp = (mlib_d64*)(dl - off); 250 off >>= 1; 251 252 x0 = X - off*dX; y0 = Y - off*dY; 253 x1 = x0 + dX; y1 = y0 + dY; 254 x2 = x1 + dX; y2 = y1 + dY; 255 x3 = x2 + dX; y3 = y2 + dY; 256 257 deltax = DOUBLE_4U16(x0, x1, x2, x3); 258 deltay = DOUBLE_4U16(y0, y1, y2, y3); 259 260 if (off) { 261 mlib_s32 emask = vis_edge16((void*)(2*off), (void*)(2*(off + size - 1))); 262 263 off = 4 - off; 264 GET_POINTER(sp3); 265 sp0 = sp1 = sp2 = sp3; 266 267 if (off > 1 && size > 1) { 268 GET_POINTER(sp3); 269 } 270 271 if (off > 2) { 272 sp2 = sp3; 273 274 if (size > 2) { 275 GET_POINTER(sp3); 276 } 277 } 278 279 LOAD_1CH(); 280 BL_SUM(); 281 282 dmask = ((mlib_d64*)mlib_dmask_arr)[emask]; 283 *dp++ = vis_for (vis_fand(dmask, dd), vis_fandnot(dmask, dp[0])); 284 285 size -= off; 286 287 if (size < 0) size = 0; 288 } 289 290#pragma pipeloop(0) 291 for (i = 0; i < size/4; i++) { 292 GET_POINTER(sp0); 293 GET_POINTER(sp1); 294 GET_POINTER(sp2); 295 GET_POINTER(sp3); 296 297 LOAD_1CH(); 298 BL_SUM(); 299 300 dp[i] = dd; 301 } 302 303 off = size & 3; 304 305 if (off) { 306 GET_POINTER(sp0); 307 sp1 = sp2 = sp3 = sp0; 308 309 if (off > 1) { 310 GET_POINTER(sp1); 311 } 312 313 if (off > 2) { 314 GET_POINTER(sp2); 315 } 316 317 LOAD_1CH(); 318 BL_SUM(); 319 320 dmask = ((mlib_d64*)mlib_dmask_arr)[(0xF0 >> off) & 0x0F]; 321 dp[i] = vis_for (vis_fand(dmask, dd), vis_fandnot(dmask, dp[i])); 322 } 323 } 324 325 return MLIB_SUCCESS; 326} 327 328/***************************************************************/ 329#undef GET_POINTER 330#define GET_POINTER(sp) \ 331 sp = *(mlib_f32**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + (X >> MLIB_SHIFT); \ 332 X += dX; \ 333 Y += dY 334 335/***************************************************************/ 336#define LOAD_2CH() \ 337 s0 = vis_freg_pair(sp0[0], sp1[0]); \ 338 s1 = vis_freg_pair(sp0[1], sp1[1]); \ 339 s2 = vis_freg_pair(sp0[srcYStride], sp1[srcYStride]); \ 340 s3 = vis_freg_pair(sp0[srcYStride + 1], sp1[srcYStride + 1]) 341 342/***************************************************************/ 343#undef PREPARE_DELTAS 344#define PREPARE_DELTAS \ 345 if (warp_tbl != NULL) { \ 346 dX = warp_tbl[2*j ]; \ 347 dY = warp_tbl[2*j + 1]; \ 348 dx64 = vis_to_double_dup(((dX & 0xFFFF) << 16) | (dX & 0xFFFF)); \ 349 dy64 = vis_to_double_dup(((dY & 0xFFFF) << 16) | (dY & 0xFFFF)); \ 350 } 351 352/***************************************************************/ 353mlib_status FUN_NAME(2ch)(mlib_affine_param *param) 354{ 355 DECLAREVAR(); 356 mlib_s32 off; 357 mlib_s32 x0, x1, y0, y1; 358 359 if (((mlib_s32)lineAddr[0] | (mlib_s32)dstData | srcYStride | dstYStride) & 3) { 360 return FUN_NAME(2ch_na)(param); 361 } 362 363 srcYStride >>= 2; 364 365 dx64 = vis_to_double_dup(((dX & 0xFFFF) << 16) | (dX & 0xFFFF)); 366 dy64 = vis_to_double_dup(((dY & 0xFFFF) << 16) | (dY & 0xFFFF)); 367 368 for (j = yStart; j <= yFinish; j++) { 369 mlib_f32 *sp0, *sp1; 370 mlib_d64 *dp; 371 372 NEW_LINE(2); 373 374 off = (mlib_s32)dl & 7; 375 dp = (mlib_d64*)(dl - off); 376 377 if (off) { 378 x0 = X - dX; y0 = Y - dY; 379 x1 = X; y1 = Y; 380 } else { 381 x0 = X; y0 = Y; 382 x1 = X + dX; y1 = Y + dY; 383 } 384 385 deltax = DOUBLE_4U16(x0, x0, x1, x1); 386 deltay = DOUBLE_4U16(y0, y0, y1, y1); 387 388 if (off) { 389 GET_POINTER(sp1); 390 sp0 = sp1; 391 LOAD_2CH(); 392 393 BL_SUM(); 394 395 ((mlib_f32*)dp)[1] = vis_read_lo(dd); 396 dp++; 397 size--; 398 } 399 400#pragma pipeloop(0) 401 for (i = 0; i < size/2; i++) { 402 GET_POINTER(sp0); 403 GET_POINTER(sp1); 404 LOAD_2CH(); 405 406 BL_SUM(); 407 408 *dp++ = dd; 409 } 410 411 if (size & 1) { 412 GET_POINTER(sp0); 413 sp1 = sp0; 414 LOAD_2CH(); 415 416 BL_SUM(); 417 418 ((mlib_f32*)dp)[0] = vis_read_hi(dd); 419 } 420 } 421 422 return MLIB_SUCCESS; 423} 424 425/***************************************************************/ 426#undef GET_POINTER 427#define GET_POINTER(sp) \ 428 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + 4*(X >> MLIB_SHIFT); \ 429 X += dX; \ 430 Y += dY 431 432/***************************************************************/ 433#ifndef MLIB_VIS2 434 435#define LOAD_2CH_NA() \ 436 s0 = vis_faligndata(LD_U16(sp1, 2), mask_7fff); \ 437 s1 = vis_faligndata(LD_U16(sp1, 6), mask_7fff); \ 438 s2 = vis_faligndata(LD_U16(sp1, srcYStride + 2), mask_7fff); \ 439 s3 = vis_faligndata(LD_U16(sp1, srcYStride + 6), mask_7fff); \ 440 \ 441 s0 = vis_faligndata(LD_U16(sp1, 0), s0); \ 442 s1 = vis_faligndata(LD_U16(sp1, 4), s1); \ 443 s2 = vis_faligndata(LD_U16(sp1, srcYStride), s2); \ 444 s3 = vis_faligndata(LD_U16(sp1, srcYStride + 4), s3); \ 445 \ 446 s0 = vis_faligndata(LD_U16(sp0, 2), s0); \ 447 s1 = vis_faligndata(LD_U16(sp0, 6), s1); \ 448 s2 = vis_faligndata(LD_U16(sp0, srcYStride + 2), s2); \ 449 s3 = vis_faligndata(LD_U16(sp0, srcYStride + 6), s3); \ 450 \ 451 s0 = vis_faligndata(LD_U16(sp0, 0), s0); \ 452 s1 = vis_faligndata(LD_U16(sp0, 4), s1); \ 453 s2 = vis_faligndata(LD_U16(sp0, srcYStride), s2); \ 454 s3 = vis_faligndata(LD_U16(sp0, srcYStride + 4), s3) 455 456#else 457 458#define LOAD_2CH_NA() \ 459 s0 = vis_bshuffle(LD_U16(sp0, 0), LD_U16(sp1, 0)); \ 460 s1 = vis_bshuffle(LD_U16(sp0, 4), LD_U16(sp1, 4)); \ 461 s2 = vis_bshuffle(LD_U16(sp0, srcYStride), LD_U16(sp1, srcYStride)); \ 462 s3 = vis_bshuffle(LD_U16(sp0, srcYStride + 4), LD_U16(sp1, srcYStride + 4)); \ 463 \ 464 t0 = vis_bshuffle(LD_U16(sp0, 2), LD_U16(sp1, 2)); \ 465 t1 = vis_bshuffle(LD_U16(sp0, 6), LD_U16(sp1, 6)); \ 466 t2 = vis_bshuffle(LD_U16(sp0, srcYStride + 2), LD_U16(sp1, srcYStride + 2)); \ 467 t3 = vis_bshuffle(LD_U16(sp0, srcYStride + 6), LD_U16(sp1, srcYStride + 6)); \ 468 \ 469 s0 = vis_bshuffle(s0, t0); \ 470 s1 = vis_bshuffle(s1, t1); \ 471 s2 = vis_bshuffle(s2, t2); \ 472 s3 = vis_bshuffle(s3, t3) 473 474#endif 475 476/***************************************************************/ 477mlib_status FUN_NAME(2ch_na)(mlib_affine_param *param) 478{ 479 DECLAREVAR(); 480 mlib_s32 max_xsize = param -> max_xsize, bsize; 481 mlib_s32 x0, x1, y0, y1; 482 mlib_d64 buff[BUF_SIZE], *pbuff = buff; 483#ifdef MLIB_VIS2 484 mlib_d64 t0, t1, t2, t3; 485#endif 486 487 bsize = (max_xsize + 1)/2; 488 489 if (bsize > BUF_SIZE) { 490 pbuff = mlib_malloc(bsize*sizeof(mlib_d64)); 491 492 if (pbuff == NULL) return MLIB_FAILURE; 493 } 494 495 MLIB_WRITE_BMASK(0x45CD67EF); 496 497 dx64 = vis_to_double_dup(((dX & 0xFFFF) << 16) | (dX & 0xFFFF)); 498 dy64 = vis_to_double_dup(((dY & 0xFFFF) << 16) | (dY & 0xFFFF)); 499 500 for (j = yStart; j <= yFinish; j++) { 501 mlib_u8 *sp0, *sp1; 502 503#ifndef MLIB_VIS2 504 vis_alignaddr((void*)0, 6); 505#endif 506 507 NEW_LINE(2); 508 509 x0 = X; y0 = Y; 510 x1 = X + dX; y1 = Y + dY; 511 512 deltax = DOUBLE_4U16(x0, x0, x1, x1); 513 deltay = DOUBLE_4U16(y0, y0, y1, y1); 514 515#pragma pipeloop(0) 516 for (i = 0; i < size/2; i++) { 517 GET_POINTER(sp0); 518 GET_POINTER(sp1); 519 LOAD_2CH_NA(); 520 521 BL_SUM(); 522 523 pbuff[i] = dd; 524 } 525 526 if (size & 1) { 527 GET_POINTER(sp0); 528 sp1 = sp0; 529 LOAD_2CH_NA(); 530 531 BL_SUM(); 532 533 pbuff[i] = dd; 534 } 535 536 mlib_ImageCopy_na((mlib_u8*)pbuff, dl, 4*size); 537 } 538 539 if (pbuff != buff) { 540 mlib_free(pbuff); 541 } 542 543 return MLIB_SUCCESS; 544} 545 546/***************************************************************/ 547#undef PREPARE_DELTAS 548#define PREPARE_DELTAS \ 549 if (warp_tbl != NULL) { \ 550 dX = warp_tbl[2*j ]; \ 551 dY = warp_tbl[2*j + 1]; \ 552 dX = (dX - (dX >> 31)) &~ 1; /* rounding towards ZERO */ \ 553 dY = (dY - (dY >> 31)) &~ 1; /* rounding towards ZERO */ \ 554 dx64 = vis_to_double_dup((((dX >> 1) & 0xFFFF) << 16) | ((dX >> 1) & 0xFFFF)); \ 555 dy64 = vis_to_double_dup((((dY >> 1) & 0xFFFF) << 16) | ((dY >> 1) & 0xFFFF)); \ 556 } 557 558/***************************************************************/ 559mlib_status FUN_NAME(3ch)(mlib_affine_param *param) 560{ 561 DECLAREVAR(); 562 mlib_s32 max_xsize = param -> max_xsize; 563 mlib_d64 buff[BUF_SIZE], *pbuff = buff; 564 565 if (max_xsize > BUF_SIZE) { 566 pbuff = mlib_malloc(max_xsize*sizeof(mlib_d64)); 567 568 if (pbuff == NULL) return MLIB_FAILURE; 569 } 570 571 dX = (dX - (dX >> 31)) &~ 1; /* rounding towards ZERO */ 572 dY = (dY - (dY >> 31)) &~ 1; /* rounding towards ZERO */ 573 dx64 = vis_to_double_dup((((dX >> 1) & 0xFFFF) << 16) | ((dX >> 1) & 0xFFFF)); 574 dy64 = vis_to_double_dup((((dY >> 1) & 0xFFFF) << 16) | ((dY >> 1) & 0xFFFF)); 575 576 for (j = yStart; j <= yFinish; j++) { 577 mlib_u8 *sp; 578 mlib_d64 *sp0, *sp1; 579 580 NEW_LINE(3); 581 582 deltax = DOUBLE_4U16(X, X, X, X); 583 deltay = DOUBLE_4U16(Y, Y, Y, Y); 584 585#pragma pipeloop(0) 586 for (i = 0; i < size; i++) { 587 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + 6*(X >> MLIB_SHIFT) - 2; 588 589 vis_alignaddr(sp, 0); 590 sp0 = AL_ADDR(sp, 0); 591 s0 = vis_faligndata(sp0[0], sp0[1]); 592 s1 = vis_faligndata(sp0[1], sp0[2]); 593 594 vis_alignaddr(sp, srcYStride); 595 sp1 = AL_ADDR(sp, srcYStride); 596 s2 = vis_faligndata(sp1[0], sp1[1]); 597 s3 = vis_faligndata(sp1[1], sp1[2]); 598 599 BL_SUM_3CH(); 600 601 pbuff[i] = dd; 602 X += dX; 603 Y += dY; 604 } 605 606 mlib_v_ImageChannelExtract_S16_43L_D1((void *)pbuff, (void *)dl, size); 607 } 608 609 if (pbuff != buff) { 610 mlib_free(pbuff); 611 } 612 613 return MLIB_SUCCESS; 614} 615 616/***************************************************************/ 617mlib_status FUN_NAME(4ch)(mlib_affine_param *param) 618{ 619 DECLAREVAR(); 620 621 if (((mlib_s32)lineAddr[0] | (mlib_s32)dstData | srcYStride | dstYStride) & 7) { 622 return FUN_NAME(4ch_na)(param); 623 } 624 625 srcYStride >>= 3; 626 627 dX = (dX - (dX >> 31)) &~ 1; /* rounding towards ZERO */ 628 dY = (dY - (dY >> 31)) &~ 1; /* rounding towards ZERO */ 629 dx64 = vis_to_double_dup((((dX >> 1) & 0xFFFF) << 16) | ((dX >> 1) & 0xFFFF)); 630 dy64 = vis_to_double_dup((((dY >> 1) & 0xFFFF) << 16) | ((dY >> 1) & 0xFFFF)); 631 632 for (j = yStart; j <= yFinish; j++) { 633 mlib_d64 *sp; 634 635 NEW_LINE(4); 636 637 deltax = DOUBLE_4U16(X, X, X, X); 638 deltay = DOUBLE_4U16(Y, Y, Y, Y); 639 640#pragma pipeloop(0) 641 for (i = 0; i < size; i++) { 642 sp = *(mlib_d64**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + (X >> MLIB_SHIFT); 643 s0 = sp[0]; 644 s1 = sp[1]; 645 s2 = sp[srcYStride]; 646 s3 = sp[srcYStride + 1]; 647 648 BL_SUM(); 649 650 ((mlib_d64*)dl)[i] = dd; 651 X += dX; 652 Y += dY; 653 } 654 } 655 656 return MLIB_SUCCESS; 657} 658 659/***************************************************************/ 660mlib_status FUN_NAME(4ch_na)(mlib_affine_param *param) 661{ 662 DECLAREVAR(); 663 mlib_s32 max_xsize = param -> max_xsize; 664 mlib_d64 buff[BUF_SIZE], *pbuff = buff; 665 666 if (max_xsize > BUF_SIZE) { 667 pbuff = mlib_malloc(max_xsize*sizeof(mlib_d64)); 668 669 if (pbuff == NULL) return MLIB_FAILURE; 670 } 671 672 dX = (dX - (dX >> 31)) &~ 1; /* rounding towards ZERO */ 673 dY = (dY - (dY >> 31)) &~ 1; /* rounding towards ZERO */ 674 dx64 = vis_to_double_dup((((dX >> 1) & 0xFFFF) << 16) | ((dX >> 1) & 0xFFFF)); 675 dy64 = vis_to_double_dup((((dY >> 1) & 0xFFFF) << 16) | ((dY >> 1) & 0xFFFF)); 676 677 for (j = yStart; j <= yFinish; j++) { 678 mlib_u8 *sp; 679 mlib_d64 *sp0, *sp1; 680 681 NEW_LINE(4); 682 683 deltax = DOUBLE_4U16(X, X, X, X); 684 deltay = DOUBLE_4U16(Y, Y, Y, Y); 685 686#pragma pipeloop(0) 687 for (i = 0; i < size; i++) { 688 sp = *(mlib_u8**)((mlib_u8*)lineAddr + PTR_SHIFT(Y)) + 8*(X >> MLIB_SHIFT); 689 690 vis_alignaddr(sp, 0); 691 sp0 = AL_ADDR(sp, 0); 692 s0 = vis_faligndata(sp0[0], sp0[1]); 693 s1 = vis_faligndata(sp0[1], sp0[2]); 694 695 vis_alignaddr(sp, srcYStride); 696 sp1 = AL_ADDR(sp, srcYStride); 697 s2 = vis_faligndata(sp1[0], sp1[1]); 698 s3 = vis_faligndata(sp1[1], sp1[2]); 699 700 BL_SUM(); 701 702 pbuff[i] = dd; 703 X += dX; 704 Y += dY; 705 } 706 707 mlib_ImageCopy_na((mlib_u8*)pbuff, dl, 8*size); 708 } 709 710 if (pbuff != buff) { 711 mlib_free(pbuff); 712 } 713 714 return MLIB_SUCCESS; 715} 716 717/***************************************************************/ 718