Libav
|
00001 /* 00002 * Copyright (C) 2003 David S. Miller <davem@redhat.com> 00003 * 00004 * This file is part of FFmpeg. 00005 * 00006 * FFmpeg is free software; you can redistribute it and/or 00007 * modify it under the terms of the GNU Lesser General Public 00008 * License as published by the Free Software Foundation; either 00009 * version 2.1 of the License, or (at your option) any later version. 00010 * 00011 * FFmpeg is distributed in the hope that it will be useful, 00012 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00013 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00014 * Lesser General Public License for more details. 00015 * 00016 * You should have received a copy of the GNU Lesser General Public 00017 * License along with FFmpeg; if not, write to the Free Software 00018 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00019 */ 00020 00021 /* The *no_round* functions have been added by James A. Morrison, 2003,2004. 00022 The vis code from libmpeg2 was adapted for ffmpeg by James A. Morrison. 00023 */ 00024 00025 #include "config.h" 00026 00027 #include <inttypes.h> 00028 00029 #include "libavcodec/dsputil.h" 00030 #include "dsputil_vis.h" 00031 00032 #include "vis.h" 00033 00034 /* The trick used in some of this file is the formula from the MMX 00035 * motion comp code, which is: 00036 * 00037 * (x+y+1)>>1 == (x|y)-((x^y)>>1) 00038 * 00039 * This allows us to average 8 bytes at a time in a 64-bit FPU reg. 00040 * We avoid overflows by masking before we do the shift, and we 00041 * implement the shift by multiplying by 1/2 using mul8x16. So in 00042 * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask 00043 * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and 00044 * the value 0x80808080 is in f8): 00045 * 00046 * fxor f0, f2, f10 00047 * fand f10, f4, f10 00048 * fmul8x16 f8, f10, f10 00049 * fand f10, f6, f10 00050 * for f0, f2, f12 00051 * fpsub16 f12, f10, f10 00052 */ 00053 00054 #define DUP4(x) {x, x, x, x} 00055 #define DUP8(x) {x, x, x, x, x, x, x, x} 00056 DECLARE_ALIGNED(8, static const int16_t, constants1)[] = DUP4 (1); 00057 DECLARE_ALIGNED(8, static const int16_t, constants2)[] = DUP4 (2); 00058 DECLARE_ALIGNED(8, static const int16_t, constants3)[] = DUP4 (3); 00059 DECLARE_ALIGNED(8, static const int16_t, constants6)[] = DUP4 (6); 00060 DECLARE_ALIGNED(8, static const int8_t, constants_fe)[] = DUP8 (0xfe); 00061 DECLARE_ALIGNED(8, static const int8_t, constants_7f)[] = DUP8 (0x7f); 00062 DECLARE_ALIGNED(8, static const int8_t, constants128)[] = DUP8 (128); 00063 DECLARE_ALIGNED(8, static const int16_t, constants256_512)[] = 00064 {256, 512, 256, 512}; 00065 DECLARE_ALIGNED(8, static const int16_t, constants256_1024)[] = 00066 {256, 1024, 256, 1024}; 00067 00068 #define REF_0 0 00069 #define REF_0_1 1 00070 #define REF_2 2 00071 #define REF_2_1 3 00072 #define REF_4 4 00073 #define REF_4_1 5 00074 #define REF_6 6 00075 #define REF_6_1 7 00076 #define REF_S0 8 00077 #define REF_S0_1 9 00078 #define REF_S2 10 00079 #define REF_S2_1 11 00080 #define REF_S4 12 00081 #define REF_S4_1 13 00082 #define REF_S6 14 00083 #define REF_S6_1 15 00084 #define DST_0 16 00085 #define DST_1 17 00086 #define DST_2 18 00087 #define DST_3 19 00088 #define CONST_1 20 00089 #define CONST_2 20 00090 #define CONST_3 20 00091 #define CONST_6 20 00092 #define MASK_fe 20 00093 #define CONST_128 22 00094 #define CONST_256 22 00095 #define CONST_512 22 00096 #define CONST_1024 22 00097 #define TMP0 24 00098 #define TMP1 25 00099 #define TMP2 26 00100 #define TMP3 27 00101 #define TMP4 28 00102 #define TMP5 29 00103 #define ZERO 30 00104 #define MASK_7f 30 00105 00106 #define TMP6 32 00107 #define TMP8 34 00108 #define TMP10 36 00109 #define TMP12 38 00110 #define TMP14 40 00111 #define TMP16 42 00112 #define TMP18 44 00113 #define TMP20 46 00114 #define TMP22 48 00115 #define TMP24 50 00116 #define TMP26 52 00117 #define TMP28 54 00118 #define TMP30 56 00119 #define TMP32 58 00120 00121 static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * ref, 00122 const int stride, int height) 00123 { 00124 ref = vis_alignaddr(ref); 00125 do { /* 5 cycles */ 00126 vis_ld64(ref[0], TMP0); 00127 00128 vis_ld64_2(ref, 8, TMP2); 00129 00130 vis_ld64_2(ref, 16, TMP4); 00131 ref += stride; 00132 00133 vis_faligndata(TMP0, TMP2, REF_0); 00134 vis_st64(REF_0, dest[0]); 00135 00136 vis_faligndata(TMP2, TMP4, REF_2); 00137 vis_st64_2(REF_2, dest, 8); 00138 dest += stride; 00139 } while (--height); 00140 } 00141 00142 static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * ref, 00143 const int stride, int height) 00144 { 00145 ref = vis_alignaddr(ref); 00146 do { /* 4 cycles */ 00147 vis_ld64(ref[0], TMP0); 00148 00149 vis_ld64(ref[8], TMP2); 00150 ref += stride; 00151 00152 /* stall */ 00153 00154 vis_faligndata(TMP0, TMP2, REF_0); 00155 vis_st64(REF_0, dest[0]); 00156 dest += stride; 00157 } while (--height); 00158 } 00159 00160 00161 static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * ref, 00162 const int stride, int height) 00163 { 00164 int stride_8 = stride + 8; 00165 00166 ref = vis_alignaddr(ref); 00167 00168 vis_ld64(ref[0], TMP0); 00169 00170 vis_ld64(ref[8], TMP2); 00171 00172 vis_ld64(ref[16], TMP4); 00173 00174 vis_ld64(dest[0], DST_0); 00175 00176 vis_ld64(dest[8], DST_2); 00177 00178 vis_ld64(constants_fe[0], MASK_fe); 00179 vis_faligndata(TMP0, TMP2, REF_0); 00180 00181 vis_ld64(constants_7f[0], MASK_7f); 00182 vis_faligndata(TMP2, TMP4, REF_2); 00183 00184 vis_ld64(constants128[0], CONST_128); 00185 00186 ref += stride; 00187 height = (height >> 1) - 1; 00188 00189 do { /* 24 cycles */ 00190 vis_ld64(ref[0], TMP0); 00191 vis_xor(DST_0, REF_0, TMP6); 00192 00193 vis_ld64_2(ref, 8, TMP2); 00194 vis_and(TMP6, MASK_fe, TMP6); 00195 00196 vis_ld64_2(ref, 16, TMP4); 00197 ref += stride; 00198 vis_mul8x16(CONST_128, TMP6, TMP6); 00199 vis_xor(DST_2, REF_2, TMP8); 00200 00201 vis_and(TMP8, MASK_fe, TMP8); 00202 00203 vis_or(DST_0, REF_0, TMP10); 00204 vis_ld64_2(dest, stride, DST_0); 00205 vis_mul8x16(CONST_128, TMP8, TMP8); 00206 00207 vis_or(DST_2, REF_2, TMP12); 00208 vis_ld64_2(dest, stride_8, DST_2); 00209 00210 vis_ld64(ref[0], TMP14); 00211 vis_and(TMP6, MASK_7f, TMP6); 00212 00213 vis_and(TMP8, MASK_7f, TMP8); 00214 00215 vis_psub16(TMP10, TMP6, TMP6); 00216 vis_st64(TMP6, dest[0]); 00217 00218 vis_psub16(TMP12, TMP8, TMP8); 00219 vis_st64_2(TMP8, dest, 8); 00220 00221 dest += stride; 00222 vis_ld64_2(ref, 8, TMP16); 00223 vis_faligndata(TMP0, TMP2, REF_0); 00224 00225 vis_ld64_2(ref, 16, TMP18); 00226 vis_faligndata(TMP2, TMP4, REF_2); 00227 ref += stride; 00228 00229 vis_xor(DST_0, REF_0, TMP20); 00230 00231 vis_and(TMP20, MASK_fe, TMP20); 00232 00233 vis_xor(DST_2, REF_2, TMP22); 00234 vis_mul8x16(CONST_128, TMP20, TMP20); 00235 00236 vis_and(TMP22, MASK_fe, TMP22); 00237 00238 vis_or(DST_0, REF_0, TMP24); 00239 vis_mul8x16(CONST_128, TMP22, TMP22); 00240 00241 vis_or(DST_2, REF_2, TMP26); 00242 00243 vis_ld64_2(dest, stride, DST_0); 00244 vis_faligndata(TMP14, TMP16, REF_0); 00245 00246 vis_ld64_2(dest, stride_8, DST_2); 00247 vis_faligndata(TMP16, TMP18, REF_2); 00248 00249 vis_and(TMP20, MASK_7f, TMP20); 00250 00251 vis_and(TMP22, MASK_7f, TMP22); 00252 00253 vis_psub16(TMP24, TMP20, TMP20); 00254 vis_st64(TMP20, dest[0]); 00255 00256 vis_psub16(TMP26, TMP22, TMP22); 00257 vis_st64_2(TMP22, dest, 8); 00258 dest += stride; 00259 } while (--height); 00260 00261 vis_ld64(ref[0], TMP0); 00262 vis_xor(DST_0, REF_0, TMP6); 00263 00264 vis_ld64_2(ref, 8, TMP2); 00265 vis_and(TMP6, MASK_fe, TMP6); 00266 00267 vis_ld64_2(ref, 16, TMP4); 00268 vis_mul8x16(CONST_128, TMP6, TMP6); 00269 vis_xor(DST_2, REF_2, TMP8); 00270 00271 vis_and(TMP8, MASK_fe, TMP8); 00272 00273 vis_or(DST_0, REF_0, TMP10); 00274 vis_ld64_2(dest, stride, DST_0); 00275 vis_mul8x16(CONST_128, TMP8, TMP8); 00276 00277 vis_or(DST_2, REF_2, TMP12); 00278 vis_ld64_2(dest, stride_8, DST_2); 00279 00280 vis_ld64(ref[0], TMP14); 00281 vis_and(TMP6, MASK_7f, TMP6); 00282 00283 vis_and(TMP8, MASK_7f, TMP8); 00284 00285 vis_psub16(TMP10, TMP6, TMP6); 00286 vis_st64(TMP6, dest[0]); 00287 00288 vis_psub16(TMP12, TMP8, TMP8); 00289 vis_st64_2(TMP8, dest, 8); 00290 00291 dest += stride; 00292 vis_faligndata(TMP0, TMP2, REF_0); 00293 00294 vis_faligndata(TMP2, TMP4, REF_2); 00295 00296 vis_xor(DST_0, REF_0, TMP20); 00297 00298 vis_and(TMP20, MASK_fe, TMP20); 00299 00300 vis_xor(DST_2, REF_2, TMP22); 00301 vis_mul8x16(CONST_128, TMP20, TMP20); 00302 00303 vis_and(TMP22, MASK_fe, TMP22); 00304 00305 vis_or(DST_0, REF_0, TMP24); 00306 vis_mul8x16(CONST_128, TMP22, TMP22); 00307 00308 vis_or(DST_2, REF_2, TMP26); 00309 00310 vis_and(TMP20, MASK_7f, TMP20); 00311 00312 vis_and(TMP22, MASK_7f, TMP22); 00313 00314 vis_psub16(TMP24, TMP20, TMP20); 00315 vis_st64(TMP20, dest[0]); 00316 00317 vis_psub16(TMP26, TMP22, TMP22); 00318 vis_st64_2(TMP22, dest, 8); 00319 } 00320 00321 static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * ref, 00322 const int stride, int height) 00323 { 00324 ref = vis_alignaddr(ref); 00325 00326 vis_ld64(ref[0], TMP0); 00327 00328 vis_ld64(ref[8], TMP2); 00329 00330 vis_ld64(dest[0], DST_0); 00331 00332 vis_ld64(constants_fe[0], MASK_fe); 00333 00334 vis_ld64(constants_7f[0], MASK_7f); 00335 vis_faligndata(TMP0, TMP2, REF_0); 00336 00337 vis_ld64(constants128[0], CONST_128); 00338 00339 ref += stride; 00340 height = (height >> 1) - 1; 00341 00342 do { /* 12 cycles */ 00343 vis_ld64(ref[0], TMP0); 00344 vis_xor(DST_0, REF_0, TMP4); 00345 00346 vis_ld64(ref[8], TMP2); 00347 vis_and(TMP4, MASK_fe, TMP4); 00348 00349 vis_or(DST_0, REF_0, TMP6); 00350 vis_ld64_2(dest, stride, DST_0); 00351 ref += stride; 00352 vis_mul8x16(CONST_128, TMP4, TMP4); 00353 00354 vis_ld64(ref[0], TMP12); 00355 vis_faligndata(TMP0, TMP2, REF_0); 00356 00357 vis_ld64(ref[8], TMP2); 00358 vis_xor(DST_0, REF_0, TMP0); 00359 ref += stride; 00360 00361 vis_and(TMP0, MASK_fe, TMP0); 00362 00363 vis_and(TMP4, MASK_7f, TMP4); 00364 00365 vis_psub16(TMP6, TMP4, TMP4); 00366 vis_st64(TMP4, dest[0]); 00367 dest += stride; 00368 vis_mul8x16(CONST_128, TMP0, TMP0); 00369 00370 vis_or(DST_0, REF_0, TMP6); 00371 vis_ld64_2(dest, stride, DST_0); 00372 00373 vis_faligndata(TMP12, TMP2, REF_0); 00374 00375 vis_and(TMP0, MASK_7f, TMP0); 00376 00377 vis_psub16(TMP6, TMP0, TMP4); 00378 vis_st64(TMP4, dest[0]); 00379 dest += stride; 00380 } while (--height); 00381 00382 vis_ld64(ref[0], TMP0); 00383 vis_xor(DST_0, REF_0, TMP4); 00384 00385 vis_ld64(ref[8], TMP2); 00386 vis_and(TMP4, MASK_fe, TMP4); 00387 00388 vis_or(DST_0, REF_0, TMP6); 00389 vis_ld64_2(dest, stride, DST_0); 00390 vis_mul8x16(CONST_128, TMP4, TMP4); 00391 00392 vis_faligndata(TMP0, TMP2, REF_0); 00393 00394 vis_xor(DST_0, REF_0, TMP0); 00395 00396 vis_and(TMP0, MASK_fe, TMP0); 00397 00398 vis_and(TMP4, MASK_7f, TMP4); 00399 00400 vis_psub16(TMP6, TMP4, TMP4); 00401 vis_st64(TMP4, dest[0]); 00402 dest += stride; 00403 vis_mul8x16(CONST_128, TMP0, TMP0); 00404 00405 vis_or(DST_0, REF_0, TMP6); 00406 00407 vis_and(TMP0, MASK_7f, TMP0); 00408 00409 vis_psub16(TMP6, TMP0, TMP4); 00410 vis_st64(TMP4, dest[0]); 00411 } 00412 00413 static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * ref, 00414 const int stride, int height) 00415 { 00416 unsigned long off = (unsigned long) ref & 0x7; 00417 unsigned long off_plus_1 = off + 1; 00418 00419 ref = vis_alignaddr(ref); 00420 00421 vis_ld64(ref[0], TMP0); 00422 00423 vis_ld64_2(ref, 8, TMP2); 00424 00425 vis_ld64_2(ref, 16, TMP4); 00426 00427 vis_ld64(constants_fe[0], MASK_fe); 00428 00429 vis_ld64(constants_7f[0], MASK_7f); 00430 vis_faligndata(TMP0, TMP2, REF_0); 00431 00432 vis_ld64(constants128[0], CONST_128); 00433 vis_faligndata(TMP2, TMP4, REF_4); 00434 00435 if (off != 0x7) { 00436 vis_alignaddr_g0((void *)off_plus_1); 00437 vis_faligndata(TMP0, TMP2, REF_2); 00438 vis_faligndata(TMP2, TMP4, REF_6); 00439 } else { 00440 vis_src1(TMP2, REF_2); 00441 vis_src1(TMP4, REF_6); 00442 } 00443 00444 ref += stride; 00445 height = (height >> 1) - 1; 00446 00447 do { /* 34 cycles */ 00448 vis_ld64(ref[0], TMP0); 00449 vis_xor(REF_0, REF_2, TMP6); 00450 00451 vis_ld64_2(ref, 8, TMP2); 00452 vis_xor(REF_4, REF_6, TMP8); 00453 00454 vis_ld64_2(ref, 16, TMP4); 00455 vis_and(TMP6, MASK_fe, TMP6); 00456 ref += stride; 00457 00458 vis_ld64(ref[0], TMP14); 00459 vis_mul8x16(CONST_128, TMP6, TMP6); 00460 vis_and(TMP8, MASK_fe, TMP8); 00461 00462 vis_ld64_2(ref, 8, TMP16); 00463 vis_mul8x16(CONST_128, TMP8, TMP8); 00464 vis_or(REF_0, REF_2, TMP10); 00465 00466 vis_ld64_2(ref, 16, TMP18); 00467 ref += stride; 00468 vis_or(REF_4, REF_6, TMP12); 00469 00470 vis_alignaddr_g0((void *)off); 00471 00472 vis_faligndata(TMP0, TMP2, REF_0); 00473 00474 vis_faligndata(TMP2, TMP4, REF_4); 00475 00476 if (off != 0x7) { 00477 vis_alignaddr_g0((void *)off_plus_1); 00478 vis_faligndata(TMP0, TMP2, REF_2); 00479 vis_faligndata(TMP2, TMP4, REF_6); 00480 } else { 00481 vis_src1(TMP2, REF_2); 00482 vis_src1(TMP4, REF_6); 00483 } 00484 00485 vis_and(TMP6, MASK_7f, TMP6); 00486 00487 vis_and(TMP8, MASK_7f, TMP8); 00488 00489 vis_psub16(TMP10, TMP6, TMP6); 00490 vis_st64(TMP6, dest[0]); 00491 00492 vis_psub16(TMP12, TMP8, TMP8); 00493 vis_st64_2(TMP8, dest, 8); 00494 dest += stride; 00495 00496 vis_xor(REF_0, REF_2, TMP6); 00497 00498 vis_xor(REF_4, REF_6, TMP8); 00499 00500 vis_and(TMP6, MASK_fe, TMP6); 00501 00502 vis_mul8x16(CONST_128, TMP6, TMP6); 00503 vis_and(TMP8, MASK_fe, TMP8); 00504 00505 vis_mul8x16(CONST_128, TMP8, TMP8); 00506 vis_or(REF_0, REF_2, TMP10); 00507 00508 vis_or(REF_4, REF_6, TMP12); 00509 00510 vis_alignaddr_g0((void *)off); 00511 00512 vis_faligndata(TMP14, TMP16, REF_0); 00513 00514 vis_faligndata(TMP16, TMP18, REF_4); 00515 00516 if (off != 0x7) { 00517 vis_alignaddr_g0((void *)off_plus_1); 00518 vis_faligndata(TMP14, TMP16, REF_2); 00519 vis_faligndata(TMP16, TMP18, REF_6); 00520 } else { 00521 vis_src1(TMP16, REF_2); 00522 vis_src1(TMP18, REF_6); 00523 } 00524 00525 vis_and(TMP6, MASK_7f, TMP6); 00526 00527 vis_and(TMP8, MASK_7f, TMP8); 00528 00529 vis_psub16(TMP10, TMP6, TMP6); 00530 vis_st64(TMP6, dest[0]); 00531 00532 vis_psub16(TMP12, TMP8, TMP8); 00533 vis_st64_2(TMP8, dest, 8); 00534 dest += stride; 00535 } while (--height); 00536 00537 vis_ld64(ref[0], TMP0); 00538 vis_xor(REF_0, REF_2, TMP6); 00539 00540 vis_ld64_2(ref, 8, TMP2); 00541 vis_xor(REF_4, REF_6, TMP8); 00542 00543 vis_ld64_2(ref, 16, TMP4); 00544 vis_and(TMP6, MASK_fe, TMP6); 00545 00546 vis_mul8x16(CONST_128, TMP6, TMP6); 00547 vis_and(TMP8, MASK_fe, TMP8); 00548 00549 vis_mul8x16(CONST_128, TMP8, TMP8); 00550 vis_or(REF_0, REF_2, TMP10); 00551 00552 vis_or(REF_4, REF_6, TMP12); 00553 00554 vis_alignaddr_g0((void *)off); 00555 00556 vis_faligndata(TMP0, TMP2, REF_0); 00557 00558 vis_faligndata(TMP2, TMP4, REF_4); 00559 00560 if (off != 0x7) { 00561 vis_alignaddr_g0((void *)off_plus_1); 00562 vis_faligndata(TMP0, TMP2, REF_2); 00563 vis_faligndata(TMP2, TMP4, REF_6); 00564 } else { 00565 vis_src1(TMP2, REF_2); 00566 vis_src1(TMP4, REF_6); 00567 } 00568 00569 vis_and(TMP6, MASK_7f, TMP6); 00570 00571 vis_and(TMP8, MASK_7f, TMP8); 00572 00573 vis_psub16(TMP10, TMP6, TMP6); 00574 vis_st64(TMP6, dest[0]); 00575 00576 vis_psub16(TMP12, TMP8, TMP8); 00577 vis_st64_2(TMP8, dest, 8); 00578 dest += stride; 00579 00580 vis_xor(REF_0, REF_2, TMP6); 00581 00582 vis_xor(REF_4, REF_6, TMP8); 00583 00584 vis_and(TMP6, MASK_fe, TMP6); 00585 00586 vis_mul8x16(CONST_128, TMP6, TMP6); 00587 vis_and(TMP8, MASK_fe, TMP8); 00588 00589 vis_mul8x16(CONST_128, TMP8, TMP8); 00590 vis_or(REF_0, REF_2, TMP10); 00591 00592 vis_or(REF_4, REF_6, TMP12); 00593 00594 vis_and(TMP6, MASK_7f, TMP6); 00595 00596 vis_and(TMP8, MASK_7f, TMP8); 00597 00598 vis_psub16(TMP10, TMP6, TMP6); 00599 vis_st64(TMP6, dest[0]); 00600 00601 vis_psub16(TMP12, TMP8, TMP8); 00602 vis_st64_2(TMP8, dest, 8); 00603 } 00604 00605 static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * ref, 00606 const int stride, int height) 00607 { 00608 unsigned long off = (unsigned long) ref & 0x7; 00609 unsigned long off_plus_1 = off + 1; 00610 00611 ref = vis_alignaddr(ref); 00612 00613 vis_ld64(ref[0], TMP0); 00614 00615 vis_ld64(ref[8], TMP2); 00616 00617 vis_ld64(constants_fe[0], MASK_fe); 00618 00619 vis_ld64(constants_7f[0], MASK_7f); 00620 00621 vis_ld64(constants128[0], CONST_128); 00622 vis_faligndata(TMP0, TMP2, REF_0); 00623 00624 if (off != 0x7) { 00625 vis_alignaddr_g0((void *)off_plus_1); 00626 vis_faligndata(TMP0, TMP2, REF_2); 00627 } else { 00628 vis_src1(TMP2, REF_2); 00629 } 00630 00631 ref += stride; 00632 height = (height >> 1) - 1; 00633 00634 do { /* 20 cycles */ 00635 vis_ld64(ref[0], TMP0); 00636 vis_xor(REF_0, REF_2, TMP4); 00637 00638 vis_ld64_2(ref, 8, TMP2); 00639 vis_and(TMP4, MASK_fe, TMP4); 00640 ref += stride; 00641 00642 vis_ld64(ref[0], TMP8); 00643 vis_or(REF_0, REF_2, TMP6); 00644 vis_mul8x16(CONST_128, TMP4, TMP4); 00645 00646 vis_alignaddr_g0((void *)off); 00647 00648 vis_ld64_2(ref, 8, TMP10); 00649 ref += stride; 00650 vis_faligndata(TMP0, TMP2, REF_0); 00651 00652 if (off != 0x7) { 00653 vis_alignaddr_g0((void *)off_plus_1); 00654 vis_faligndata(TMP0, TMP2, REF_2); 00655 } else { 00656 vis_src1(TMP2, REF_2); 00657 } 00658 00659 vis_and(TMP4, MASK_7f, TMP4); 00660 00661 vis_psub16(TMP6, TMP4, DST_0); 00662 vis_st64(DST_0, dest[0]); 00663 dest += stride; 00664 00665 vis_xor(REF_0, REF_2, TMP12); 00666 00667 vis_and(TMP12, MASK_fe, TMP12); 00668 00669 vis_or(REF_0, REF_2, TMP14); 00670 vis_mul8x16(CONST_128, TMP12, TMP12); 00671 00672 vis_alignaddr_g0((void *)off); 00673 vis_faligndata(TMP8, TMP10, REF_0); 00674 if (off != 0x7) { 00675 vis_alignaddr_g0((void *)off_plus_1); 00676 vis_faligndata(TMP8, TMP10, REF_2); 00677 } else { 00678 vis_src1(TMP10, REF_2); 00679 } 00680 00681 vis_and(TMP12, MASK_7f, TMP12); 00682 00683 vis_psub16(TMP14, TMP12, DST_0); 00684 vis_st64(DST_0, dest[0]); 00685 dest += stride; 00686 } while (--height); 00687 00688 vis_ld64(ref[0], TMP0); 00689 vis_xor(REF_0, REF_2, TMP4); 00690 00691 vis_ld64_2(ref, 8, TMP2); 00692 vis_and(TMP4, MASK_fe, TMP4); 00693 00694 vis_or(REF_0, REF_2, TMP6); 00695 vis_mul8x16(CONST_128, TMP4, TMP4); 00696 00697 vis_alignaddr_g0((void *)off); 00698 00699 vis_faligndata(TMP0, TMP2, REF_0); 00700 00701 if (off != 0x7) { 00702 vis_alignaddr_g0((void *)off_plus_1); 00703 vis_faligndata(TMP0, TMP2, REF_2); 00704 } else { 00705 vis_src1(TMP2, REF_2); 00706 } 00707 00708 vis_and(TMP4, MASK_7f, TMP4); 00709 00710 vis_psub16(TMP6, TMP4, DST_0); 00711 vis_st64(DST_0, dest[0]); 00712 dest += stride; 00713 00714 vis_xor(REF_0, REF_2, TMP12); 00715 00716 vis_and(TMP12, MASK_fe, TMP12); 00717 00718 vis_or(REF_0, REF_2, TMP14); 00719 vis_mul8x16(CONST_128, TMP12, TMP12); 00720 00721 vis_and(TMP12, MASK_7f, TMP12); 00722 00723 vis_psub16(TMP14, TMP12, DST_0); 00724 vis_st64(DST_0, dest[0]); 00725 dest += stride; 00726 } 00727 00728 static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * ref, 00729 const int stride, int height) 00730 { 00731 unsigned long off = (unsigned long) ref & 0x7; 00732 unsigned long off_plus_1 = off + 1; 00733 00734 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 00735 00736 vis_ld64(constants3[0], CONST_3); 00737 vis_fzero(ZERO); 00738 vis_ld64(constants256_512[0], CONST_256); 00739 00740 ref = vis_alignaddr(ref); 00741 do { /* 26 cycles */ 00742 vis_ld64(ref[0], TMP0); 00743 00744 vis_ld64(ref[8], TMP2); 00745 00746 vis_alignaddr_g0((void *)off); 00747 00748 vis_ld64(ref[16], TMP4); 00749 00750 vis_ld64(dest[0], DST_0); 00751 vis_faligndata(TMP0, TMP2, REF_0); 00752 00753 vis_ld64(dest[8], DST_2); 00754 vis_faligndata(TMP2, TMP4, REF_4); 00755 00756 if (off != 0x7) { 00757 vis_alignaddr_g0((void *)off_plus_1); 00758 vis_faligndata(TMP0, TMP2, REF_2); 00759 vis_faligndata(TMP2, TMP4, REF_6); 00760 } else { 00761 vis_src1(TMP2, REF_2); 00762 vis_src1(TMP4, REF_6); 00763 } 00764 00765 vis_mul8x16au(REF_0, CONST_256, TMP0); 00766 00767 vis_pmerge(ZERO, REF_2, TMP4); 00768 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 00769 00770 vis_pmerge(ZERO, REF_2_1, TMP6); 00771 00772 vis_padd16(TMP0, TMP4, TMP0); 00773 00774 vis_mul8x16al(DST_0, CONST_512, TMP4); 00775 vis_padd16(TMP2, TMP6, TMP2); 00776 00777 vis_mul8x16al(DST_1, CONST_512, TMP6); 00778 00779 vis_mul8x16au(REF_6, CONST_256, TMP12); 00780 00781 vis_padd16(TMP0, TMP4, TMP0); 00782 vis_mul8x16au(REF_6_1, CONST_256, TMP14); 00783 00784 vis_padd16(TMP2, TMP6, TMP2); 00785 vis_mul8x16au(REF_4, CONST_256, TMP16); 00786 00787 vis_padd16(TMP0, CONST_3, TMP8); 00788 vis_mul8x16au(REF_4_1, CONST_256, TMP18); 00789 00790 vis_padd16(TMP2, CONST_3, TMP10); 00791 vis_pack16(TMP8, DST_0); 00792 00793 vis_pack16(TMP10, DST_1); 00794 vis_padd16(TMP16, TMP12, TMP0); 00795 00796 vis_st64(DST_0, dest[0]); 00797 vis_mul8x16al(DST_2, CONST_512, TMP4); 00798 vis_padd16(TMP18, TMP14, TMP2); 00799 00800 vis_mul8x16al(DST_3, CONST_512, TMP6); 00801 vis_padd16(TMP0, CONST_3, TMP0); 00802 00803 vis_padd16(TMP2, CONST_3, TMP2); 00804 00805 vis_padd16(TMP0, TMP4, TMP0); 00806 00807 vis_padd16(TMP2, TMP6, TMP2); 00808 vis_pack16(TMP0, DST_2); 00809 00810 vis_pack16(TMP2, DST_3); 00811 vis_st64(DST_2, dest[8]); 00812 00813 ref += stride; 00814 dest += stride; 00815 } while (--height); 00816 } 00817 00818 static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * ref, 00819 const int stride, int height) 00820 { 00821 unsigned long off = (unsigned long) ref & 0x7; 00822 unsigned long off_plus_1 = off + 1; 00823 int stride_times_2 = stride << 1; 00824 00825 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 00826 00827 vis_ld64(constants3[0], CONST_3); 00828 vis_fzero(ZERO); 00829 vis_ld64(constants256_512[0], CONST_256); 00830 00831 ref = vis_alignaddr(ref); 00832 height >>= 2; 00833 do { /* 47 cycles */ 00834 vis_ld64(ref[0], TMP0); 00835 00836 vis_ld64_2(ref, 8, TMP2); 00837 ref += stride; 00838 00839 vis_alignaddr_g0((void *)off); 00840 00841 vis_ld64(ref[0], TMP4); 00842 vis_faligndata(TMP0, TMP2, REF_0); 00843 00844 vis_ld64_2(ref, 8, TMP6); 00845 ref += stride; 00846 00847 vis_ld64(ref[0], TMP8); 00848 00849 vis_ld64_2(ref, 8, TMP10); 00850 ref += stride; 00851 vis_faligndata(TMP4, TMP6, REF_4); 00852 00853 vis_ld64(ref[0], TMP12); 00854 00855 vis_ld64_2(ref, 8, TMP14); 00856 ref += stride; 00857 vis_faligndata(TMP8, TMP10, REF_S0); 00858 00859 vis_faligndata(TMP12, TMP14, REF_S4); 00860 00861 if (off != 0x7) { 00862 vis_alignaddr_g0((void *)off_plus_1); 00863 00864 vis_ld64(dest[0], DST_0); 00865 vis_faligndata(TMP0, TMP2, REF_2); 00866 00867 vis_ld64_2(dest, stride, DST_2); 00868 vis_faligndata(TMP4, TMP6, REF_6); 00869 00870 vis_faligndata(TMP8, TMP10, REF_S2); 00871 00872 vis_faligndata(TMP12, TMP14, REF_S6); 00873 } else { 00874 vis_ld64(dest[0], DST_0); 00875 vis_src1(TMP2, REF_2); 00876 00877 vis_ld64_2(dest, stride, DST_2); 00878 vis_src1(TMP6, REF_6); 00879 00880 vis_src1(TMP10, REF_S2); 00881 00882 vis_src1(TMP14, REF_S6); 00883 } 00884 00885 vis_pmerge(ZERO, REF_0, TMP0); 00886 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 00887 00888 vis_pmerge(ZERO, REF_2, TMP4); 00889 vis_mul8x16au(REF_2_1, CONST_256, TMP6); 00890 00891 vis_padd16(TMP0, CONST_3, TMP0); 00892 vis_mul8x16al(DST_0, CONST_512, TMP16); 00893 00894 vis_padd16(TMP2, CONST_3, TMP2); 00895 vis_mul8x16al(DST_1, CONST_512, TMP18); 00896 00897 vis_padd16(TMP0, TMP4, TMP0); 00898 vis_mul8x16au(REF_4, CONST_256, TMP8); 00899 00900 vis_padd16(TMP2, TMP6, TMP2); 00901 vis_mul8x16au(REF_4_1, CONST_256, TMP10); 00902 00903 vis_padd16(TMP0, TMP16, TMP0); 00904 vis_mul8x16au(REF_6, CONST_256, TMP12); 00905 00906 vis_padd16(TMP2, TMP18, TMP2); 00907 vis_mul8x16au(REF_6_1, CONST_256, TMP14); 00908 00909 vis_padd16(TMP8, CONST_3, TMP8); 00910 vis_mul8x16al(DST_2, CONST_512, TMP16); 00911 00912 vis_padd16(TMP8, TMP12, TMP8); 00913 vis_mul8x16al(DST_3, CONST_512, TMP18); 00914 00915 vis_padd16(TMP10, TMP14, TMP10); 00916 vis_pack16(TMP0, DST_0); 00917 00918 vis_pack16(TMP2, DST_1); 00919 vis_st64(DST_0, dest[0]); 00920 dest += stride; 00921 vis_padd16(TMP10, CONST_3, TMP10); 00922 00923 vis_ld64_2(dest, stride, DST_0); 00924 vis_padd16(TMP8, TMP16, TMP8); 00925 00926 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/); 00927 vis_padd16(TMP10, TMP18, TMP10); 00928 vis_pack16(TMP8, DST_2); 00929 00930 vis_pack16(TMP10, DST_3); 00931 vis_st64(DST_2, dest[0]); 00932 dest += stride; 00933 00934 vis_mul8x16au(REF_S0_1, CONST_256, TMP2); 00935 vis_pmerge(ZERO, REF_S0, TMP0); 00936 00937 vis_pmerge(ZERO, REF_S2, TMP24); 00938 vis_mul8x16au(REF_S2_1, CONST_256, TMP6); 00939 00940 vis_padd16(TMP0, CONST_3, TMP0); 00941 vis_mul8x16au(REF_S4, CONST_256, TMP8); 00942 00943 vis_padd16(TMP2, CONST_3, TMP2); 00944 vis_mul8x16au(REF_S4_1, CONST_256, TMP10); 00945 00946 vis_padd16(TMP0, TMP24, TMP0); 00947 vis_mul8x16au(REF_S6, CONST_256, TMP12); 00948 00949 vis_padd16(TMP2, TMP6, TMP2); 00950 vis_mul8x16au(REF_S6_1, CONST_256, TMP14); 00951 00952 vis_padd16(TMP8, CONST_3, TMP8); 00953 vis_mul8x16al(DST_0, CONST_512, TMP16); 00954 00955 vis_padd16(TMP10, CONST_3, TMP10); 00956 vis_mul8x16al(DST_1, CONST_512, TMP18); 00957 00958 vis_padd16(TMP8, TMP12, TMP8); 00959 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20); 00960 00961 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22); 00962 vis_padd16(TMP0, TMP16, TMP0); 00963 00964 vis_padd16(TMP2, TMP18, TMP2); 00965 vis_pack16(TMP0, DST_0); 00966 00967 vis_padd16(TMP10, TMP14, TMP10); 00968 vis_pack16(TMP2, DST_1); 00969 vis_st64(DST_0, dest[0]); 00970 dest += stride; 00971 00972 vis_padd16(TMP8, TMP20, TMP8); 00973 00974 vis_padd16(TMP10, TMP22, TMP10); 00975 vis_pack16(TMP8, DST_2); 00976 00977 vis_pack16(TMP10, DST_3); 00978 vis_st64(DST_2, dest[0]); 00979 dest += stride; 00980 } while (--height); 00981 } 00982 00983 static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * ref, 00984 const int stride, int height) 00985 { 00986 ref = vis_alignaddr(ref); 00987 vis_ld64(ref[0], TMP0); 00988 00989 vis_ld64_2(ref, 8, TMP2); 00990 00991 vis_ld64_2(ref, 16, TMP4); 00992 ref += stride; 00993 00994 vis_ld64(ref[0], TMP6); 00995 vis_faligndata(TMP0, TMP2, REF_0); 00996 00997 vis_ld64_2(ref, 8, TMP8); 00998 vis_faligndata(TMP2, TMP4, REF_4); 00999 01000 vis_ld64_2(ref, 16, TMP10); 01001 ref += stride; 01002 01003 vis_ld64(constants_fe[0], MASK_fe); 01004 vis_faligndata(TMP6, TMP8, REF_2); 01005 01006 vis_ld64(constants_7f[0], MASK_7f); 01007 vis_faligndata(TMP8, TMP10, REF_6); 01008 01009 vis_ld64(constants128[0], CONST_128); 01010 height = (height >> 1) - 1; 01011 do { /* 24 cycles */ 01012 vis_ld64(ref[0], TMP0); 01013 vis_xor(REF_0, REF_2, TMP12); 01014 01015 vis_ld64_2(ref, 8, TMP2); 01016 vis_xor(REF_4, REF_6, TMP16); 01017 01018 vis_ld64_2(ref, 16, TMP4); 01019 ref += stride; 01020 vis_or(REF_0, REF_2, TMP14); 01021 01022 vis_ld64(ref[0], TMP6); 01023 vis_or(REF_4, REF_6, TMP18); 01024 01025 vis_ld64_2(ref, 8, TMP8); 01026 vis_faligndata(TMP0, TMP2, REF_0); 01027 01028 vis_ld64_2(ref, 16, TMP10); 01029 ref += stride; 01030 vis_faligndata(TMP2, TMP4, REF_4); 01031 01032 vis_and(TMP12, MASK_fe, TMP12); 01033 01034 vis_and(TMP16, MASK_fe, TMP16); 01035 vis_mul8x16(CONST_128, TMP12, TMP12); 01036 01037 vis_mul8x16(CONST_128, TMP16, TMP16); 01038 vis_xor(REF_0, REF_2, TMP0); 01039 01040 vis_xor(REF_4, REF_6, TMP2); 01041 01042 vis_or(REF_0, REF_2, TMP20); 01043 01044 vis_and(TMP12, MASK_7f, TMP12); 01045 01046 vis_and(TMP16, MASK_7f, TMP16); 01047 01048 vis_psub16(TMP14, TMP12, TMP12); 01049 vis_st64(TMP12, dest[0]); 01050 01051 vis_psub16(TMP18, TMP16, TMP16); 01052 vis_st64_2(TMP16, dest, 8); 01053 dest += stride; 01054 01055 vis_or(REF_4, REF_6, TMP18); 01056 01057 vis_and(TMP0, MASK_fe, TMP0); 01058 01059 vis_and(TMP2, MASK_fe, TMP2); 01060 vis_mul8x16(CONST_128, TMP0, TMP0); 01061 01062 vis_faligndata(TMP6, TMP8, REF_2); 01063 vis_mul8x16(CONST_128, TMP2, TMP2); 01064 01065 vis_faligndata(TMP8, TMP10, REF_6); 01066 01067 vis_and(TMP0, MASK_7f, TMP0); 01068 01069 vis_and(TMP2, MASK_7f, TMP2); 01070 01071 vis_psub16(TMP20, TMP0, TMP0); 01072 vis_st64(TMP0, dest[0]); 01073 01074 vis_psub16(TMP18, TMP2, TMP2); 01075 vis_st64_2(TMP2, dest, 8); 01076 dest += stride; 01077 } while (--height); 01078 01079 vis_ld64(ref[0], TMP0); 01080 vis_xor(REF_0, REF_2, TMP12); 01081 01082 vis_ld64_2(ref, 8, TMP2); 01083 vis_xor(REF_4, REF_6, TMP16); 01084 01085 vis_ld64_2(ref, 16, TMP4); 01086 vis_or(REF_0, REF_2, TMP14); 01087 01088 vis_or(REF_4, REF_6, TMP18); 01089 01090 vis_faligndata(TMP0, TMP2, REF_0); 01091 01092 vis_faligndata(TMP2, TMP4, REF_4); 01093 01094 vis_and(TMP12, MASK_fe, TMP12); 01095 01096 vis_and(TMP16, MASK_fe, TMP16); 01097 vis_mul8x16(CONST_128, TMP12, TMP12); 01098 01099 vis_mul8x16(CONST_128, TMP16, TMP16); 01100 vis_xor(REF_0, REF_2, TMP0); 01101 01102 vis_xor(REF_4, REF_6, TMP2); 01103 01104 vis_or(REF_0, REF_2, TMP20); 01105 01106 vis_and(TMP12, MASK_7f, TMP12); 01107 01108 vis_and(TMP16, MASK_7f, TMP16); 01109 01110 vis_psub16(TMP14, TMP12, TMP12); 01111 vis_st64(TMP12, dest[0]); 01112 01113 vis_psub16(TMP18, TMP16, TMP16); 01114 vis_st64_2(TMP16, dest, 8); 01115 dest += stride; 01116 01117 vis_or(REF_4, REF_6, TMP18); 01118 01119 vis_and(TMP0, MASK_fe, TMP0); 01120 01121 vis_and(TMP2, MASK_fe, TMP2); 01122 vis_mul8x16(CONST_128, TMP0, TMP0); 01123 01124 vis_mul8x16(CONST_128, TMP2, TMP2); 01125 01126 vis_and(TMP0, MASK_7f, TMP0); 01127 01128 vis_and(TMP2, MASK_7f, TMP2); 01129 01130 vis_psub16(TMP20, TMP0, TMP0); 01131 vis_st64(TMP0, dest[0]); 01132 01133 vis_psub16(TMP18, TMP2, TMP2); 01134 vis_st64_2(TMP2, dest, 8); 01135 } 01136 01137 static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * ref, 01138 const int stride, int height) 01139 { 01140 ref = vis_alignaddr(ref); 01141 vis_ld64(ref[0], TMP0); 01142 01143 vis_ld64_2(ref, 8, TMP2); 01144 ref += stride; 01145 01146 vis_ld64(ref[0], TMP4); 01147 01148 vis_ld64_2(ref, 8, TMP6); 01149 ref += stride; 01150 01151 vis_ld64(constants_fe[0], MASK_fe); 01152 vis_faligndata(TMP0, TMP2, REF_0); 01153 01154 vis_ld64(constants_7f[0], MASK_7f); 01155 vis_faligndata(TMP4, TMP6, REF_2); 01156 01157 vis_ld64(constants128[0], CONST_128); 01158 height = (height >> 1) - 1; 01159 do { /* 12 cycles */ 01160 vis_ld64(ref[0], TMP0); 01161 vis_xor(REF_0, REF_2, TMP4); 01162 01163 vis_ld64_2(ref, 8, TMP2); 01164 ref += stride; 01165 vis_and(TMP4, MASK_fe, TMP4); 01166 01167 vis_or(REF_0, REF_2, TMP6); 01168 vis_mul8x16(CONST_128, TMP4, TMP4); 01169 01170 vis_faligndata(TMP0, TMP2, REF_0); 01171 vis_ld64(ref[0], TMP0); 01172 01173 vis_ld64_2(ref, 8, TMP2); 01174 ref += stride; 01175 vis_xor(REF_0, REF_2, TMP12); 01176 01177 vis_and(TMP4, MASK_7f, TMP4); 01178 01179 vis_and(TMP12, MASK_fe, TMP12); 01180 01181 vis_mul8x16(CONST_128, TMP12, TMP12); 01182 vis_or(REF_0, REF_2, TMP14); 01183 01184 vis_psub16(TMP6, TMP4, DST_0); 01185 vis_st64(DST_0, dest[0]); 01186 dest += stride; 01187 01188 vis_faligndata(TMP0, TMP2, REF_2); 01189 01190 vis_and(TMP12, MASK_7f, TMP12); 01191 01192 vis_psub16(TMP14, TMP12, DST_0); 01193 vis_st64(DST_0, dest[0]); 01194 dest += stride; 01195 } while (--height); 01196 01197 vis_ld64(ref[0], TMP0); 01198 vis_xor(REF_0, REF_2, TMP4); 01199 01200 vis_ld64_2(ref, 8, TMP2); 01201 vis_and(TMP4, MASK_fe, TMP4); 01202 01203 vis_or(REF_0, REF_2, TMP6); 01204 vis_mul8x16(CONST_128, TMP4, TMP4); 01205 01206 vis_faligndata(TMP0, TMP2, REF_0); 01207 01208 vis_xor(REF_0, REF_2, TMP12); 01209 01210 vis_and(TMP4, MASK_7f, TMP4); 01211 01212 vis_and(TMP12, MASK_fe, TMP12); 01213 01214 vis_mul8x16(CONST_128, TMP12, TMP12); 01215 vis_or(REF_0, REF_2, TMP14); 01216 01217 vis_psub16(TMP6, TMP4, DST_0); 01218 vis_st64(DST_0, dest[0]); 01219 dest += stride; 01220 01221 vis_and(TMP12, MASK_7f, TMP12); 01222 01223 vis_psub16(TMP14, TMP12, DST_0); 01224 vis_st64(DST_0, dest[0]); 01225 } 01226 01227 static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * ref, 01228 const int stride, int height) 01229 { 01230 int stride_8 = stride + 8; 01231 int stride_16 = stride + 16; 01232 01233 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 01234 01235 ref = vis_alignaddr(ref); 01236 01237 vis_ld64(ref[ 0], TMP0); 01238 vis_fzero(ZERO); 01239 01240 vis_ld64(ref[ 8], TMP2); 01241 01242 vis_ld64(ref[16], TMP4); 01243 01244 vis_ld64(constants3[0], CONST_3); 01245 vis_faligndata(TMP0, TMP2, REF_2); 01246 01247 vis_ld64(constants256_512[0], CONST_256); 01248 vis_faligndata(TMP2, TMP4, REF_6); 01249 height >>= 1; 01250 01251 do { /* 31 cycles */ 01252 vis_ld64_2(ref, stride, TMP0); 01253 vis_pmerge(ZERO, REF_2, TMP12); 01254 vis_mul8x16au(REF_2_1, CONST_256, TMP14); 01255 01256 vis_ld64_2(ref, stride_8, TMP2); 01257 vis_pmerge(ZERO, REF_6, TMP16); 01258 vis_mul8x16au(REF_6_1, CONST_256, TMP18); 01259 01260 vis_ld64_2(ref, stride_16, TMP4); 01261 ref += stride; 01262 01263 vis_ld64(dest[0], DST_0); 01264 vis_faligndata(TMP0, TMP2, REF_0); 01265 01266 vis_ld64_2(dest, 8, DST_2); 01267 vis_faligndata(TMP2, TMP4, REF_4); 01268 01269 vis_ld64_2(ref, stride, TMP6); 01270 vis_pmerge(ZERO, REF_0, TMP0); 01271 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 01272 01273 vis_ld64_2(ref, stride_8, TMP8); 01274 vis_pmerge(ZERO, REF_4, TMP4); 01275 01276 vis_ld64_2(ref, stride_16, TMP10); 01277 ref += stride; 01278 01279 vis_ld64_2(dest, stride, REF_S0/*DST_4*/); 01280 vis_faligndata(TMP6, TMP8, REF_2); 01281 vis_mul8x16au(REF_4_1, CONST_256, TMP6); 01282 01283 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/); 01284 vis_faligndata(TMP8, TMP10, REF_6); 01285 vis_mul8x16al(DST_0, CONST_512, TMP20); 01286 01287 vis_padd16(TMP0, CONST_3, TMP0); 01288 vis_mul8x16al(DST_1, CONST_512, TMP22); 01289 01290 vis_padd16(TMP2, CONST_3, TMP2); 01291 vis_mul8x16al(DST_2, CONST_512, TMP24); 01292 01293 vis_padd16(TMP4, CONST_3, TMP4); 01294 vis_mul8x16al(DST_3, CONST_512, TMP26); 01295 01296 vis_padd16(TMP6, CONST_3, TMP6); 01297 01298 vis_padd16(TMP12, TMP20, TMP12); 01299 vis_mul8x16al(REF_S0, CONST_512, TMP20); 01300 01301 vis_padd16(TMP14, TMP22, TMP14); 01302 vis_mul8x16al(REF_S0_1, CONST_512, TMP22); 01303 01304 vis_padd16(TMP16, TMP24, TMP16); 01305 vis_mul8x16al(REF_S2, CONST_512, TMP24); 01306 01307 vis_padd16(TMP18, TMP26, TMP18); 01308 vis_mul8x16al(REF_S2_1, CONST_512, TMP26); 01309 01310 vis_padd16(TMP12, TMP0, TMP12); 01311 vis_mul8x16au(REF_2, CONST_256, TMP28); 01312 01313 vis_padd16(TMP14, TMP2, TMP14); 01314 vis_mul8x16au(REF_2_1, CONST_256, TMP30); 01315 01316 vis_padd16(TMP16, TMP4, TMP16); 01317 vis_mul8x16au(REF_6, CONST_256, REF_S4); 01318 01319 vis_padd16(TMP18, TMP6, TMP18); 01320 vis_mul8x16au(REF_6_1, CONST_256, REF_S6); 01321 01322 vis_pack16(TMP12, DST_0); 01323 vis_padd16(TMP28, TMP0, TMP12); 01324 01325 vis_pack16(TMP14, DST_1); 01326 vis_st64(DST_0, dest[0]); 01327 vis_padd16(TMP30, TMP2, TMP14); 01328 01329 vis_pack16(TMP16, DST_2); 01330 vis_padd16(REF_S4, TMP4, TMP16); 01331 01332 vis_pack16(TMP18, DST_3); 01333 vis_st64_2(DST_2, dest, 8); 01334 dest += stride; 01335 vis_padd16(REF_S6, TMP6, TMP18); 01336 01337 vis_padd16(TMP12, TMP20, TMP12); 01338 01339 vis_padd16(TMP14, TMP22, TMP14); 01340 vis_pack16(TMP12, DST_0); 01341 01342 vis_padd16(TMP16, TMP24, TMP16); 01343 vis_pack16(TMP14, DST_1); 01344 vis_st64(DST_0, dest[0]); 01345 01346 vis_padd16(TMP18, TMP26, TMP18); 01347 vis_pack16(TMP16, DST_2); 01348 01349 vis_pack16(TMP18, DST_3); 01350 vis_st64_2(DST_2, dest, 8); 01351 dest += stride; 01352 } while (--height); 01353 } 01354 01355 static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * ref, 01356 const int stride, int height) 01357 { 01358 int stride_8 = stride + 8; 01359 01360 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 01361 01362 ref = vis_alignaddr(ref); 01363 01364 vis_ld64(ref[ 0], TMP0); 01365 vis_fzero(ZERO); 01366 01367 vis_ld64(ref[ 8], TMP2); 01368 01369 vis_ld64(constants3[0], CONST_3); 01370 vis_faligndata(TMP0, TMP2, REF_2); 01371 01372 vis_ld64(constants256_512[0], CONST_256); 01373 01374 height >>= 1; 01375 do { /* 20 cycles */ 01376 vis_ld64_2(ref, stride, TMP0); 01377 vis_pmerge(ZERO, REF_2, TMP8); 01378 vis_mul8x16au(REF_2_1, CONST_256, TMP10); 01379 01380 vis_ld64_2(ref, stride_8, TMP2); 01381 ref += stride; 01382 01383 vis_ld64(dest[0], DST_0); 01384 01385 vis_ld64_2(dest, stride, DST_2); 01386 vis_faligndata(TMP0, TMP2, REF_0); 01387 01388 vis_ld64_2(ref, stride, TMP4); 01389 vis_mul8x16al(DST_0, CONST_512, TMP16); 01390 vis_pmerge(ZERO, REF_0, TMP12); 01391 01392 vis_ld64_2(ref, stride_8, TMP6); 01393 ref += stride; 01394 vis_mul8x16al(DST_1, CONST_512, TMP18); 01395 vis_pmerge(ZERO, REF_0_1, TMP14); 01396 01397 vis_padd16(TMP12, CONST_3, TMP12); 01398 vis_mul8x16al(DST_2, CONST_512, TMP24); 01399 01400 vis_padd16(TMP14, CONST_3, TMP14); 01401 vis_mul8x16al(DST_3, CONST_512, TMP26); 01402 01403 vis_faligndata(TMP4, TMP6, REF_2); 01404 01405 vis_padd16(TMP8, TMP12, TMP8); 01406 01407 vis_padd16(TMP10, TMP14, TMP10); 01408 vis_mul8x16au(REF_2, CONST_256, TMP20); 01409 01410 vis_padd16(TMP8, TMP16, TMP0); 01411 vis_mul8x16au(REF_2_1, CONST_256, TMP22); 01412 01413 vis_padd16(TMP10, TMP18, TMP2); 01414 vis_pack16(TMP0, DST_0); 01415 01416 vis_pack16(TMP2, DST_1); 01417 vis_st64(DST_0, dest[0]); 01418 dest += stride; 01419 vis_padd16(TMP12, TMP20, TMP12); 01420 01421 vis_padd16(TMP14, TMP22, TMP14); 01422 01423 vis_padd16(TMP12, TMP24, TMP0); 01424 01425 vis_padd16(TMP14, TMP26, TMP2); 01426 vis_pack16(TMP0, DST_2); 01427 01428 vis_pack16(TMP2, DST_3); 01429 vis_st64(DST_2, dest[0]); 01430 dest += stride; 01431 } while (--height); 01432 } 01433 01434 static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * ref, 01435 const int stride, int height) 01436 { 01437 unsigned long off = (unsigned long) ref & 0x7; 01438 unsigned long off_plus_1 = off + 1; 01439 int stride_8 = stride + 8; 01440 int stride_16 = stride + 16; 01441 01442 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 01443 01444 ref = vis_alignaddr(ref); 01445 01446 vis_ld64(ref[ 0], TMP0); 01447 vis_fzero(ZERO); 01448 01449 vis_ld64(ref[ 8], TMP2); 01450 01451 vis_ld64(ref[16], TMP4); 01452 01453 vis_ld64(constants2[0], CONST_2); 01454 vis_faligndata(TMP0, TMP2, REF_S0); 01455 01456 vis_ld64(constants256_512[0], CONST_256); 01457 vis_faligndata(TMP2, TMP4, REF_S4); 01458 01459 if (off != 0x7) { 01460 vis_alignaddr_g0((void *)off_plus_1); 01461 vis_faligndata(TMP0, TMP2, REF_S2); 01462 vis_faligndata(TMP2, TMP4, REF_S6); 01463 } else { 01464 vis_src1(TMP2, REF_S2); 01465 vis_src1(TMP4, REF_S6); 01466 } 01467 01468 height >>= 1; 01469 do { 01470 vis_ld64_2(ref, stride, TMP0); 01471 vis_mul8x16au(REF_S0, CONST_256, TMP12); 01472 vis_pmerge(ZERO, REF_S0_1, TMP14); 01473 01474 vis_alignaddr_g0((void *)off); 01475 01476 vis_ld64_2(ref, stride_8, TMP2); 01477 vis_mul8x16au(REF_S2, CONST_256, TMP16); 01478 vis_pmerge(ZERO, REF_S2_1, TMP18); 01479 01480 vis_ld64_2(ref, stride_16, TMP4); 01481 ref += stride; 01482 vis_mul8x16au(REF_S4, CONST_256, TMP20); 01483 vis_pmerge(ZERO, REF_S4_1, TMP22); 01484 01485 vis_ld64_2(ref, stride, TMP6); 01486 vis_mul8x16au(REF_S6, CONST_256, TMP24); 01487 vis_pmerge(ZERO, REF_S6_1, TMP26); 01488 01489 vis_ld64_2(ref, stride_8, TMP8); 01490 vis_faligndata(TMP0, TMP2, REF_0); 01491 01492 vis_ld64_2(ref, stride_16, TMP10); 01493 ref += stride; 01494 vis_faligndata(TMP2, TMP4, REF_4); 01495 01496 vis_faligndata(TMP6, TMP8, REF_S0); 01497 01498 vis_faligndata(TMP8, TMP10, REF_S4); 01499 01500 if (off != 0x7) { 01501 vis_alignaddr_g0((void *)off_plus_1); 01502 vis_faligndata(TMP0, TMP2, REF_2); 01503 vis_faligndata(TMP2, TMP4, REF_6); 01504 vis_faligndata(TMP6, TMP8, REF_S2); 01505 vis_faligndata(TMP8, TMP10, REF_S6); 01506 } else { 01507 vis_src1(TMP2, REF_2); 01508 vis_src1(TMP4, REF_6); 01509 vis_src1(TMP8, REF_S2); 01510 vis_src1(TMP10, REF_S6); 01511 } 01512 01513 vis_mul8x16au(REF_0, CONST_256, TMP0); 01514 vis_pmerge(ZERO, REF_0_1, TMP2); 01515 01516 vis_mul8x16au(REF_2, CONST_256, TMP4); 01517 vis_pmerge(ZERO, REF_2_1, TMP6); 01518 01519 vis_padd16(TMP0, CONST_2, TMP8); 01520 vis_mul8x16au(REF_4, CONST_256, TMP0); 01521 01522 vis_padd16(TMP2, CONST_2, TMP10); 01523 vis_mul8x16au(REF_4_1, CONST_256, TMP2); 01524 01525 vis_padd16(TMP8, TMP4, TMP8); 01526 vis_mul8x16au(REF_6, CONST_256, TMP4); 01527 01528 vis_padd16(TMP10, TMP6, TMP10); 01529 vis_mul8x16au(REF_6_1, CONST_256, TMP6); 01530 01531 vis_padd16(TMP12, TMP8, TMP12); 01532 01533 vis_padd16(TMP14, TMP10, TMP14); 01534 01535 vis_padd16(TMP12, TMP16, TMP12); 01536 01537 vis_padd16(TMP14, TMP18, TMP14); 01538 vis_pack16(TMP12, DST_0); 01539 01540 vis_pack16(TMP14, DST_1); 01541 vis_st64(DST_0, dest[0]); 01542 vis_padd16(TMP0, CONST_2, TMP12); 01543 01544 vis_mul8x16au(REF_S0, CONST_256, TMP0); 01545 vis_padd16(TMP2, CONST_2, TMP14); 01546 01547 vis_mul8x16au(REF_S0_1, CONST_256, TMP2); 01548 vis_padd16(TMP12, TMP4, TMP12); 01549 01550 vis_mul8x16au(REF_S2, CONST_256, TMP4); 01551 vis_padd16(TMP14, TMP6, TMP14); 01552 01553 vis_mul8x16au(REF_S2_1, CONST_256, TMP6); 01554 vis_padd16(TMP20, TMP12, TMP20); 01555 01556 vis_padd16(TMP22, TMP14, TMP22); 01557 01558 vis_padd16(TMP20, TMP24, TMP20); 01559 01560 vis_padd16(TMP22, TMP26, TMP22); 01561 vis_pack16(TMP20, DST_2); 01562 01563 vis_pack16(TMP22, DST_3); 01564 vis_st64_2(DST_2, dest, 8); 01565 dest += stride; 01566 vis_padd16(TMP0, TMP4, TMP24); 01567 01568 vis_mul8x16au(REF_S4, CONST_256, TMP0); 01569 vis_padd16(TMP2, TMP6, TMP26); 01570 01571 vis_mul8x16au(REF_S4_1, CONST_256, TMP2); 01572 vis_padd16(TMP24, TMP8, TMP24); 01573 01574 vis_padd16(TMP26, TMP10, TMP26); 01575 vis_pack16(TMP24, DST_0); 01576 01577 vis_pack16(TMP26, DST_1); 01578 vis_st64(DST_0, dest[0]); 01579 vis_pmerge(ZERO, REF_S6, TMP4); 01580 01581 vis_pmerge(ZERO, REF_S6_1, TMP6); 01582 01583 vis_padd16(TMP0, TMP4, TMP0); 01584 01585 vis_padd16(TMP2, TMP6, TMP2); 01586 01587 vis_padd16(TMP0, TMP12, TMP0); 01588 01589 vis_padd16(TMP2, TMP14, TMP2); 01590 vis_pack16(TMP0, DST_2); 01591 01592 vis_pack16(TMP2, DST_3); 01593 vis_st64_2(DST_2, dest, 8); 01594 dest += stride; 01595 } while (--height); 01596 } 01597 01598 static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * ref, 01599 const int stride, int height) 01600 { 01601 unsigned long off = (unsigned long) ref & 0x7; 01602 unsigned long off_plus_1 = off + 1; 01603 int stride_8 = stride + 8; 01604 01605 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 01606 01607 ref = vis_alignaddr(ref); 01608 01609 vis_ld64(ref[ 0], TMP0); 01610 vis_fzero(ZERO); 01611 01612 vis_ld64(ref[ 8], TMP2); 01613 01614 vis_ld64(constants2[0], CONST_2); 01615 01616 vis_ld64(constants256_512[0], CONST_256); 01617 vis_faligndata(TMP0, TMP2, REF_S0); 01618 01619 if (off != 0x7) { 01620 vis_alignaddr_g0((void *)off_plus_1); 01621 vis_faligndata(TMP0, TMP2, REF_S2); 01622 } else { 01623 vis_src1(TMP2, REF_S2); 01624 } 01625 01626 height >>= 1; 01627 do { /* 26 cycles */ 01628 vis_ld64_2(ref, stride, TMP0); 01629 vis_mul8x16au(REF_S0, CONST_256, TMP8); 01630 vis_pmerge(ZERO, REF_S2, TMP12); 01631 01632 vis_alignaddr_g0((void *)off); 01633 01634 vis_ld64_2(ref, stride_8, TMP2); 01635 ref += stride; 01636 vis_mul8x16au(REF_S0_1, CONST_256, TMP10); 01637 vis_pmerge(ZERO, REF_S2_1, TMP14); 01638 01639 vis_ld64_2(ref, stride, TMP4); 01640 01641 vis_ld64_2(ref, stride_8, TMP6); 01642 ref += stride; 01643 vis_faligndata(TMP0, TMP2, REF_S4); 01644 01645 vis_pmerge(ZERO, REF_S4, TMP18); 01646 01647 vis_pmerge(ZERO, REF_S4_1, TMP20); 01648 01649 vis_faligndata(TMP4, TMP6, REF_S0); 01650 01651 if (off != 0x7) { 01652 vis_alignaddr_g0((void *)off_plus_1); 01653 vis_faligndata(TMP0, TMP2, REF_S6); 01654 vis_faligndata(TMP4, TMP6, REF_S2); 01655 } else { 01656 vis_src1(TMP2, REF_S6); 01657 vis_src1(TMP6, REF_S2); 01658 } 01659 01660 vis_padd16(TMP18, CONST_2, TMP18); 01661 vis_mul8x16au(REF_S6, CONST_256, TMP22); 01662 01663 vis_padd16(TMP20, CONST_2, TMP20); 01664 vis_mul8x16au(REF_S6_1, CONST_256, TMP24); 01665 01666 vis_mul8x16au(REF_S0, CONST_256, TMP26); 01667 vis_pmerge(ZERO, REF_S0_1, TMP28); 01668 01669 vis_mul8x16au(REF_S2, CONST_256, TMP30); 01670 vis_padd16(TMP18, TMP22, TMP18); 01671 01672 vis_mul8x16au(REF_S2_1, CONST_256, TMP32); 01673 vis_padd16(TMP20, TMP24, TMP20); 01674 01675 vis_padd16(TMP8, TMP18, TMP8); 01676 01677 vis_padd16(TMP10, TMP20, TMP10); 01678 01679 vis_padd16(TMP8, TMP12, TMP8); 01680 01681 vis_padd16(TMP10, TMP14, TMP10); 01682 vis_pack16(TMP8, DST_0); 01683 01684 vis_pack16(TMP10, DST_1); 01685 vis_st64(DST_0, dest[0]); 01686 dest += stride; 01687 vis_padd16(TMP18, TMP26, TMP18); 01688 01689 vis_padd16(TMP20, TMP28, TMP20); 01690 01691 vis_padd16(TMP18, TMP30, TMP18); 01692 01693 vis_padd16(TMP20, TMP32, TMP20); 01694 vis_pack16(TMP18, DST_2); 01695 01696 vis_pack16(TMP20, DST_3); 01697 vis_st64(DST_2, dest[0]); 01698 dest += stride; 01699 } while (--height); 01700 } 01701 01702 static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * ref, 01703 const int stride, int height) 01704 { 01705 unsigned long off = (unsigned long) ref & 0x7; 01706 unsigned long off_plus_1 = off + 1; 01707 int stride_8 = stride + 8; 01708 int stride_16 = stride + 16; 01709 01710 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT); 01711 01712 ref = vis_alignaddr(ref); 01713 01714 vis_ld64(ref[ 0], TMP0); 01715 vis_fzero(ZERO); 01716 01717 vis_ld64(ref[ 8], TMP2); 01718 01719 vis_ld64(ref[16], TMP4); 01720 01721 vis_ld64(constants6[0], CONST_6); 01722 vis_faligndata(TMP0, TMP2, REF_S0); 01723 01724 vis_ld64(constants256_1024[0], CONST_256); 01725 vis_faligndata(TMP2, TMP4, REF_S4); 01726 01727 if (off != 0x7) { 01728 vis_alignaddr_g0((void *)off_plus_1); 01729 vis_faligndata(TMP0, TMP2, REF_S2); 01730 vis_faligndata(TMP2, TMP4, REF_S6); 01731 } else { 01732 vis_src1(TMP2, REF_S2); 01733 vis_src1(TMP4, REF_S6); 01734 } 01735 01736 height >>= 1; 01737 do { /* 55 cycles */ 01738 vis_ld64_2(ref, stride, TMP0); 01739 vis_mul8x16au(REF_S0, CONST_256, TMP12); 01740 vis_pmerge(ZERO, REF_S0_1, TMP14); 01741 01742 vis_alignaddr_g0((void *)off); 01743 01744 vis_ld64_2(ref, stride_8, TMP2); 01745 vis_mul8x16au(REF_S2, CONST_256, TMP16); 01746 vis_pmerge(ZERO, REF_S2_1, TMP18); 01747 01748 vis_ld64_2(ref, stride_16, TMP4); 01749 ref += stride; 01750 vis_mul8x16au(REF_S4, CONST_256, TMP20); 01751 vis_pmerge(ZERO, REF_S4_1, TMP22); 01752 01753 vis_ld64_2(ref, stride, TMP6); 01754 vis_mul8x16au(REF_S6, CONST_256, TMP24); 01755 vis_pmerge(ZERO, REF_S6_1, TMP26); 01756 01757 vis_ld64_2(ref, stride_8, TMP8); 01758 vis_faligndata(TMP0, TMP2, REF_0); 01759 01760 vis_ld64_2(ref, stride_16, TMP10); 01761 ref += stride; 01762 vis_faligndata(TMP2, TMP4, REF_4); 01763 01764 vis_ld64(dest[0], DST_0); 01765 vis_faligndata(TMP6, TMP8, REF_S0); 01766 01767 vis_ld64_2(dest, 8, DST_2); 01768 vis_faligndata(TMP8, TMP10, REF_S4); 01769 01770 if (off != 0x7) { 01771 vis_alignaddr_g0((void *)off_plus_1); 01772 vis_faligndata(TMP0, TMP2, REF_2); 01773 vis_faligndata(TMP2, TMP4, REF_6); 01774 vis_faligndata(TMP6, TMP8, REF_S2); 01775 vis_faligndata(TMP8, TMP10, REF_S6); 01776 } else { 01777 vis_src1(TMP2, REF_2); 01778 vis_src1(TMP4, REF_6); 01779 vis_src1(TMP8, REF_S2); 01780 vis_src1(TMP10, REF_S6); 01781 } 01782 01783 vis_mul8x16al(DST_0, CONST_1024, TMP30); 01784 vis_pmerge(ZERO, REF_0, TMP0); 01785 01786 vis_mul8x16al(DST_1, CONST_1024, TMP32); 01787 vis_pmerge(ZERO, REF_0_1, TMP2); 01788 01789 vis_mul8x16au(REF_2, CONST_256, TMP4); 01790 vis_pmerge(ZERO, REF_2_1, TMP6); 01791 01792 vis_mul8x16al(DST_2, CONST_1024, REF_0); 01793 vis_padd16(TMP0, CONST_6, TMP0); 01794 01795 vis_mul8x16al(DST_3, CONST_1024, REF_2); 01796 vis_padd16(TMP2, CONST_6, TMP2); 01797 01798 vis_padd16(TMP0, TMP4, TMP0); 01799 vis_mul8x16au(REF_4, CONST_256, TMP4); 01800 01801 vis_padd16(TMP2, TMP6, TMP2); 01802 vis_mul8x16au(REF_4_1, CONST_256, TMP6); 01803 01804 vis_padd16(TMP12, TMP0, TMP12); 01805 vis_mul8x16au(REF_6, CONST_256, TMP8); 01806 01807 vis_padd16(TMP14, TMP2, TMP14); 01808 vis_mul8x16au(REF_6_1, CONST_256, TMP10); 01809 01810 vis_padd16(TMP12, TMP16, TMP12); 01811 vis_mul8x16au(REF_S0, CONST_256, REF_4); 01812 01813 vis_padd16(TMP14, TMP18, TMP14); 01814 vis_mul8x16au(REF_S0_1, CONST_256, REF_6); 01815 01816 vis_padd16(TMP12, TMP30, TMP12); 01817 01818 vis_padd16(TMP14, TMP32, TMP14); 01819 vis_pack16(TMP12, DST_0); 01820 01821 vis_pack16(TMP14, DST_1); 01822 vis_st64(DST_0, dest[0]); 01823 vis_padd16(TMP4, CONST_6, TMP4); 01824 01825 vis_ld64_2(dest, stride, DST_0); 01826 vis_padd16(TMP6, CONST_6, TMP6); 01827 vis_mul8x16au(REF_S2, CONST_256, TMP12); 01828 01829 vis_padd16(TMP4, TMP8, TMP4); 01830 vis_mul8x16au(REF_S2_1, CONST_256, TMP14); 01831 01832 vis_padd16(TMP6, TMP10, TMP6); 01833 01834 vis_padd16(TMP20, TMP4, TMP20); 01835 01836 vis_padd16(TMP22, TMP6, TMP22); 01837 01838 vis_padd16(TMP20, TMP24, TMP20); 01839 01840 vis_padd16(TMP22, TMP26, TMP22); 01841 01842 vis_padd16(TMP20, REF_0, TMP20); 01843 vis_mul8x16au(REF_S4, CONST_256, REF_0); 01844 01845 vis_padd16(TMP22, REF_2, TMP22); 01846 vis_pack16(TMP20, DST_2); 01847 01848 vis_pack16(TMP22, DST_3); 01849 vis_st64_2(DST_2, dest, 8); 01850 dest += stride; 01851 01852 vis_ld64_2(dest, 8, DST_2); 01853 vis_mul8x16al(DST_0, CONST_1024, TMP30); 01854 vis_pmerge(ZERO, REF_S4_1, REF_2); 01855 01856 vis_mul8x16al(DST_1, CONST_1024, TMP32); 01857 vis_padd16(REF_4, TMP0, TMP8); 01858 01859 vis_mul8x16au(REF_S6, CONST_256, REF_4); 01860 vis_padd16(REF_6, TMP2, TMP10); 01861 01862 vis_mul8x16au(REF_S6_1, CONST_256, REF_6); 01863 vis_padd16(TMP8, TMP12, TMP8); 01864 01865 vis_padd16(TMP10, TMP14, TMP10); 01866 01867 vis_padd16(TMP8, TMP30, TMP8); 01868 01869 vis_padd16(TMP10, TMP32, TMP10); 01870 vis_pack16(TMP8, DST_0); 01871 01872 vis_pack16(TMP10, DST_1); 01873 vis_st64(DST_0, dest[0]); 01874 01875 vis_padd16(REF_0, TMP4, REF_0); 01876 01877 vis_mul8x16al(DST_2, CONST_1024, TMP30); 01878 vis_padd16(REF_2, TMP6, REF_2); 01879 01880 vis_mul8x16al(DST_3, CONST_1024, TMP32); 01881 vis_padd16(REF_0, REF_4, REF_0); 01882 01883 vis_padd16(REF_2, REF_6, REF_2); 01884 01885 vis_padd16(REF_0, TMP30, REF_0); 01886 01887 /* stall */ 01888 01889 vis_padd16(REF_2, TMP32, REF_2); 01890 vis_pack16(REF_0, DST_2); 01891 01892 vis_pack16(REF_2, DST_3); 01893 vis_st64_2(DST_2, dest, 8); 01894 dest += stride; 01895 } while (--height); 01896 } 01897 01898 static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * ref, 01899 const int stride, int height) 01900 { 01901 unsigned long off = (unsigned long) ref & 0x7; 01902 unsigned long off_plus_1 = off + 1; 01903 int stride_8 = stride + 8; 01904 01905 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT); 01906 01907 ref = vis_alignaddr(ref); 01908 01909 vis_ld64(ref[0], TMP0); 01910 vis_fzero(ZERO); 01911 01912 vis_ld64_2(ref, 8, TMP2); 01913 01914 vis_ld64(constants6[0], CONST_6); 01915 01916 vis_ld64(constants256_1024[0], CONST_256); 01917 vis_faligndata(TMP0, TMP2, REF_S0); 01918 01919 if (off != 0x7) { 01920 vis_alignaddr_g0((void *)off_plus_1); 01921 vis_faligndata(TMP0, TMP2, REF_S2); 01922 } else { 01923 vis_src1(TMP2, REF_S2); 01924 } 01925 01926 height >>= 1; 01927 do { /* 31 cycles */ 01928 vis_ld64_2(ref, stride, TMP0); 01929 vis_mul8x16au(REF_S0, CONST_256, TMP8); 01930 vis_pmerge(ZERO, REF_S0_1, TMP10); 01931 01932 vis_ld64_2(ref, stride_8, TMP2); 01933 ref += stride; 01934 vis_mul8x16au(REF_S2, CONST_256, TMP12); 01935 vis_pmerge(ZERO, REF_S2_1, TMP14); 01936 01937 vis_alignaddr_g0((void *)off); 01938 01939 vis_ld64_2(ref, stride, TMP4); 01940 vis_faligndata(TMP0, TMP2, REF_S4); 01941 01942 vis_ld64_2(ref, stride_8, TMP6); 01943 ref += stride; 01944 01945 vis_ld64(dest[0], DST_0); 01946 vis_faligndata(TMP4, TMP6, REF_S0); 01947 01948 vis_ld64_2(dest, stride, DST_2); 01949 01950 if (off != 0x7) { 01951 vis_alignaddr_g0((void *)off_plus_1); 01952 vis_faligndata(TMP0, TMP2, REF_S6); 01953 vis_faligndata(TMP4, TMP6, REF_S2); 01954 } else { 01955 vis_src1(TMP2, REF_S6); 01956 vis_src1(TMP6, REF_S2); 01957 } 01958 01959 vis_mul8x16al(DST_0, CONST_1024, TMP30); 01960 vis_pmerge(ZERO, REF_S4, TMP22); 01961 01962 vis_mul8x16al(DST_1, CONST_1024, TMP32); 01963 vis_pmerge(ZERO, REF_S4_1, TMP24); 01964 01965 vis_mul8x16au(REF_S6, CONST_256, TMP26); 01966 vis_pmerge(ZERO, REF_S6_1, TMP28); 01967 01968 vis_mul8x16au(REF_S0, CONST_256, REF_S4); 01969 vis_padd16(TMP22, CONST_6, TMP22); 01970 01971 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6); 01972 vis_padd16(TMP24, CONST_6, TMP24); 01973 01974 vis_mul8x16al(DST_2, CONST_1024, REF_0); 01975 vis_padd16(TMP22, TMP26, TMP22); 01976 01977 vis_mul8x16al(DST_3, CONST_1024, REF_2); 01978 vis_padd16(TMP24, TMP28, TMP24); 01979 01980 vis_mul8x16au(REF_S2, CONST_256, TMP26); 01981 vis_padd16(TMP8, TMP22, TMP8); 01982 01983 vis_mul8x16au(REF_S2_1, CONST_256, TMP28); 01984 vis_padd16(TMP10, TMP24, TMP10); 01985 01986 vis_padd16(TMP8, TMP12, TMP8); 01987 01988 vis_padd16(TMP10, TMP14, TMP10); 01989 01990 vis_padd16(TMP8, TMP30, TMP8); 01991 01992 vis_padd16(TMP10, TMP32, TMP10); 01993 vis_pack16(TMP8, DST_0); 01994 01995 vis_pack16(TMP10, DST_1); 01996 vis_st64(DST_0, dest[0]); 01997 dest += stride; 01998 01999 vis_padd16(REF_S4, TMP22, TMP12); 02000 02001 vis_padd16(REF_S6, TMP24, TMP14); 02002 02003 vis_padd16(TMP12, TMP26, TMP12); 02004 02005 vis_padd16(TMP14, TMP28, TMP14); 02006 02007 vis_padd16(TMP12, REF_0, TMP12); 02008 02009 vis_padd16(TMP14, REF_2, TMP14); 02010 vis_pack16(TMP12, DST_2); 02011 02012 vis_pack16(TMP14, DST_3); 02013 vis_st64(DST_2, dest[0]); 02014 dest += stride; 02015 } while (--height); 02016 } 02017 02018 /* End of rounding code */ 02019 02020 /* Start of no rounding code */ 02021 /* The trick used in some of this file is the formula from the MMX 02022 * motion comp code, which is: 02023 * 02024 * (x+y)>>1 == (x&y)+((x^y)>>1) 02025 * 02026 * This allows us to average 8 bytes at a time in a 64-bit FPU reg. 02027 * We avoid overflows by masking before we do the shift, and we 02028 * implement the shift by multiplying by 1/2 using mul8x16. So in 02029 * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask 02030 * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and 02031 * the value 0x80808080 is in f8): 02032 * 02033 * fxor f0, f2, f10 02034 * fand f10, f4, f10 02035 * fmul8x16 f8, f10, f10 02036 * fand f10, f6, f10 02037 * fand f0, f2, f12 02038 * fpadd16 f12, f10, f10 02039 */ 02040 02041 static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref, 02042 const int stride, int height) 02043 { 02044 ref = vis_alignaddr(ref); 02045 do { /* 5 cycles */ 02046 vis_ld64(ref[0], TMP0); 02047 02048 vis_ld64_2(ref, 8, TMP2); 02049 02050 vis_ld64_2(ref, 16, TMP4); 02051 ref += stride; 02052 02053 vis_faligndata(TMP0, TMP2, REF_0); 02054 vis_st64(REF_0, dest[0]); 02055 02056 vis_faligndata(TMP2, TMP4, REF_2); 02057 vis_st64_2(REF_2, dest, 8); 02058 dest += stride; 02059 } while (--height); 02060 } 02061 02062 static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref, 02063 const int stride, int height) 02064 { 02065 ref = vis_alignaddr(ref); 02066 do { /* 4 cycles */ 02067 vis_ld64(ref[0], TMP0); 02068 02069 vis_ld64(ref[8], TMP2); 02070 ref += stride; 02071 02072 /* stall */ 02073 02074 vis_faligndata(TMP0, TMP2, REF_0); 02075 vis_st64(REF_0, dest[0]); 02076 dest += stride; 02077 } while (--height); 02078 } 02079 02080 02081 static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref, 02082 const int stride, int height) 02083 { 02084 int stride_8 = stride + 8; 02085 02086 ref = vis_alignaddr(ref); 02087 02088 vis_ld64(ref[0], TMP0); 02089 02090 vis_ld64(ref[8], TMP2); 02091 02092 vis_ld64(ref[16], TMP4); 02093 02094 vis_ld64(dest[0], DST_0); 02095 02096 vis_ld64(dest[8], DST_2); 02097 02098 vis_ld64(constants_fe[0], MASK_fe); 02099 vis_faligndata(TMP0, TMP2, REF_0); 02100 02101 vis_ld64(constants_7f[0], MASK_7f); 02102 vis_faligndata(TMP2, TMP4, REF_2); 02103 02104 vis_ld64(constants128[0], CONST_128); 02105 02106 ref += stride; 02107 height = (height >> 1) - 1; 02108 02109 do { /* 24 cycles */ 02110 vis_ld64(ref[0], TMP0); 02111 vis_xor(DST_0, REF_0, TMP6); 02112 02113 vis_ld64_2(ref, 8, TMP2); 02114 vis_and(TMP6, MASK_fe, TMP6); 02115 02116 vis_ld64_2(ref, 16, TMP4); 02117 ref += stride; 02118 vis_mul8x16(CONST_128, TMP6, TMP6); 02119 vis_xor(DST_2, REF_2, TMP8); 02120 02121 vis_and(TMP8, MASK_fe, TMP8); 02122 02123 vis_and(DST_0, REF_0, TMP10); 02124 vis_ld64_2(dest, stride, DST_0); 02125 vis_mul8x16(CONST_128, TMP8, TMP8); 02126 02127 vis_and(DST_2, REF_2, TMP12); 02128 vis_ld64_2(dest, stride_8, DST_2); 02129 02130 vis_ld64(ref[0], TMP14); 02131 vis_and(TMP6, MASK_7f, TMP6); 02132 02133 vis_and(TMP8, MASK_7f, TMP8); 02134 02135 vis_padd16(TMP10, TMP6, TMP6); 02136 vis_st64(TMP6, dest[0]); 02137 02138 vis_padd16(TMP12, TMP8, TMP8); 02139 vis_st64_2(TMP8, dest, 8); 02140 02141 dest += stride; 02142 vis_ld64_2(ref, 8, TMP16); 02143 vis_faligndata(TMP0, TMP2, REF_0); 02144 02145 vis_ld64_2(ref, 16, TMP18); 02146 vis_faligndata(TMP2, TMP4, REF_2); 02147 ref += stride; 02148 02149 vis_xor(DST_0, REF_0, TMP20); 02150 02151 vis_and(TMP20, MASK_fe, TMP20); 02152 02153 vis_xor(DST_2, REF_2, TMP22); 02154 vis_mul8x16(CONST_128, TMP20, TMP20); 02155 02156 vis_and(TMP22, MASK_fe, TMP22); 02157 02158 vis_and(DST_0, REF_0, TMP24); 02159 vis_mul8x16(CONST_128, TMP22, TMP22); 02160 02161 vis_and(DST_2, REF_2, TMP26); 02162 02163 vis_ld64_2(dest, stride, DST_0); 02164 vis_faligndata(TMP14, TMP16, REF_0); 02165 02166 vis_ld64_2(dest, stride_8, DST_2); 02167 vis_faligndata(TMP16, TMP18, REF_2); 02168 02169 vis_and(TMP20, MASK_7f, TMP20); 02170 02171 vis_and(TMP22, MASK_7f, TMP22); 02172 02173 vis_padd16(TMP24, TMP20, TMP20); 02174 vis_st64(TMP20, dest[0]); 02175 02176 vis_padd16(TMP26, TMP22, TMP22); 02177 vis_st64_2(TMP22, dest, 8); 02178 dest += stride; 02179 } while (--height); 02180 02181 vis_ld64(ref[0], TMP0); 02182 vis_xor(DST_0, REF_0, TMP6); 02183 02184 vis_ld64_2(ref, 8, TMP2); 02185 vis_and(TMP6, MASK_fe, TMP6); 02186 02187 vis_ld64_2(ref, 16, TMP4); 02188 vis_mul8x16(CONST_128, TMP6, TMP6); 02189 vis_xor(DST_2, REF_2, TMP8); 02190 02191 vis_and(TMP8, MASK_fe, TMP8); 02192 02193 vis_and(DST_0, REF_0, TMP10); 02194 vis_ld64_2(dest, stride, DST_0); 02195 vis_mul8x16(CONST_128, TMP8, TMP8); 02196 02197 vis_and(DST_2, REF_2, TMP12); 02198 vis_ld64_2(dest, stride_8, DST_2); 02199 02200 vis_ld64(ref[0], TMP14); 02201 vis_and(TMP6, MASK_7f, TMP6); 02202 02203 vis_and(TMP8, MASK_7f, TMP8); 02204 02205 vis_padd16(TMP10, TMP6, TMP6); 02206 vis_st64(TMP6, dest[0]); 02207 02208 vis_padd16(TMP12, TMP8, TMP8); 02209 vis_st64_2(TMP8, dest, 8); 02210 02211 dest += stride; 02212 vis_faligndata(TMP0, TMP2, REF_0); 02213 02214 vis_faligndata(TMP2, TMP4, REF_2); 02215 02216 vis_xor(DST_0, REF_0, TMP20); 02217 02218 vis_and(TMP20, MASK_fe, TMP20); 02219 02220 vis_xor(DST_2, REF_2, TMP22); 02221 vis_mul8x16(CONST_128, TMP20, TMP20); 02222 02223 vis_and(TMP22, MASK_fe, TMP22); 02224 02225 vis_and(DST_0, REF_0, TMP24); 02226 vis_mul8x16(CONST_128, TMP22, TMP22); 02227 02228 vis_and(DST_2, REF_2, TMP26); 02229 02230 vis_and(TMP20, MASK_7f, TMP20); 02231 02232 vis_and(TMP22, MASK_7f, TMP22); 02233 02234 vis_padd16(TMP24, TMP20, TMP20); 02235 vis_st64(TMP20, dest[0]); 02236 02237 vis_padd16(TMP26, TMP22, TMP22); 02238 vis_st64_2(TMP22, dest, 8); 02239 } 02240 02241 static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref, 02242 const int stride, int height) 02243 { 02244 ref = vis_alignaddr(ref); 02245 02246 vis_ld64(ref[0], TMP0); 02247 02248 vis_ld64(ref[8], TMP2); 02249 02250 vis_ld64(dest[0], DST_0); 02251 02252 vis_ld64(constants_fe[0], MASK_fe); 02253 02254 vis_ld64(constants_7f[0], MASK_7f); 02255 vis_faligndata(TMP0, TMP2, REF_0); 02256 02257 vis_ld64(constants128[0], CONST_128); 02258 02259 ref += stride; 02260 height = (height >> 1) - 1; 02261 02262 do { /* 12 cycles */ 02263 vis_ld64(ref[0], TMP0); 02264 vis_xor(DST_0, REF_0, TMP4); 02265 02266 vis_ld64(ref[8], TMP2); 02267 vis_and(TMP4, MASK_fe, TMP4); 02268 02269 vis_and(DST_0, REF_0, TMP6); 02270 vis_ld64_2(dest, stride, DST_0); 02271 ref += stride; 02272 vis_mul8x16(CONST_128, TMP4, TMP4); 02273 02274 vis_ld64(ref[0], TMP12); 02275 vis_faligndata(TMP0, TMP2, REF_0); 02276 02277 vis_ld64(ref[8], TMP2); 02278 vis_xor(DST_0, REF_0, TMP0); 02279 ref += stride; 02280 02281 vis_and(TMP0, MASK_fe, TMP0); 02282 02283 vis_and(TMP4, MASK_7f, TMP4); 02284 02285 vis_padd16(TMP6, TMP4, TMP4); 02286 vis_st64(TMP4, dest[0]); 02287 dest += stride; 02288 vis_mul8x16(CONST_128, TMP0, TMP0); 02289 02290 vis_and(DST_0, REF_0, TMP6); 02291 vis_ld64_2(dest, stride, DST_0); 02292 02293 vis_faligndata(TMP12, TMP2, REF_0); 02294 02295 vis_and(TMP0, MASK_7f, TMP0); 02296 02297 vis_padd16(TMP6, TMP0, TMP4); 02298 vis_st64(TMP4, dest[0]); 02299 dest += stride; 02300 } while (--height); 02301 02302 vis_ld64(ref[0], TMP0); 02303 vis_xor(DST_0, REF_0, TMP4); 02304 02305 vis_ld64(ref[8], TMP2); 02306 vis_and(TMP4, MASK_fe, TMP4); 02307 02308 vis_and(DST_0, REF_0, TMP6); 02309 vis_ld64_2(dest, stride, DST_0); 02310 vis_mul8x16(CONST_128, TMP4, TMP4); 02311 02312 vis_faligndata(TMP0, TMP2, REF_0); 02313 02314 vis_xor(DST_0, REF_0, TMP0); 02315 02316 vis_and(TMP0, MASK_fe, TMP0); 02317 02318 vis_and(TMP4, MASK_7f, TMP4); 02319 02320 vis_padd16(TMP6, TMP4, TMP4); 02321 vis_st64(TMP4, dest[0]); 02322 dest += stride; 02323 vis_mul8x16(CONST_128, TMP0, TMP0); 02324 02325 vis_and(DST_0, REF_0, TMP6); 02326 02327 vis_and(TMP0, MASK_7f, TMP0); 02328 02329 vis_padd16(TMP6, TMP0, TMP4); 02330 vis_st64(TMP4, dest[0]); 02331 } 02332 02333 static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref, 02334 const int stride, int height) 02335 { 02336 unsigned long off = (unsigned long) ref & 0x7; 02337 unsigned long off_plus_1 = off + 1; 02338 02339 ref = vis_alignaddr(ref); 02340 02341 vis_ld64(ref[0], TMP0); 02342 02343 vis_ld64_2(ref, 8, TMP2); 02344 02345 vis_ld64_2(ref, 16, TMP4); 02346 02347 vis_ld64(constants_fe[0], MASK_fe); 02348 02349 vis_ld64(constants_7f[0], MASK_7f); 02350 vis_faligndata(TMP0, TMP2, REF_0); 02351 02352 vis_ld64(constants128[0], CONST_128); 02353 vis_faligndata(TMP2, TMP4, REF_4); 02354 02355 if (off != 0x7) { 02356 vis_alignaddr_g0((void *)off_plus_1); 02357 vis_faligndata(TMP0, TMP2, REF_2); 02358 vis_faligndata(TMP2, TMP4, REF_6); 02359 } else { 02360 vis_src1(TMP2, REF_2); 02361 vis_src1(TMP4, REF_6); 02362 } 02363 02364 ref += stride; 02365 height = (height >> 1) - 1; 02366 02367 do { /* 34 cycles */ 02368 vis_ld64(ref[0], TMP0); 02369 vis_xor(REF_0, REF_2, TMP6); 02370 02371 vis_ld64_2(ref, 8, TMP2); 02372 vis_xor(REF_4, REF_6, TMP8); 02373 02374 vis_ld64_2(ref, 16, TMP4); 02375 vis_and(TMP6, MASK_fe, TMP6); 02376 ref += stride; 02377 02378 vis_ld64(ref[0], TMP14); 02379 vis_mul8x16(CONST_128, TMP6, TMP6); 02380 vis_and(TMP8, MASK_fe, TMP8); 02381 02382 vis_ld64_2(ref, 8, TMP16); 02383 vis_mul8x16(CONST_128, TMP8, TMP8); 02384 vis_and(REF_0, REF_2, TMP10); 02385 02386 vis_ld64_2(ref, 16, TMP18); 02387 ref += stride; 02388 vis_and(REF_4, REF_6, TMP12); 02389 02390 vis_alignaddr_g0((void *)off); 02391 02392 vis_faligndata(TMP0, TMP2, REF_0); 02393 02394 vis_faligndata(TMP2, TMP4, REF_4); 02395 02396 if (off != 0x7) { 02397 vis_alignaddr_g0((void *)off_plus_1); 02398 vis_faligndata(TMP0, TMP2, REF_2); 02399 vis_faligndata(TMP2, TMP4, REF_6); 02400 } else { 02401 vis_src1(TMP2, REF_2); 02402 vis_src1(TMP4, REF_6); 02403 } 02404 02405 vis_and(TMP6, MASK_7f, TMP6); 02406 02407 vis_and(TMP8, MASK_7f, TMP8); 02408 02409 vis_padd16(TMP10, TMP6, TMP6); 02410 vis_st64(TMP6, dest[0]); 02411 02412 vis_padd16(TMP12, TMP8, TMP8); 02413 vis_st64_2(TMP8, dest, 8); 02414 dest += stride; 02415 02416 vis_xor(REF_0, REF_2, TMP6); 02417 02418 vis_xor(REF_4, REF_6, TMP8); 02419 02420 vis_and(TMP6, MASK_fe, TMP6); 02421 02422 vis_mul8x16(CONST_128, TMP6, TMP6); 02423 vis_and(TMP8, MASK_fe, TMP8); 02424 02425 vis_mul8x16(CONST_128, TMP8, TMP8); 02426 vis_and(REF_0, REF_2, TMP10); 02427 02428 vis_and(REF_4, REF_6, TMP12); 02429 02430 vis_alignaddr_g0((void *)off); 02431 02432 vis_faligndata(TMP14, TMP16, REF_0); 02433 02434 vis_faligndata(TMP16, TMP18, REF_4); 02435 02436 if (off != 0x7) { 02437 vis_alignaddr_g0((void *)off_plus_1); 02438 vis_faligndata(TMP14, TMP16, REF_2); 02439 vis_faligndata(TMP16, TMP18, REF_6); 02440 } else { 02441 vis_src1(TMP16, REF_2); 02442 vis_src1(TMP18, REF_6); 02443 } 02444 02445 vis_and(TMP6, MASK_7f, TMP6); 02446 02447 vis_and(TMP8, MASK_7f, TMP8); 02448 02449 vis_padd16(TMP10, TMP6, TMP6); 02450 vis_st64(TMP6, dest[0]); 02451 02452 vis_padd16(TMP12, TMP8, TMP8); 02453 vis_st64_2(TMP8, dest, 8); 02454 dest += stride; 02455 } while (--height); 02456 02457 vis_ld64(ref[0], TMP0); 02458 vis_xor(REF_0, REF_2, TMP6); 02459 02460 vis_ld64_2(ref, 8, TMP2); 02461 vis_xor(REF_4, REF_6, TMP8); 02462 02463 vis_ld64_2(ref, 16, TMP4); 02464 vis_and(TMP6, MASK_fe, TMP6); 02465 02466 vis_mul8x16(CONST_128, TMP6, TMP6); 02467 vis_and(TMP8, MASK_fe, TMP8); 02468 02469 vis_mul8x16(CONST_128, TMP8, TMP8); 02470 vis_and(REF_0, REF_2, TMP10); 02471 02472 vis_and(REF_4, REF_6, TMP12); 02473 02474 vis_alignaddr_g0((void *)off); 02475 02476 vis_faligndata(TMP0, TMP2, REF_0); 02477 02478 vis_faligndata(TMP2, TMP4, REF_4); 02479 02480 if (off != 0x7) { 02481 vis_alignaddr_g0((void *)off_plus_1); 02482 vis_faligndata(TMP0, TMP2, REF_2); 02483 vis_faligndata(TMP2, TMP4, REF_6); 02484 } else { 02485 vis_src1(TMP2, REF_2); 02486 vis_src1(TMP4, REF_6); 02487 } 02488 02489 vis_and(TMP6, MASK_7f, TMP6); 02490 02491 vis_and(TMP8, MASK_7f, TMP8); 02492 02493 vis_padd16(TMP10, TMP6, TMP6); 02494 vis_st64(TMP6, dest[0]); 02495 02496 vis_padd16(TMP12, TMP8, TMP8); 02497 vis_st64_2(TMP8, dest, 8); 02498 dest += stride; 02499 02500 vis_xor(REF_0, REF_2, TMP6); 02501 02502 vis_xor(REF_4, REF_6, TMP8); 02503 02504 vis_and(TMP6, MASK_fe, TMP6); 02505 02506 vis_mul8x16(CONST_128, TMP6, TMP6); 02507 vis_and(TMP8, MASK_fe, TMP8); 02508 02509 vis_mul8x16(CONST_128, TMP8, TMP8); 02510 vis_and(REF_0, REF_2, TMP10); 02511 02512 vis_and(REF_4, REF_6, TMP12); 02513 02514 vis_and(TMP6, MASK_7f, TMP6); 02515 02516 vis_and(TMP8, MASK_7f, TMP8); 02517 02518 vis_padd16(TMP10, TMP6, TMP6); 02519 vis_st64(TMP6, dest[0]); 02520 02521 vis_padd16(TMP12, TMP8, TMP8); 02522 vis_st64_2(TMP8, dest, 8); 02523 } 02524 02525 static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref, 02526 const int stride, int height) 02527 { 02528 unsigned long off = (unsigned long) ref & 0x7; 02529 unsigned long off_plus_1 = off + 1; 02530 02531 ref = vis_alignaddr(ref); 02532 02533 vis_ld64(ref[0], TMP0); 02534 02535 vis_ld64(ref[8], TMP2); 02536 02537 vis_ld64(constants_fe[0], MASK_fe); 02538 02539 vis_ld64(constants_7f[0], MASK_7f); 02540 02541 vis_ld64(constants128[0], CONST_128); 02542 vis_faligndata(TMP0, TMP2, REF_0); 02543 02544 if (off != 0x7) { 02545 vis_alignaddr_g0((void *)off_plus_1); 02546 vis_faligndata(TMP0, TMP2, REF_2); 02547 } else { 02548 vis_src1(TMP2, REF_2); 02549 } 02550 02551 ref += stride; 02552 height = (height >> 1) - 1; 02553 02554 do { /* 20 cycles */ 02555 vis_ld64(ref[0], TMP0); 02556 vis_xor(REF_0, REF_2, TMP4); 02557 02558 vis_ld64_2(ref, 8, TMP2); 02559 vis_and(TMP4, MASK_fe, TMP4); 02560 ref += stride; 02561 02562 vis_ld64(ref[0], TMP8); 02563 vis_and(REF_0, REF_2, TMP6); 02564 vis_mul8x16(CONST_128, TMP4, TMP4); 02565 02566 vis_alignaddr_g0((void *)off); 02567 02568 vis_ld64_2(ref, 8, TMP10); 02569 ref += stride; 02570 vis_faligndata(TMP0, TMP2, REF_0); 02571 02572 if (off != 0x7) { 02573 vis_alignaddr_g0((void *)off_plus_1); 02574 vis_faligndata(TMP0, TMP2, REF_2); 02575 } else { 02576 vis_src1(TMP2, REF_2); 02577 } 02578 02579 vis_and(TMP4, MASK_7f, TMP4); 02580 02581 vis_padd16(TMP6, TMP4, DST_0); 02582 vis_st64(DST_0, dest[0]); 02583 dest += stride; 02584 02585 vis_xor(REF_0, REF_2, TMP12); 02586 02587 vis_and(TMP12, MASK_fe, TMP12); 02588 02589 vis_and(REF_0, REF_2, TMP14); 02590 vis_mul8x16(CONST_128, TMP12, TMP12); 02591 02592 vis_alignaddr_g0((void *)off); 02593 vis_faligndata(TMP8, TMP10, REF_0); 02594 if (off != 0x7) { 02595 vis_alignaddr_g0((void *)off_plus_1); 02596 vis_faligndata(TMP8, TMP10, REF_2); 02597 } else { 02598 vis_src1(TMP10, REF_2); 02599 } 02600 02601 vis_and(TMP12, MASK_7f, TMP12); 02602 02603 vis_padd16(TMP14, TMP12, DST_0); 02604 vis_st64(DST_0, dest[0]); 02605 dest += stride; 02606 } while (--height); 02607 02608 vis_ld64(ref[0], TMP0); 02609 vis_xor(REF_0, REF_2, TMP4); 02610 02611 vis_ld64_2(ref, 8, TMP2); 02612 vis_and(TMP4, MASK_fe, TMP4); 02613 02614 vis_and(REF_0, REF_2, TMP6); 02615 vis_mul8x16(CONST_128, TMP4, TMP4); 02616 02617 vis_alignaddr_g0((void *)off); 02618 02619 vis_faligndata(TMP0, TMP2, REF_0); 02620 02621 if (off != 0x7) { 02622 vis_alignaddr_g0((void *)off_plus_1); 02623 vis_faligndata(TMP0, TMP2, REF_2); 02624 } else { 02625 vis_src1(TMP2, REF_2); 02626 } 02627 02628 vis_and(TMP4, MASK_7f, TMP4); 02629 02630 vis_padd16(TMP6, TMP4, DST_0); 02631 vis_st64(DST_0, dest[0]); 02632 dest += stride; 02633 02634 vis_xor(REF_0, REF_2, TMP12); 02635 02636 vis_and(TMP12, MASK_fe, TMP12); 02637 02638 vis_and(REF_0, REF_2, TMP14); 02639 vis_mul8x16(CONST_128, TMP12, TMP12); 02640 02641 vis_and(TMP12, MASK_7f, TMP12); 02642 02643 vis_padd16(TMP14, TMP12, DST_0); 02644 vis_st64(DST_0, dest[0]); 02645 dest += stride; 02646 } 02647 02648 static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref, 02649 const int stride, int height) 02650 { 02651 unsigned long off = (unsigned long) ref & 0x7; 02652 unsigned long off_plus_1 = off + 1; 02653 02654 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 02655 02656 vis_ld64(constants3[0], CONST_3); 02657 vis_fzero(ZERO); 02658 vis_ld64(constants256_512[0], CONST_256); 02659 02660 ref = vis_alignaddr(ref); 02661 do { /* 26 cycles */ 02662 vis_ld64(ref[0], TMP0); 02663 02664 vis_ld64(ref[8], TMP2); 02665 02666 vis_alignaddr_g0((void *)off); 02667 02668 vis_ld64(ref[16], TMP4); 02669 02670 vis_ld64(dest[0], DST_0); 02671 vis_faligndata(TMP0, TMP2, REF_0); 02672 02673 vis_ld64(dest[8], DST_2); 02674 vis_faligndata(TMP2, TMP4, REF_4); 02675 02676 if (off != 0x7) { 02677 vis_alignaddr_g0((void *)off_plus_1); 02678 vis_faligndata(TMP0, TMP2, REF_2); 02679 vis_faligndata(TMP2, TMP4, REF_6); 02680 } else { 02681 vis_src1(TMP2, REF_2); 02682 vis_src1(TMP4, REF_6); 02683 } 02684 02685 vis_mul8x16au(REF_0, CONST_256, TMP0); 02686 02687 vis_pmerge(ZERO, REF_2, TMP4); 02688 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 02689 02690 vis_pmerge(ZERO, REF_2_1, TMP6); 02691 02692 vis_padd16(TMP0, TMP4, TMP0); 02693 02694 vis_mul8x16al(DST_0, CONST_512, TMP4); 02695 vis_padd16(TMP2, TMP6, TMP2); 02696 02697 vis_mul8x16al(DST_1, CONST_512, TMP6); 02698 02699 vis_mul8x16au(REF_6, CONST_256, TMP12); 02700 02701 vis_padd16(TMP0, TMP4, TMP0); 02702 vis_mul8x16au(REF_6_1, CONST_256, TMP14); 02703 02704 vis_padd16(TMP2, TMP6, TMP2); 02705 vis_mul8x16au(REF_4, CONST_256, TMP16); 02706 02707 vis_padd16(TMP0, CONST_3, TMP8); 02708 vis_mul8x16au(REF_4_1, CONST_256, TMP18); 02709 02710 vis_padd16(TMP2, CONST_3, TMP10); 02711 vis_pack16(TMP8, DST_0); 02712 02713 vis_pack16(TMP10, DST_1); 02714 vis_padd16(TMP16, TMP12, TMP0); 02715 02716 vis_st64(DST_0, dest[0]); 02717 vis_mul8x16al(DST_2, CONST_512, TMP4); 02718 vis_padd16(TMP18, TMP14, TMP2); 02719 02720 vis_mul8x16al(DST_3, CONST_512, TMP6); 02721 vis_padd16(TMP0, CONST_3, TMP0); 02722 02723 vis_padd16(TMP2, CONST_3, TMP2); 02724 02725 vis_padd16(TMP0, TMP4, TMP0); 02726 02727 vis_padd16(TMP2, TMP6, TMP2); 02728 vis_pack16(TMP0, DST_2); 02729 02730 vis_pack16(TMP2, DST_3); 02731 vis_st64(DST_2, dest[8]); 02732 02733 ref += stride; 02734 dest += stride; 02735 } while (--height); 02736 } 02737 02738 static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref, 02739 const int stride, int height) 02740 { 02741 unsigned long off = (unsigned long) ref & 0x7; 02742 unsigned long off_plus_1 = off + 1; 02743 int stride_times_2 = stride << 1; 02744 02745 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 02746 02747 vis_ld64(constants3[0], CONST_3); 02748 vis_fzero(ZERO); 02749 vis_ld64(constants256_512[0], CONST_256); 02750 02751 ref = vis_alignaddr(ref); 02752 height >>= 2; 02753 do { /* 47 cycles */ 02754 vis_ld64(ref[0], TMP0); 02755 02756 vis_ld64_2(ref, 8, TMP2); 02757 ref += stride; 02758 02759 vis_alignaddr_g0((void *)off); 02760 02761 vis_ld64(ref[0], TMP4); 02762 vis_faligndata(TMP0, TMP2, REF_0); 02763 02764 vis_ld64_2(ref, 8, TMP6); 02765 ref += stride; 02766 02767 vis_ld64(ref[0], TMP8); 02768 02769 vis_ld64_2(ref, 8, TMP10); 02770 ref += stride; 02771 vis_faligndata(TMP4, TMP6, REF_4); 02772 02773 vis_ld64(ref[0], TMP12); 02774 02775 vis_ld64_2(ref, 8, TMP14); 02776 ref += stride; 02777 vis_faligndata(TMP8, TMP10, REF_S0); 02778 02779 vis_faligndata(TMP12, TMP14, REF_S4); 02780 02781 if (off != 0x7) { 02782 vis_alignaddr_g0((void *)off_plus_1); 02783 02784 vis_ld64(dest[0], DST_0); 02785 vis_faligndata(TMP0, TMP2, REF_2); 02786 02787 vis_ld64_2(dest, stride, DST_2); 02788 vis_faligndata(TMP4, TMP6, REF_6); 02789 02790 vis_faligndata(TMP8, TMP10, REF_S2); 02791 02792 vis_faligndata(TMP12, TMP14, REF_S6); 02793 } else { 02794 vis_ld64(dest[0], DST_0); 02795 vis_src1(TMP2, REF_2); 02796 02797 vis_ld64_2(dest, stride, DST_2); 02798 vis_src1(TMP6, REF_6); 02799 02800 vis_src1(TMP10, REF_S2); 02801 02802 vis_src1(TMP14, REF_S6); 02803 } 02804 02805 vis_pmerge(ZERO, REF_0, TMP0); 02806 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 02807 02808 vis_pmerge(ZERO, REF_2, TMP4); 02809 vis_mul8x16au(REF_2_1, CONST_256, TMP6); 02810 02811 vis_padd16(TMP0, CONST_3, TMP0); 02812 vis_mul8x16al(DST_0, CONST_512, TMP16); 02813 02814 vis_padd16(TMP2, CONST_3, TMP2); 02815 vis_mul8x16al(DST_1, CONST_512, TMP18); 02816 02817 vis_padd16(TMP0, TMP4, TMP0); 02818 vis_mul8x16au(REF_4, CONST_256, TMP8); 02819 02820 vis_padd16(TMP2, TMP6, TMP2); 02821 vis_mul8x16au(REF_4_1, CONST_256, TMP10); 02822 02823 vis_padd16(TMP0, TMP16, TMP0); 02824 vis_mul8x16au(REF_6, CONST_256, TMP12); 02825 02826 vis_padd16(TMP2, TMP18, TMP2); 02827 vis_mul8x16au(REF_6_1, CONST_256, TMP14); 02828 02829 vis_padd16(TMP8, CONST_3, TMP8); 02830 vis_mul8x16al(DST_2, CONST_512, TMP16); 02831 02832 vis_padd16(TMP8, TMP12, TMP8); 02833 vis_mul8x16al(DST_3, CONST_512, TMP18); 02834 02835 vis_padd16(TMP10, TMP14, TMP10); 02836 vis_pack16(TMP0, DST_0); 02837 02838 vis_pack16(TMP2, DST_1); 02839 vis_st64(DST_0, dest[0]); 02840 dest += stride; 02841 vis_padd16(TMP10, CONST_3, TMP10); 02842 02843 vis_ld64_2(dest, stride, DST_0); 02844 vis_padd16(TMP8, TMP16, TMP8); 02845 02846 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/); 02847 vis_padd16(TMP10, TMP18, TMP10); 02848 vis_pack16(TMP8, DST_2); 02849 02850 vis_pack16(TMP10, DST_3); 02851 vis_st64(DST_2, dest[0]); 02852 dest += stride; 02853 02854 vis_mul8x16au(REF_S0_1, CONST_256, TMP2); 02855 vis_pmerge(ZERO, REF_S0, TMP0); 02856 02857 vis_pmerge(ZERO, REF_S2, TMP24); 02858 vis_mul8x16au(REF_S2_1, CONST_256, TMP6); 02859 02860 vis_padd16(TMP0, CONST_3, TMP0); 02861 vis_mul8x16au(REF_S4, CONST_256, TMP8); 02862 02863 vis_padd16(TMP2, CONST_3, TMP2); 02864 vis_mul8x16au(REF_S4_1, CONST_256, TMP10); 02865 02866 vis_padd16(TMP0, TMP24, TMP0); 02867 vis_mul8x16au(REF_S6, CONST_256, TMP12); 02868 02869 vis_padd16(TMP2, TMP6, TMP2); 02870 vis_mul8x16au(REF_S6_1, CONST_256, TMP14); 02871 02872 vis_padd16(TMP8, CONST_3, TMP8); 02873 vis_mul8x16al(DST_0, CONST_512, TMP16); 02874 02875 vis_padd16(TMP10, CONST_3, TMP10); 02876 vis_mul8x16al(DST_1, CONST_512, TMP18); 02877 02878 vis_padd16(TMP8, TMP12, TMP8); 02879 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20); 02880 02881 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22); 02882 vis_padd16(TMP0, TMP16, TMP0); 02883 02884 vis_padd16(TMP2, TMP18, TMP2); 02885 vis_pack16(TMP0, DST_0); 02886 02887 vis_padd16(TMP10, TMP14, TMP10); 02888 vis_pack16(TMP2, DST_1); 02889 vis_st64(DST_0, dest[0]); 02890 dest += stride; 02891 02892 vis_padd16(TMP8, TMP20, TMP8); 02893 02894 vis_padd16(TMP10, TMP22, TMP10); 02895 vis_pack16(TMP8, DST_2); 02896 02897 vis_pack16(TMP10, DST_3); 02898 vis_st64(DST_2, dest[0]); 02899 dest += stride; 02900 } while (--height); 02901 } 02902 02903 static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref, 02904 const int stride, int height) 02905 { 02906 ref = vis_alignaddr(ref); 02907 vis_ld64(ref[0], TMP0); 02908 02909 vis_ld64_2(ref, 8, TMP2); 02910 02911 vis_ld64_2(ref, 16, TMP4); 02912 ref += stride; 02913 02914 vis_ld64(ref[0], TMP6); 02915 vis_faligndata(TMP0, TMP2, REF_0); 02916 02917 vis_ld64_2(ref, 8, TMP8); 02918 vis_faligndata(TMP2, TMP4, REF_4); 02919 02920 vis_ld64_2(ref, 16, TMP10); 02921 ref += stride; 02922 02923 vis_ld64(constants_fe[0], MASK_fe); 02924 vis_faligndata(TMP6, TMP8, REF_2); 02925 02926 vis_ld64(constants_7f[0], MASK_7f); 02927 vis_faligndata(TMP8, TMP10, REF_6); 02928 02929 vis_ld64(constants128[0], CONST_128); 02930 height = (height >> 1) - 1; 02931 do { /* 24 cycles */ 02932 vis_ld64(ref[0], TMP0); 02933 vis_xor(REF_0, REF_2, TMP12); 02934 02935 vis_ld64_2(ref, 8, TMP2); 02936 vis_xor(REF_4, REF_6, TMP16); 02937 02938 vis_ld64_2(ref, 16, TMP4); 02939 ref += stride; 02940 vis_and(REF_0, REF_2, TMP14); 02941 02942 vis_ld64(ref[0], TMP6); 02943 vis_and(REF_4, REF_6, TMP18); 02944 02945 vis_ld64_2(ref, 8, TMP8); 02946 vis_faligndata(TMP0, TMP2, REF_0); 02947 02948 vis_ld64_2(ref, 16, TMP10); 02949 ref += stride; 02950 vis_faligndata(TMP2, TMP4, REF_4); 02951 02952 vis_and(TMP12, MASK_fe, TMP12); 02953 02954 vis_and(TMP16, MASK_fe, TMP16); 02955 vis_mul8x16(CONST_128, TMP12, TMP12); 02956 02957 vis_mul8x16(CONST_128, TMP16, TMP16); 02958 vis_xor(REF_0, REF_2, TMP0); 02959 02960 vis_xor(REF_4, REF_6, TMP2); 02961 02962 vis_and(REF_0, REF_2, TMP20); 02963 02964 vis_and(TMP12, MASK_7f, TMP12); 02965 02966 vis_and(TMP16, MASK_7f, TMP16); 02967 02968 vis_padd16(TMP14, TMP12, TMP12); 02969 vis_st64(TMP12, dest[0]); 02970 02971 vis_padd16(TMP18, TMP16, TMP16); 02972 vis_st64_2(TMP16, dest, 8); 02973 dest += stride; 02974 02975 vis_and(REF_4, REF_6, TMP18); 02976 02977 vis_and(TMP0, MASK_fe, TMP0); 02978 02979 vis_and(TMP2, MASK_fe, TMP2); 02980 vis_mul8x16(CONST_128, TMP0, TMP0); 02981 02982 vis_faligndata(TMP6, TMP8, REF_2); 02983 vis_mul8x16(CONST_128, TMP2, TMP2); 02984 02985 vis_faligndata(TMP8, TMP10, REF_6); 02986 02987 vis_and(TMP0, MASK_7f, TMP0); 02988 02989 vis_and(TMP2, MASK_7f, TMP2); 02990 02991 vis_padd16(TMP20, TMP0, TMP0); 02992 vis_st64(TMP0, dest[0]); 02993 02994 vis_padd16(TMP18, TMP2, TMP2); 02995 vis_st64_2(TMP2, dest, 8); 02996 dest += stride; 02997 } while (--height); 02998 02999 vis_ld64(ref[0], TMP0); 03000 vis_xor(REF_0, REF_2, TMP12); 03001 03002 vis_ld64_2(ref, 8, TMP2); 03003 vis_xor(REF_4, REF_6, TMP16); 03004 03005 vis_ld64_2(ref, 16, TMP4); 03006 vis_and(REF_0, REF_2, TMP14); 03007 03008 vis_and(REF_4, REF_6, TMP18); 03009 03010 vis_faligndata(TMP0, TMP2, REF_0); 03011 03012 vis_faligndata(TMP2, TMP4, REF_4); 03013 03014 vis_and(TMP12, MASK_fe, TMP12); 03015 03016 vis_and(TMP16, MASK_fe, TMP16); 03017 vis_mul8x16(CONST_128, TMP12, TMP12); 03018 03019 vis_mul8x16(CONST_128, TMP16, TMP16); 03020 vis_xor(REF_0, REF_2, TMP0); 03021 03022 vis_xor(REF_4, REF_6, TMP2); 03023 03024 vis_and(REF_0, REF_2, TMP20); 03025 03026 vis_and(TMP12, MASK_7f, TMP12); 03027 03028 vis_and(TMP16, MASK_7f, TMP16); 03029 03030 vis_padd16(TMP14, TMP12, TMP12); 03031 vis_st64(TMP12, dest[0]); 03032 03033 vis_padd16(TMP18, TMP16, TMP16); 03034 vis_st64_2(TMP16, dest, 8); 03035 dest += stride; 03036 03037 vis_and(REF_4, REF_6, TMP18); 03038 03039 vis_and(TMP0, MASK_fe, TMP0); 03040 03041 vis_and(TMP2, MASK_fe, TMP2); 03042 vis_mul8x16(CONST_128, TMP0, TMP0); 03043 03044 vis_mul8x16(CONST_128, TMP2, TMP2); 03045 03046 vis_and(TMP0, MASK_7f, TMP0); 03047 03048 vis_and(TMP2, MASK_7f, TMP2); 03049 03050 vis_padd16(TMP20, TMP0, TMP0); 03051 vis_st64(TMP0, dest[0]); 03052 03053 vis_padd16(TMP18, TMP2, TMP2); 03054 vis_st64_2(TMP2, dest, 8); 03055 } 03056 03057 static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref, 03058 const int stride, int height) 03059 { 03060 ref = vis_alignaddr(ref); 03061 vis_ld64(ref[0], TMP0); 03062 03063 vis_ld64_2(ref, 8, TMP2); 03064 ref += stride; 03065 03066 vis_ld64(ref[0], TMP4); 03067 03068 vis_ld64_2(ref, 8, TMP6); 03069 ref += stride; 03070 03071 vis_ld64(constants_fe[0], MASK_fe); 03072 vis_faligndata(TMP0, TMP2, REF_0); 03073 03074 vis_ld64(constants_7f[0], MASK_7f); 03075 vis_faligndata(TMP4, TMP6, REF_2); 03076 03077 vis_ld64(constants128[0], CONST_128); 03078 height = (height >> 1) - 1; 03079 do { /* 12 cycles */ 03080 vis_ld64(ref[0], TMP0); 03081 vis_xor(REF_0, REF_2, TMP4); 03082 03083 vis_ld64_2(ref, 8, TMP2); 03084 ref += stride; 03085 vis_and(TMP4, MASK_fe, TMP4); 03086 03087 vis_and(REF_0, REF_2, TMP6); 03088 vis_mul8x16(CONST_128, TMP4, TMP4); 03089 03090 vis_faligndata(TMP0, TMP2, REF_0); 03091 vis_ld64(ref[0], TMP0); 03092 03093 vis_ld64_2(ref, 8, TMP2); 03094 ref += stride; 03095 vis_xor(REF_0, REF_2, TMP12); 03096 03097 vis_and(TMP4, MASK_7f, TMP4); 03098 03099 vis_and(TMP12, MASK_fe, TMP12); 03100 03101 vis_mul8x16(CONST_128, TMP12, TMP12); 03102 vis_and(REF_0, REF_2, TMP14); 03103 03104 vis_padd16(TMP6, TMP4, DST_0); 03105 vis_st64(DST_0, dest[0]); 03106 dest += stride; 03107 03108 vis_faligndata(TMP0, TMP2, REF_2); 03109 03110 vis_and(TMP12, MASK_7f, TMP12); 03111 03112 vis_padd16(TMP14, TMP12, DST_0); 03113 vis_st64(DST_0, dest[0]); 03114 dest += stride; 03115 } while (--height); 03116 03117 vis_ld64(ref[0], TMP0); 03118 vis_xor(REF_0, REF_2, TMP4); 03119 03120 vis_ld64_2(ref, 8, TMP2); 03121 vis_and(TMP4, MASK_fe, TMP4); 03122 03123 vis_and(REF_0, REF_2, TMP6); 03124 vis_mul8x16(CONST_128, TMP4, TMP4); 03125 03126 vis_faligndata(TMP0, TMP2, REF_0); 03127 03128 vis_xor(REF_0, REF_2, TMP12); 03129 03130 vis_and(TMP4, MASK_7f, TMP4); 03131 03132 vis_and(TMP12, MASK_fe, TMP12); 03133 03134 vis_mul8x16(CONST_128, TMP12, TMP12); 03135 vis_and(REF_0, REF_2, TMP14); 03136 03137 vis_padd16(TMP6, TMP4, DST_0); 03138 vis_st64(DST_0, dest[0]); 03139 dest += stride; 03140 03141 vis_and(TMP12, MASK_7f, TMP12); 03142 03143 vis_padd16(TMP14, TMP12, DST_0); 03144 vis_st64(DST_0, dest[0]); 03145 } 03146 03147 static void MC_avg_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref, 03148 const int stride, int height) 03149 { 03150 int stride_8 = stride + 8; 03151 int stride_16 = stride + 16; 03152 03153 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 03154 03155 ref = vis_alignaddr(ref); 03156 03157 vis_ld64(ref[ 0], TMP0); 03158 vis_fzero(ZERO); 03159 03160 vis_ld64(ref[ 8], TMP2); 03161 03162 vis_ld64(ref[16], TMP4); 03163 03164 vis_ld64(constants3[0], CONST_3); 03165 vis_faligndata(TMP0, TMP2, REF_2); 03166 03167 vis_ld64(constants256_512[0], CONST_256); 03168 vis_faligndata(TMP2, TMP4, REF_6); 03169 height >>= 1; 03170 03171 do { /* 31 cycles */ 03172 vis_ld64_2(ref, stride, TMP0); 03173 vis_pmerge(ZERO, REF_2, TMP12); 03174 vis_mul8x16au(REF_2_1, CONST_256, TMP14); 03175 03176 vis_ld64_2(ref, stride_8, TMP2); 03177 vis_pmerge(ZERO, REF_6, TMP16); 03178 vis_mul8x16au(REF_6_1, CONST_256, TMP18); 03179 03180 vis_ld64_2(ref, stride_16, TMP4); 03181 ref += stride; 03182 03183 vis_ld64(dest[0], DST_0); 03184 vis_faligndata(TMP0, TMP2, REF_0); 03185 03186 vis_ld64_2(dest, 8, DST_2); 03187 vis_faligndata(TMP2, TMP4, REF_4); 03188 03189 vis_ld64_2(ref, stride, TMP6); 03190 vis_pmerge(ZERO, REF_0, TMP0); 03191 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 03192 03193 vis_ld64_2(ref, stride_8, TMP8); 03194 vis_pmerge(ZERO, REF_4, TMP4); 03195 03196 vis_ld64_2(ref, stride_16, TMP10); 03197 ref += stride; 03198 03199 vis_ld64_2(dest, stride, REF_S0/*DST_4*/); 03200 vis_faligndata(TMP6, TMP8, REF_2); 03201 vis_mul8x16au(REF_4_1, CONST_256, TMP6); 03202 03203 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/); 03204 vis_faligndata(TMP8, TMP10, REF_6); 03205 vis_mul8x16al(DST_0, CONST_512, TMP20); 03206 03207 vis_padd16(TMP0, CONST_3, TMP0); 03208 vis_mul8x16al(DST_1, CONST_512, TMP22); 03209 03210 vis_padd16(TMP2, CONST_3, TMP2); 03211 vis_mul8x16al(DST_2, CONST_512, TMP24); 03212 03213 vis_padd16(TMP4, CONST_3, TMP4); 03214 vis_mul8x16al(DST_3, CONST_512, TMP26); 03215 03216 vis_padd16(TMP6, CONST_3, TMP6); 03217 03218 vis_padd16(TMP12, TMP20, TMP12); 03219 vis_mul8x16al(REF_S0, CONST_512, TMP20); 03220 03221 vis_padd16(TMP14, TMP22, TMP14); 03222 vis_mul8x16al(REF_S0_1, CONST_512, TMP22); 03223 03224 vis_padd16(TMP16, TMP24, TMP16); 03225 vis_mul8x16al(REF_S2, CONST_512, TMP24); 03226 03227 vis_padd16(TMP18, TMP26, TMP18); 03228 vis_mul8x16al(REF_S2_1, CONST_512, TMP26); 03229 03230 vis_padd16(TMP12, TMP0, TMP12); 03231 vis_mul8x16au(REF_2, CONST_256, TMP28); 03232 03233 vis_padd16(TMP14, TMP2, TMP14); 03234 vis_mul8x16au(REF_2_1, CONST_256, TMP30); 03235 03236 vis_padd16(TMP16, TMP4, TMP16); 03237 vis_mul8x16au(REF_6, CONST_256, REF_S4); 03238 03239 vis_padd16(TMP18, TMP6, TMP18); 03240 vis_mul8x16au(REF_6_1, CONST_256, REF_S6); 03241 03242 vis_pack16(TMP12, DST_0); 03243 vis_padd16(TMP28, TMP0, TMP12); 03244 03245 vis_pack16(TMP14, DST_1); 03246 vis_st64(DST_0, dest[0]); 03247 vis_padd16(TMP30, TMP2, TMP14); 03248 03249 vis_pack16(TMP16, DST_2); 03250 vis_padd16(REF_S4, TMP4, TMP16); 03251 03252 vis_pack16(TMP18, DST_3); 03253 vis_st64_2(DST_2, dest, 8); 03254 dest += stride; 03255 vis_padd16(REF_S6, TMP6, TMP18); 03256 03257 vis_padd16(TMP12, TMP20, TMP12); 03258 03259 vis_padd16(TMP14, TMP22, TMP14); 03260 vis_pack16(TMP12, DST_0); 03261 03262 vis_padd16(TMP16, TMP24, TMP16); 03263 vis_pack16(TMP14, DST_1); 03264 vis_st64(DST_0, dest[0]); 03265 03266 vis_padd16(TMP18, TMP26, TMP18); 03267 vis_pack16(TMP16, DST_2); 03268 03269 vis_pack16(TMP18, DST_3); 03270 vis_st64_2(DST_2, dest, 8); 03271 dest += stride; 03272 } while (--height); 03273 } 03274 03275 static void MC_avg_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref, 03276 const int stride, int height) 03277 { 03278 int stride_8 = stride + 8; 03279 03280 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 03281 03282 ref = vis_alignaddr(ref); 03283 03284 vis_ld64(ref[ 0], TMP0); 03285 vis_fzero(ZERO); 03286 03287 vis_ld64(ref[ 8], TMP2); 03288 03289 vis_ld64(constants3[0], CONST_3); 03290 vis_faligndata(TMP0, TMP2, REF_2); 03291 03292 vis_ld64(constants256_512[0], CONST_256); 03293 03294 height >>= 1; 03295 do { /* 20 cycles */ 03296 vis_ld64_2(ref, stride, TMP0); 03297 vis_pmerge(ZERO, REF_2, TMP8); 03298 vis_mul8x16au(REF_2_1, CONST_256, TMP10); 03299 03300 vis_ld64_2(ref, stride_8, TMP2); 03301 ref += stride; 03302 03303 vis_ld64(dest[0], DST_0); 03304 03305 vis_ld64_2(dest, stride, DST_2); 03306 vis_faligndata(TMP0, TMP2, REF_0); 03307 03308 vis_ld64_2(ref, stride, TMP4); 03309 vis_mul8x16al(DST_0, CONST_512, TMP16); 03310 vis_pmerge(ZERO, REF_0, TMP12); 03311 03312 vis_ld64_2(ref, stride_8, TMP6); 03313 ref += stride; 03314 vis_mul8x16al(DST_1, CONST_512, TMP18); 03315 vis_pmerge(ZERO, REF_0_1, TMP14); 03316 03317 vis_padd16(TMP12, CONST_3, TMP12); 03318 vis_mul8x16al(DST_2, CONST_512, TMP24); 03319 03320 vis_padd16(TMP14, CONST_3, TMP14); 03321 vis_mul8x16al(DST_3, CONST_512, TMP26); 03322 03323 vis_faligndata(TMP4, TMP6, REF_2); 03324 03325 vis_padd16(TMP8, TMP12, TMP8); 03326 03327 vis_padd16(TMP10, TMP14, TMP10); 03328 vis_mul8x16au(REF_2, CONST_256, TMP20); 03329 03330 vis_padd16(TMP8, TMP16, TMP0); 03331 vis_mul8x16au(REF_2_1, CONST_256, TMP22); 03332 03333 vis_padd16(TMP10, TMP18, TMP2); 03334 vis_pack16(TMP0, DST_0); 03335 03336 vis_pack16(TMP2, DST_1); 03337 vis_st64(DST_0, dest[0]); 03338 dest += stride; 03339 vis_padd16(TMP12, TMP20, TMP12); 03340 03341 vis_padd16(TMP14, TMP22, TMP14); 03342 03343 vis_padd16(TMP12, TMP24, TMP0); 03344 03345 vis_padd16(TMP14, TMP26, TMP2); 03346 vis_pack16(TMP0, DST_2); 03347 03348 vis_pack16(TMP2, DST_3); 03349 vis_st64(DST_2, dest[0]); 03350 dest += stride; 03351 } while (--height); 03352 } 03353 03354 static void MC_put_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref, 03355 const int stride, int height) 03356 { 03357 unsigned long off = (unsigned long) ref & 0x7; 03358 unsigned long off_plus_1 = off + 1; 03359 int stride_8 = stride + 8; 03360 int stride_16 = stride + 16; 03361 03362 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 03363 03364 ref = vis_alignaddr(ref); 03365 03366 vis_ld64(ref[ 0], TMP0); 03367 vis_fzero(ZERO); 03368 03369 vis_ld64(ref[ 8], TMP2); 03370 03371 vis_ld64(ref[16], TMP4); 03372 03373 vis_ld64(constants1[0], CONST_1); 03374 vis_faligndata(TMP0, TMP2, REF_S0); 03375 03376 vis_ld64(constants256_512[0], CONST_256); 03377 vis_faligndata(TMP2, TMP4, REF_S4); 03378 03379 if (off != 0x7) { 03380 vis_alignaddr_g0((void *)off_plus_1); 03381 vis_faligndata(TMP0, TMP2, REF_S2); 03382 vis_faligndata(TMP2, TMP4, REF_S6); 03383 } else { 03384 vis_src1(TMP2, REF_S2); 03385 vis_src1(TMP4, REF_S6); 03386 } 03387 03388 height >>= 1; 03389 do { 03390 vis_ld64_2(ref, stride, TMP0); 03391 vis_mul8x16au(REF_S0, CONST_256, TMP12); 03392 vis_pmerge(ZERO, REF_S0_1, TMP14); 03393 03394 vis_alignaddr_g0((void *)off); 03395 03396 vis_ld64_2(ref, stride_8, TMP2); 03397 vis_mul8x16au(REF_S2, CONST_256, TMP16); 03398 vis_pmerge(ZERO, REF_S2_1, TMP18); 03399 03400 vis_ld64_2(ref, stride_16, TMP4); 03401 ref += stride; 03402 vis_mul8x16au(REF_S4, CONST_256, TMP20); 03403 vis_pmerge(ZERO, REF_S4_1, TMP22); 03404 03405 vis_ld64_2(ref, stride, TMP6); 03406 vis_mul8x16au(REF_S6, CONST_256, TMP24); 03407 vis_pmerge(ZERO, REF_S6_1, TMP26); 03408 03409 vis_ld64_2(ref, stride_8, TMP8); 03410 vis_faligndata(TMP0, TMP2, REF_0); 03411 03412 vis_ld64_2(ref, stride_16, TMP10); 03413 ref += stride; 03414 vis_faligndata(TMP2, TMP4, REF_4); 03415 03416 vis_faligndata(TMP6, TMP8, REF_S0); 03417 03418 vis_faligndata(TMP8, TMP10, REF_S4); 03419 03420 if (off != 0x7) { 03421 vis_alignaddr_g0((void *)off_plus_1); 03422 vis_faligndata(TMP0, TMP2, REF_2); 03423 vis_faligndata(TMP2, TMP4, REF_6); 03424 vis_faligndata(TMP6, TMP8, REF_S2); 03425 vis_faligndata(TMP8, TMP10, REF_S6); 03426 } else { 03427 vis_src1(TMP2, REF_2); 03428 vis_src1(TMP4, REF_6); 03429 vis_src1(TMP8, REF_S2); 03430 vis_src1(TMP10, REF_S6); 03431 } 03432 03433 vis_mul8x16au(REF_0, CONST_256, TMP0); 03434 vis_pmerge(ZERO, REF_0_1, TMP2); 03435 03436 vis_mul8x16au(REF_2, CONST_256, TMP4); 03437 vis_pmerge(ZERO, REF_2_1, TMP6); 03438 03439 vis_padd16(TMP0, CONST_2, TMP8); 03440 vis_mul8x16au(REF_4, CONST_256, TMP0); 03441 03442 vis_padd16(TMP2, CONST_1, TMP10); 03443 vis_mul8x16au(REF_4_1, CONST_256, TMP2); 03444 03445 vis_padd16(TMP8, TMP4, TMP8); 03446 vis_mul8x16au(REF_6, CONST_256, TMP4); 03447 03448 vis_padd16(TMP10, TMP6, TMP10); 03449 vis_mul8x16au(REF_6_1, CONST_256, TMP6); 03450 03451 vis_padd16(TMP12, TMP8, TMP12); 03452 03453 vis_padd16(TMP14, TMP10, TMP14); 03454 03455 vis_padd16(TMP12, TMP16, TMP12); 03456 03457 vis_padd16(TMP14, TMP18, TMP14); 03458 vis_pack16(TMP12, DST_0); 03459 03460 vis_pack16(TMP14, DST_1); 03461 vis_st64(DST_0, dest[0]); 03462 vis_padd16(TMP0, CONST_1, TMP12); 03463 03464 vis_mul8x16au(REF_S0, CONST_256, TMP0); 03465 vis_padd16(TMP2, CONST_1, TMP14); 03466 03467 vis_mul8x16au(REF_S0_1, CONST_256, TMP2); 03468 vis_padd16(TMP12, TMP4, TMP12); 03469 03470 vis_mul8x16au(REF_S2, CONST_256, TMP4); 03471 vis_padd16(TMP14, TMP6, TMP14); 03472 03473 vis_mul8x16au(REF_S2_1, CONST_256, TMP6); 03474 vis_padd16(TMP20, TMP12, TMP20); 03475 03476 vis_padd16(TMP22, TMP14, TMP22); 03477 03478 vis_padd16(TMP20, TMP24, TMP20); 03479 03480 vis_padd16(TMP22, TMP26, TMP22); 03481 vis_pack16(TMP20, DST_2); 03482 03483 vis_pack16(TMP22, DST_3); 03484 vis_st64_2(DST_2, dest, 8); 03485 dest += stride; 03486 vis_padd16(TMP0, TMP4, TMP24); 03487 03488 vis_mul8x16au(REF_S4, CONST_256, TMP0); 03489 vis_padd16(TMP2, TMP6, TMP26); 03490 03491 vis_mul8x16au(REF_S4_1, CONST_256, TMP2); 03492 vis_padd16(TMP24, TMP8, TMP24); 03493 03494 vis_padd16(TMP26, TMP10, TMP26); 03495 vis_pack16(TMP24, DST_0); 03496 03497 vis_pack16(TMP26, DST_1); 03498 vis_st64(DST_0, dest[0]); 03499 vis_pmerge(ZERO, REF_S6, TMP4); 03500 03501 vis_pmerge(ZERO, REF_S6_1, TMP6); 03502 03503 vis_padd16(TMP0, TMP4, TMP0); 03504 03505 vis_padd16(TMP2, TMP6, TMP2); 03506 03507 vis_padd16(TMP0, TMP12, TMP0); 03508 03509 vis_padd16(TMP2, TMP14, TMP2); 03510 vis_pack16(TMP0, DST_2); 03511 03512 vis_pack16(TMP2, DST_3); 03513 vis_st64_2(DST_2, dest, 8); 03514 dest += stride; 03515 } while (--height); 03516 } 03517 03518 static void MC_put_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref, 03519 const int stride, int height) 03520 { 03521 unsigned long off = (unsigned long) ref & 0x7; 03522 unsigned long off_plus_1 = off + 1; 03523 int stride_8 = stride + 8; 03524 03525 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 03526 03527 ref = vis_alignaddr(ref); 03528 03529 vis_ld64(ref[ 0], TMP0); 03530 vis_fzero(ZERO); 03531 03532 vis_ld64(ref[ 8], TMP2); 03533 03534 vis_ld64(constants1[0], CONST_1); 03535 03536 vis_ld64(constants256_512[0], CONST_256); 03537 vis_faligndata(TMP0, TMP2, REF_S0); 03538 03539 if (off != 0x7) { 03540 vis_alignaddr_g0((void *)off_plus_1); 03541 vis_faligndata(TMP0, TMP2, REF_S2); 03542 } else { 03543 vis_src1(TMP2, REF_S2); 03544 } 03545 03546 height >>= 1; 03547 do { /* 26 cycles */ 03548 vis_ld64_2(ref, stride, TMP0); 03549 vis_mul8x16au(REF_S0, CONST_256, TMP8); 03550 vis_pmerge(ZERO, REF_S2, TMP12); 03551 03552 vis_alignaddr_g0((void *)off); 03553 03554 vis_ld64_2(ref, stride_8, TMP2); 03555 ref += stride; 03556 vis_mul8x16au(REF_S0_1, CONST_256, TMP10); 03557 vis_pmerge(ZERO, REF_S2_1, TMP14); 03558 03559 vis_ld64_2(ref, stride, TMP4); 03560 03561 vis_ld64_2(ref, stride_8, TMP6); 03562 ref += stride; 03563 vis_faligndata(TMP0, TMP2, REF_S4); 03564 03565 vis_pmerge(ZERO, REF_S4, TMP18); 03566 03567 vis_pmerge(ZERO, REF_S4_1, TMP20); 03568 03569 vis_faligndata(TMP4, TMP6, REF_S0); 03570 03571 if (off != 0x7) { 03572 vis_alignaddr_g0((void *)off_plus_1); 03573 vis_faligndata(TMP0, TMP2, REF_S6); 03574 vis_faligndata(TMP4, TMP6, REF_S2); 03575 } else { 03576 vis_src1(TMP2, REF_S6); 03577 vis_src1(TMP6, REF_S2); 03578 } 03579 03580 vis_padd16(TMP18, CONST_1, TMP18); 03581 vis_mul8x16au(REF_S6, CONST_256, TMP22); 03582 03583 vis_padd16(TMP20, CONST_1, TMP20); 03584 vis_mul8x16au(REF_S6_1, CONST_256, TMP24); 03585 03586 vis_mul8x16au(REF_S0, CONST_256, TMP26); 03587 vis_pmerge(ZERO, REF_S0_1, TMP28); 03588 03589 vis_mul8x16au(REF_S2, CONST_256, TMP30); 03590 vis_padd16(TMP18, TMP22, TMP18); 03591 03592 vis_mul8x16au(REF_S2_1, CONST_256, TMP32); 03593 vis_padd16(TMP20, TMP24, TMP20); 03594 03595 vis_padd16(TMP8, TMP18, TMP8); 03596 03597 vis_padd16(TMP10, TMP20, TMP10); 03598 03599 vis_padd16(TMP8, TMP12, TMP8); 03600 03601 vis_padd16(TMP10, TMP14, TMP10); 03602 vis_pack16(TMP8, DST_0); 03603 03604 vis_pack16(TMP10, DST_1); 03605 vis_st64(DST_0, dest[0]); 03606 dest += stride; 03607 vis_padd16(TMP18, TMP26, TMP18); 03608 03609 vis_padd16(TMP20, TMP28, TMP20); 03610 03611 vis_padd16(TMP18, TMP30, TMP18); 03612 03613 vis_padd16(TMP20, TMP32, TMP20); 03614 vis_pack16(TMP18, DST_2); 03615 03616 vis_pack16(TMP20, DST_3); 03617 vis_st64(DST_2, dest[0]); 03618 dest += stride; 03619 } while (--height); 03620 } 03621 03622 static void MC_avg_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref, 03623 const int stride, int height) 03624 { 03625 unsigned long off = (unsigned long) ref & 0x7; 03626 unsigned long off_plus_1 = off + 1; 03627 int stride_8 = stride + 8; 03628 int stride_16 = stride + 16; 03629 03630 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT); 03631 03632 ref = vis_alignaddr(ref); 03633 03634 vis_ld64(ref[ 0], TMP0); 03635 vis_fzero(ZERO); 03636 03637 vis_ld64(ref[ 8], TMP2); 03638 03639 vis_ld64(ref[16], TMP4); 03640 03641 vis_ld64(constants6[0], CONST_6); 03642 vis_faligndata(TMP0, TMP2, REF_S0); 03643 03644 vis_ld64(constants256_1024[0], CONST_256); 03645 vis_faligndata(TMP2, TMP4, REF_S4); 03646 03647 if (off != 0x7) { 03648 vis_alignaddr_g0((void *)off_plus_1); 03649 vis_faligndata(TMP0, TMP2, REF_S2); 03650 vis_faligndata(TMP2, TMP4, REF_S6); 03651 } else { 03652 vis_src1(TMP2, REF_S2); 03653 vis_src1(TMP4, REF_S6); 03654 } 03655 03656 height >>= 1; 03657 do { /* 55 cycles */ 03658 vis_ld64_2(ref, stride, TMP0); 03659 vis_mul8x16au(REF_S0, CONST_256, TMP12); 03660 vis_pmerge(ZERO, REF_S0_1, TMP14); 03661 03662 vis_alignaddr_g0((void *)off); 03663 03664 vis_ld64_2(ref, stride_8, TMP2); 03665 vis_mul8x16au(REF_S2, CONST_256, TMP16); 03666 vis_pmerge(ZERO, REF_S2_1, TMP18); 03667 03668 vis_ld64_2(ref, stride_16, TMP4); 03669 ref += stride; 03670 vis_mul8x16au(REF_S4, CONST_256, TMP20); 03671 vis_pmerge(ZERO, REF_S4_1, TMP22); 03672 03673 vis_ld64_2(ref, stride, TMP6); 03674 vis_mul8x16au(REF_S6, CONST_256, TMP24); 03675 vis_pmerge(ZERO, REF_S6_1, TMP26); 03676 03677 vis_ld64_2(ref, stride_8, TMP8); 03678 vis_faligndata(TMP0, TMP2, REF_0); 03679 03680 vis_ld64_2(ref, stride_16, TMP10); 03681 ref += stride; 03682 vis_faligndata(TMP2, TMP4, REF_4); 03683 03684 vis_ld64(dest[0], DST_0); 03685 vis_faligndata(TMP6, TMP8, REF_S0); 03686 03687 vis_ld64_2(dest, 8, DST_2); 03688 vis_faligndata(TMP8, TMP10, REF_S4); 03689 03690 if (off != 0x7) { 03691 vis_alignaddr_g0((void *)off_plus_1); 03692 vis_faligndata(TMP0, TMP2, REF_2); 03693 vis_faligndata(TMP2, TMP4, REF_6); 03694 vis_faligndata(TMP6, TMP8, REF_S2); 03695 vis_faligndata(TMP8, TMP10, REF_S6); 03696 } else { 03697 vis_src1(TMP2, REF_2); 03698 vis_src1(TMP4, REF_6); 03699 vis_src1(TMP8, REF_S2); 03700 vis_src1(TMP10, REF_S6); 03701 } 03702 03703 vis_mul8x16al(DST_0, CONST_1024, TMP30); 03704 vis_pmerge(ZERO, REF_0, TMP0); 03705 03706 vis_mul8x16al(DST_1, CONST_1024, TMP32); 03707 vis_pmerge(ZERO, REF_0_1, TMP2); 03708 03709 vis_mul8x16au(REF_2, CONST_256, TMP4); 03710 vis_pmerge(ZERO, REF_2_1, TMP6); 03711 03712 vis_mul8x16al(DST_2, CONST_1024, REF_0); 03713 vis_padd16(TMP0, CONST_6, TMP0); 03714 03715 vis_mul8x16al(DST_3, CONST_1024, REF_2); 03716 vis_padd16(TMP2, CONST_6, TMP2); 03717 03718 vis_padd16(TMP0, TMP4, TMP0); 03719 vis_mul8x16au(REF_4, CONST_256, TMP4); 03720 03721 vis_padd16(TMP2, TMP6, TMP2); 03722 vis_mul8x16au(REF_4_1, CONST_256, TMP6); 03723 03724 vis_padd16(TMP12, TMP0, TMP12); 03725 vis_mul8x16au(REF_6, CONST_256, TMP8); 03726 03727 vis_padd16(TMP14, TMP2, TMP14); 03728 vis_mul8x16au(REF_6_1, CONST_256, TMP10); 03729 03730 vis_padd16(TMP12, TMP16, TMP12); 03731 vis_mul8x16au(REF_S0, CONST_256, REF_4); 03732 03733 vis_padd16(TMP14, TMP18, TMP14); 03734 vis_mul8x16au(REF_S0_1, CONST_256, REF_6); 03735 03736 vis_padd16(TMP12, TMP30, TMP12); 03737 03738 vis_padd16(TMP14, TMP32, TMP14); 03739 vis_pack16(TMP12, DST_0); 03740 03741 vis_pack16(TMP14, DST_1); 03742 vis_st64(DST_0, dest[0]); 03743 vis_padd16(TMP4, CONST_6, TMP4); 03744 03745 vis_ld64_2(dest, stride, DST_0); 03746 vis_padd16(TMP6, CONST_6, TMP6); 03747 vis_mul8x16au(REF_S2, CONST_256, TMP12); 03748 03749 vis_padd16(TMP4, TMP8, TMP4); 03750 vis_mul8x16au(REF_S2_1, CONST_256, TMP14); 03751 03752 vis_padd16(TMP6, TMP10, TMP6); 03753 03754 vis_padd16(TMP20, TMP4, TMP20); 03755 03756 vis_padd16(TMP22, TMP6, TMP22); 03757 03758 vis_padd16(TMP20, TMP24, TMP20); 03759 03760 vis_padd16(TMP22, TMP26, TMP22); 03761 03762 vis_padd16(TMP20, REF_0, TMP20); 03763 vis_mul8x16au(REF_S4, CONST_256, REF_0); 03764 03765 vis_padd16(TMP22, REF_2, TMP22); 03766 vis_pack16(TMP20, DST_2); 03767 03768 vis_pack16(TMP22, DST_3); 03769 vis_st64_2(DST_2, dest, 8); 03770 dest += stride; 03771 03772 vis_ld64_2(dest, 8, DST_2); 03773 vis_mul8x16al(DST_0, CONST_1024, TMP30); 03774 vis_pmerge(ZERO, REF_S4_1, REF_2); 03775 03776 vis_mul8x16al(DST_1, CONST_1024, TMP32); 03777 vis_padd16(REF_4, TMP0, TMP8); 03778 03779 vis_mul8x16au(REF_S6, CONST_256, REF_4); 03780 vis_padd16(REF_6, TMP2, TMP10); 03781 03782 vis_mul8x16au(REF_S6_1, CONST_256, REF_6); 03783 vis_padd16(TMP8, TMP12, TMP8); 03784 03785 vis_padd16(TMP10, TMP14, TMP10); 03786 03787 vis_padd16(TMP8, TMP30, TMP8); 03788 03789 vis_padd16(TMP10, TMP32, TMP10); 03790 vis_pack16(TMP8, DST_0); 03791 03792 vis_pack16(TMP10, DST_1); 03793 vis_st64(DST_0, dest[0]); 03794 03795 vis_padd16(REF_0, TMP4, REF_0); 03796 03797 vis_mul8x16al(DST_2, CONST_1024, TMP30); 03798 vis_padd16(REF_2, TMP6, REF_2); 03799 03800 vis_mul8x16al(DST_3, CONST_1024, TMP32); 03801 vis_padd16(REF_0, REF_4, REF_0); 03802 03803 vis_padd16(REF_2, REF_6, REF_2); 03804 03805 vis_padd16(REF_0, TMP30, REF_0); 03806 03807 /* stall */ 03808 03809 vis_padd16(REF_2, TMP32, REF_2); 03810 vis_pack16(REF_0, DST_2); 03811 03812 vis_pack16(REF_2, DST_3); 03813 vis_st64_2(DST_2, dest, 8); 03814 dest += stride; 03815 } while (--height); 03816 } 03817 03818 static void MC_avg_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref, 03819 const int stride, int height) 03820 { 03821 unsigned long off = (unsigned long) ref & 0x7; 03822 unsigned long off_plus_1 = off + 1; 03823 int stride_8 = stride + 8; 03824 03825 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT); 03826 03827 ref = vis_alignaddr(ref); 03828 03829 vis_ld64(ref[0], TMP0); 03830 vis_fzero(ZERO); 03831 03832 vis_ld64_2(ref, 8, TMP2); 03833 03834 vis_ld64(constants6[0], CONST_6); 03835 03836 vis_ld64(constants256_1024[0], CONST_256); 03837 vis_faligndata(TMP0, TMP2, REF_S0); 03838 03839 if (off != 0x7) { 03840 vis_alignaddr_g0((void *)off_plus_1); 03841 vis_faligndata(TMP0, TMP2, REF_S2); 03842 } else { 03843 vis_src1(TMP2, REF_S2); 03844 } 03845 03846 height >>= 1; 03847 do { /* 31 cycles */ 03848 vis_ld64_2(ref, stride, TMP0); 03849 vis_mul8x16au(REF_S0, CONST_256, TMP8); 03850 vis_pmerge(ZERO, REF_S0_1, TMP10); 03851 03852 vis_ld64_2(ref, stride_8, TMP2); 03853 ref += stride; 03854 vis_mul8x16au(REF_S2, CONST_256, TMP12); 03855 vis_pmerge(ZERO, REF_S2_1, TMP14); 03856 03857 vis_alignaddr_g0((void *)off); 03858 03859 vis_ld64_2(ref, stride, TMP4); 03860 vis_faligndata(TMP0, TMP2, REF_S4); 03861 03862 vis_ld64_2(ref, stride_8, TMP6); 03863 ref += stride; 03864 03865 vis_ld64(dest[0], DST_0); 03866 vis_faligndata(TMP4, TMP6, REF_S0); 03867 03868 vis_ld64_2(dest, stride, DST_2); 03869 03870 if (off != 0x7) { 03871 vis_alignaddr_g0((void *)off_plus_1); 03872 vis_faligndata(TMP0, TMP2, REF_S6); 03873 vis_faligndata(TMP4, TMP6, REF_S2); 03874 } else { 03875 vis_src1(TMP2, REF_S6); 03876 vis_src1(TMP6, REF_S2); 03877 } 03878 03879 vis_mul8x16al(DST_0, CONST_1024, TMP30); 03880 vis_pmerge(ZERO, REF_S4, TMP22); 03881 03882 vis_mul8x16al(DST_1, CONST_1024, TMP32); 03883 vis_pmerge(ZERO, REF_S4_1, TMP24); 03884 03885 vis_mul8x16au(REF_S6, CONST_256, TMP26); 03886 vis_pmerge(ZERO, REF_S6_1, TMP28); 03887 03888 vis_mul8x16au(REF_S0, CONST_256, REF_S4); 03889 vis_padd16(TMP22, CONST_6, TMP22); 03890 03891 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6); 03892 vis_padd16(TMP24, CONST_6, TMP24); 03893 03894 vis_mul8x16al(DST_2, CONST_1024, REF_0); 03895 vis_padd16(TMP22, TMP26, TMP22); 03896 03897 vis_mul8x16al(DST_3, CONST_1024, REF_2); 03898 vis_padd16(TMP24, TMP28, TMP24); 03899 03900 vis_mul8x16au(REF_S2, CONST_256, TMP26); 03901 vis_padd16(TMP8, TMP22, TMP8); 03902 03903 vis_mul8x16au(REF_S2_1, CONST_256, TMP28); 03904 vis_padd16(TMP10, TMP24, TMP10); 03905 03906 vis_padd16(TMP8, TMP12, TMP8); 03907 03908 vis_padd16(TMP10, TMP14, TMP10); 03909 03910 vis_padd16(TMP8, TMP30, TMP8); 03911 03912 vis_padd16(TMP10, TMP32, TMP10); 03913 vis_pack16(TMP8, DST_0); 03914 03915 vis_pack16(TMP10, DST_1); 03916 vis_st64(DST_0, dest[0]); 03917 dest += stride; 03918 03919 vis_padd16(REF_S4, TMP22, TMP12); 03920 03921 vis_padd16(REF_S6, TMP24, TMP14); 03922 03923 vis_padd16(TMP12, TMP26, TMP12); 03924 03925 vis_padd16(TMP14, TMP28, TMP14); 03926 03927 vis_padd16(TMP12, REF_0, TMP12); 03928 03929 vis_padd16(TMP14, REF_2, TMP14); 03930 vis_pack16(TMP12, DST_2); 03931 03932 vis_pack16(TMP14, DST_3); 03933 vis_st64(DST_2, dest[0]); 03934 dest += stride; 03935 } while (--height); 03936 } 03937 03938 /* End of no rounding code */ 03939 03940 #define ACCEL_SPARC_VIS 1 03941 #define ACCEL_SPARC_VIS2 2 03942 03943 static int vis_level(void) 03944 { 03945 int accel = 0; 03946 accel |= ACCEL_SPARC_VIS; 03947 accel |= ACCEL_SPARC_VIS2; 03948 return accel; 03949 } 03950 03951 /* libavcodec initialization code */ 03952 void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx) 03953 { 03954 /* VIS-specific optimizations */ 03955 int accel = vis_level (); 03956 03957 if (accel & ACCEL_SPARC_VIS) { 03958 if(avctx->idct_algo==FF_IDCT_SIMPLEVIS){ 03959 c->idct_put = ff_simple_idct_put_vis; 03960 c->idct_add = ff_simple_idct_add_vis; 03961 c->idct = ff_simple_idct_vis; 03962 c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM; 03963 } 03964 03965 c->put_pixels_tab[0][0] = MC_put_o_16_vis; 03966 c->put_pixels_tab[0][1] = MC_put_x_16_vis; 03967 c->put_pixels_tab[0][2] = MC_put_y_16_vis; 03968 c->put_pixels_tab[0][3] = MC_put_xy_16_vis; 03969 03970 c->put_pixels_tab[1][0] = MC_put_o_8_vis; 03971 c->put_pixels_tab[1][1] = MC_put_x_8_vis; 03972 c->put_pixels_tab[1][2] = MC_put_y_8_vis; 03973 c->put_pixels_tab[1][3] = MC_put_xy_8_vis; 03974 03975 c->avg_pixels_tab[0][0] = MC_avg_o_16_vis; 03976 c->avg_pixels_tab[0][1] = MC_avg_x_16_vis; 03977 c->avg_pixels_tab[0][2] = MC_avg_y_16_vis; 03978 c->avg_pixels_tab[0][3] = MC_avg_xy_16_vis; 03979 03980 c->avg_pixels_tab[1][0] = MC_avg_o_8_vis; 03981 c->avg_pixels_tab[1][1] = MC_avg_x_8_vis; 03982 c->avg_pixels_tab[1][2] = MC_avg_y_8_vis; 03983 c->avg_pixels_tab[1][3] = MC_avg_xy_8_vis; 03984 03985 c->put_no_rnd_pixels_tab[0][0] = MC_put_no_round_o_16_vis; 03986 c->put_no_rnd_pixels_tab[0][1] = MC_put_no_round_x_16_vis; 03987 c->put_no_rnd_pixels_tab[0][2] = MC_put_no_round_y_16_vis; 03988 c->put_no_rnd_pixels_tab[0][3] = MC_put_no_round_xy_16_vis; 03989 03990 c->put_no_rnd_pixels_tab[1][0] = MC_put_no_round_o_8_vis; 03991 c->put_no_rnd_pixels_tab[1][1] = MC_put_no_round_x_8_vis; 03992 c->put_no_rnd_pixels_tab[1][2] = MC_put_no_round_y_8_vis; 03993 c->put_no_rnd_pixels_tab[1][3] = MC_put_no_round_xy_8_vis; 03994 03995 c->avg_no_rnd_pixels_tab[0][0] = MC_avg_no_round_o_16_vis; 03996 c->avg_no_rnd_pixels_tab[0][1] = MC_avg_no_round_x_16_vis; 03997 c->avg_no_rnd_pixels_tab[0][2] = MC_avg_no_round_y_16_vis; 03998 c->avg_no_rnd_pixels_tab[0][3] = MC_avg_no_round_xy_16_vis; 03999 04000 c->avg_no_rnd_pixels_tab[1][0] = MC_avg_no_round_o_8_vis; 04001 c->avg_no_rnd_pixels_tab[1][1] = MC_avg_no_round_x_8_vis; 04002 c->avg_no_rnd_pixels_tab[1][2] = MC_avg_no_round_y_8_vis; 04003 c->avg_no_rnd_pixels_tab[1][3] = MC_avg_no_round_xy_8_vis; 04004 } 04005 }