1/* 2 * Copyright (C) 2003 David S. Miller <davem@redhat.com> 3 * 4 * This file is part of FFmpeg. 5 * 6 * FFmpeg is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU Lesser General Public 8 * License as published by the Free Software Foundation; either 9 * version 2.1 of the License, or (at your option) any later version. 10 * 11 * FFmpeg is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * Lesser General Public License for more details. 15 * 16 * You should have received a copy of the GNU Lesser General Public 17 * License along with FFmpeg; if not, write to the Free Software 18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 19 */ 20 21/* The *no_round* functions have been added by James A. Morrison, 2003,2004. 22 The vis code from libmpeg2 was adapted for ffmpeg by James A. Morrison. 23 */ 24 25#include "config.h" 26 27#include <inttypes.h> 28 29#include "libavcodec/dsputil.h" 30#include "dsputil_vis.h" 31 32#include "vis.h" 33 34/* The trick used in some of this file is the formula from the MMX 35 * motion comp code, which is: 36 * 37 * (x+y+1)>>1 == (x|y)-((x^y)>>1) 38 * 39 * This allows us to average 8 bytes at a time in a 64-bit FPU reg. 40 * We avoid overflows by masking before we do the shift, and we 41 * implement the shift by multiplying by 1/2 using mul8x16. So in 42 * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask 43 * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and 44 * the value 0x80808080 is in f8): 45 * 46 * fxor f0, f2, f10 47 * fand f10, f4, f10 48 * fmul8x16 f8, f10, f10 49 * fand f10, f6, f10 50 * for f0, f2, f12 51 * fpsub16 f12, f10, f10 52 */ 53 54#define DUP4(x) {x, x, x, x} 55#define DUP8(x) {x, x, x, x, x, x, x, x} 56DECLARE_ALIGNED(8, static const int16_t, constants1)[] = DUP4 (1); 57DECLARE_ALIGNED(8, static const int16_t, constants2)[] = DUP4 (2); 58DECLARE_ALIGNED(8, static const int16_t, constants3)[] = DUP4 (3); 59DECLARE_ALIGNED(8, static const int16_t, constants6)[] = DUP4 (6); 60DECLARE_ALIGNED(8, static const int8_t, constants_fe)[] = DUP8 (0xfe); 61DECLARE_ALIGNED(8, static const int8_t, constants_7f)[] = DUP8 (0x7f); 62DECLARE_ALIGNED(8, static const int8_t, constants128)[] = DUP8 (128); 63DECLARE_ALIGNED(8, static const int16_t, constants256_512)[] = 64 {256, 512, 256, 512}; 65DECLARE_ALIGNED(8, static const int16_t, constants256_1024)[] = 66 {256, 1024, 256, 1024}; 67 68#define REF_0 0 69#define REF_0_1 1 70#define REF_2 2 71#define REF_2_1 3 72#define REF_4 4 73#define REF_4_1 5 74#define REF_6 6 75#define REF_6_1 7 76#define REF_S0 8 77#define REF_S0_1 9 78#define REF_S2 10 79#define REF_S2_1 11 80#define REF_S4 12 81#define REF_S4_1 13 82#define REF_S6 14 83#define REF_S6_1 15 84#define DST_0 16 85#define DST_1 17 86#define DST_2 18 87#define DST_3 19 88#define CONST_1 20 89#define CONST_2 20 90#define CONST_3 20 91#define CONST_6 20 92#define MASK_fe 20 93#define CONST_128 22 94#define CONST_256 22 95#define CONST_512 22 96#define CONST_1024 22 97#define TMP0 24 98#define TMP1 25 99#define TMP2 26 100#define TMP3 27 101#define TMP4 28 102#define TMP5 29 103#define ZERO 30 104#define MASK_7f 30 105 106#define TMP6 32 107#define TMP8 34 108#define TMP10 36 109#define TMP12 38 110#define TMP14 40 111#define TMP16 42 112#define TMP18 44 113#define TMP20 46 114#define TMP22 48 115#define TMP24 50 116#define TMP26 52 117#define TMP28 54 118#define TMP30 56 119#define TMP32 58 120 121static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * ref, 122 const int stride, int height) 123{ 124 ref = vis_alignaddr(ref); 125 do { /* 5 cycles */ 126 vis_ld64(ref[0], TMP0); 127 128 vis_ld64_2(ref, 8, TMP2); 129 130 vis_ld64_2(ref, 16, TMP4); 131 ref += stride; 132 133 vis_faligndata(TMP0, TMP2, REF_0); 134 vis_st64(REF_0, dest[0]); 135 136 vis_faligndata(TMP2, TMP4, REF_2); 137 vis_st64_2(REF_2, dest, 8); 138 dest += stride; 139 } while (--height); 140} 141 142static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * ref, 143 const int stride, int height) 144{ 145 ref = vis_alignaddr(ref); 146 do { /* 4 cycles */ 147 vis_ld64(ref[0], TMP0); 148 149 vis_ld64(ref[8], TMP2); 150 ref += stride; 151 152 /* stall */ 153 154 vis_faligndata(TMP0, TMP2, REF_0); 155 vis_st64(REF_0, dest[0]); 156 dest += stride; 157 } while (--height); 158} 159 160 161static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * ref, 162 const int stride, int height) 163{ 164 int stride_8 = stride + 8; 165 166 ref = vis_alignaddr(ref); 167 168 vis_ld64(ref[0], TMP0); 169 170 vis_ld64(ref[8], TMP2); 171 172 vis_ld64(ref[16], TMP4); 173 174 vis_ld64(dest[0], DST_0); 175 176 vis_ld64(dest[8], DST_2); 177 178 vis_ld64(constants_fe[0], MASK_fe); 179 vis_faligndata(TMP0, TMP2, REF_0); 180 181 vis_ld64(constants_7f[0], MASK_7f); 182 vis_faligndata(TMP2, TMP4, REF_2); 183 184 vis_ld64(constants128[0], CONST_128); 185 186 ref += stride; 187 height = (height >> 1) - 1; 188 189 do { /* 24 cycles */ 190 vis_ld64(ref[0], TMP0); 191 vis_xor(DST_0, REF_0, TMP6); 192 193 vis_ld64_2(ref, 8, TMP2); 194 vis_and(TMP6, MASK_fe, TMP6); 195 196 vis_ld64_2(ref, 16, TMP4); 197 ref += stride; 198 vis_mul8x16(CONST_128, TMP6, TMP6); 199 vis_xor(DST_2, REF_2, TMP8); 200 201 vis_and(TMP8, MASK_fe, TMP8); 202 203 vis_or(DST_0, REF_0, TMP10); 204 vis_ld64_2(dest, stride, DST_0); 205 vis_mul8x16(CONST_128, TMP8, TMP8); 206 207 vis_or(DST_2, REF_2, TMP12); 208 vis_ld64_2(dest, stride_8, DST_2); 209 210 vis_ld64(ref[0], TMP14); 211 vis_and(TMP6, MASK_7f, TMP6); 212 213 vis_and(TMP8, MASK_7f, TMP8); 214 215 vis_psub16(TMP10, TMP6, TMP6); 216 vis_st64(TMP6, dest[0]); 217 218 vis_psub16(TMP12, TMP8, TMP8); 219 vis_st64_2(TMP8, dest, 8); 220 221 dest += stride; 222 vis_ld64_2(ref, 8, TMP16); 223 vis_faligndata(TMP0, TMP2, REF_0); 224 225 vis_ld64_2(ref, 16, TMP18); 226 vis_faligndata(TMP2, TMP4, REF_2); 227 ref += stride; 228 229 vis_xor(DST_0, REF_0, TMP20); 230 231 vis_and(TMP20, MASK_fe, TMP20); 232 233 vis_xor(DST_2, REF_2, TMP22); 234 vis_mul8x16(CONST_128, TMP20, TMP20); 235 236 vis_and(TMP22, MASK_fe, TMP22); 237 238 vis_or(DST_0, REF_0, TMP24); 239 vis_mul8x16(CONST_128, TMP22, TMP22); 240 241 vis_or(DST_2, REF_2, TMP26); 242 243 vis_ld64_2(dest, stride, DST_0); 244 vis_faligndata(TMP14, TMP16, REF_0); 245 246 vis_ld64_2(dest, stride_8, DST_2); 247 vis_faligndata(TMP16, TMP18, REF_2); 248 249 vis_and(TMP20, MASK_7f, TMP20); 250 251 vis_and(TMP22, MASK_7f, TMP22); 252 253 vis_psub16(TMP24, TMP20, TMP20); 254 vis_st64(TMP20, dest[0]); 255 256 vis_psub16(TMP26, TMP22, TMP22); 257 vis_st64_2(TMP22, dest, 8); 258 dest += stride; 259 } while (--height); 260 261 vis_ld64(ref[0], TMP0); 262 vis_xor(DST_0, REF_0, TMP6); 263 264 vis_ld64_2(ref, 8, TMP2); 265 vis_and(TMP6, MASK_fe, TMP6); 266 267 vis_ld64_2(ref, 16, TMP4); 268 vis_mul8x16(CONST_128, TMP6, TMP6); 269 vis_xor(DST_2, REF_2, TMP8); 270 271 vis_and(TMP8, MASK_fe, TMP8); 272 273 vis_or(DST_0, REF_0, TMP10); 274 vis_ld64_2(dest, stride, DST_0); 275 vis_mul8x16(CONST_128, TMP8, TMP8); 276 277 vis_or(DST_2, REF_2, TMP12); 278 vis_ld64_2(dest, stride_8, DST_2); 279 280 vis_ld64(ref[0], TMP14); 281 vis_and(TMP6, MASK_7f, TMP6); 282 283 vis_and(TMP8, MASK_7f, TMP8); 284 285 vis_psub16(TMP10, TMP6, TMP6); 286 vis_st64(TMP6, dest[0]); 287 288 vis_psub16(TMP12, TMP8, TMP8); 289 vis_st64_2(TMP8, dest, 8); 290 291 dest += stride; 292 vis_faligndata(TMP0, TMP2, REF_0); 293 294 vis_faligndata(TMP2, TMP4, REF_2); 295 296 vis_xor(DST_0, REF_0, TMP20); 297 298 vis_and(TMP20, MASK_fe, TMP20); 299 300 vis_xor(DST_2, REF_2, TMP22); 301 vis_mul8x16(CONST_128, TMP20, TMP20); 302 303 vis_and(TMP22, MASK_fe, TMP22); 304 305 vis_or(DST_0, REF_0, TMP24); 306 vis_mul8x16(CONST_128, TMP22, TMP22); 307 308 vis_or(DST_2, REF_2, TMP26); 309 310 vis_and(TMP20, MASK_7f, TMP20); 311 312 vis_and(TMP22, MASK_7f, TMP22); 313 314 vis_psub16(TMP24, TMP20, TMP20); 315 vis_st64(TMP20, dest[0]); 316 317 vis_psub16(TMP26, TMP22, TMP22); 318 vis_st64_2(TMP22, dest, 8); 319} 320 321static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * ref, 322 const int stride, int height) 323{ 324 ref = vis_alignaddr(ref); 325 326 vis_ld64(ref[0], TMP0); 327 328 vis_ld64(ref[8], TMP2); 329 330 vis_ld64(dest[0], DST_0); 331 332 vis_ld64(constants_fe[0], MASK_fe); 333 334 vis_ld64(constants_7f[0], MASK_7f); 335 vis_faligndata(TMP0, TMP2, REF_0); 336 337 vis_ld64(constants128[0], CONST_128); 338 339 ref += stride; 340 height = (height >> 1) - 1; 341 342 do { /* 12 cycles */ 343 vis_ld64(ref[0], TMP0); 344 vis_xor(DST_0, REF_0, TMP4); 345 346 vis_ld64(ref[8], TMP2); 347 vis_and(TMP4, MASK_fe, TMP4); 348 349 vis_or(DST_0, REF_0, TMP6); 350 vis_ld64_2(dest, stride, DST_0); 351 ref += stride; 352 vis_mul8x16(CONST_128, TMP4, TMP4); 353 354 vis_ld64(ref[0], TMP12); 355 vis_faligndata(TMP0, TMP2, REF_0); 356 357 vis_ld64(ref[8], TMP2); 358 vis_xor(DST_0, REF_0, TMP0); 359 ref += stride; 360 361 vis_and(TMP0, MASK_fe, TMP0); 362 363 vis_and(TMP4, MASK_7f, TMP4); 364 365 vis_psub16(TMP6, TMP4, TMP4); 366 vis_st64(TMP4, dest[0]); 367 dest += stride; 368 vis_mul8x16(CONST_128, TMP0, TMP0); 369 370 vis_or(DST_0, REF_0, TMP6); 371 vis_ld64_2(dest, stride, DST_0); 372 373 vis_faligndata(TMP12, TMP2, REF_0); 374 375 vis_and(TMP0, MASK_7f, TMP0); 376 377 vis_psub16(TMP6, TMP0, TMP4); 378 vis_st64(TMP4, dest[0]); 379 dest += stride; 380 } while (--height); 381 382 vis_ld64(ref[0], TMP0); 383 vis_xor(DST_0, REF_0, TMP4); 384 385 vis_ld64(ref[8], TMP2); 386 vis_and(TMP4, MASK_fe, TMP4); 387 388 vis_or(DST_0, REF_0, TMP6); 389 vis_ld64_2(dest, stride, DST_0); 390 vis_mul8x16(CONST_128, TMP4, TMP4); 391 392 vis_faligndata(TMP0, TMP2, REF_0); 393 394 vis_xor(DST_0, REF_0, TMP0); 395 396 vis_and(TMP0, MASK_fe, TMP0); 397 398 vis_and(TMP4, MASK_7f, TMP4); 399 400 vis_psub16(TMP6, TMP4, TMP4); 401 vis_st64(TMP4, dest[0]); 402 dest += stride; 403 vis_mul8x16(CONST_128, TMP0, TMP0); 404 405 vis_or(DST_0, REF_0, TMP6); 406 407 vis_and(TMP0, MASK_7f, TMP0); 408 409 vis_psub16(TMP6, TMP0, TMP4); 410 vis_st64(TMP4, dest[0]); 411} 412 413static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * ref, 414 const int stride, int height) 415{ 416 unsigned long off = (unsigned long) ref & 0x7; 417 unsigned long off_plus_1 = off + 1; 418 419 ref = vis_alignaddr(ref); 420 421 vis_ld64(ref[0], TMP0); 422 423 vis_ld64_2(ref, 8, TMP2); 424 425 vis_ld64_2(ref, 16, TMP4); 426 427 vis_ld64(constants_fe[0], MASK_fe); 428 429 vis_ld64(constants_7f[0], MASK_7f); 430 vis_faligndata(TMP0, TMP2, REF_0); 431 432 vis_ld64(constants128[0], CONST_128); 433 vis_faligndata(TMP2, TMP4, REF_4); 434 435 if (off != 0x7) { 436 vis_alignaddr_g0((void *)off_plus_1); 437 vis_faligndata(TMP0, TMP2, REF_2); 438 vis_faligndata(TMP2, TMP4, REF_6); 439 } else { 440 vis_src1(TMP2, REF_2); 441 vis_src1(TMP4, REF_6); 442 } 443 444 ref += stride; 445 height = (height >> 1) - 1; 446 447 do { /* 34 cycles */ 448 vis_ld64(ref[0], TMP0); 449 vis_xor(REF_0, REF_2, TMP6); 450 451 vis_ld64_2(ref, 8, TMP2); 452 vis_xor(REF_4, REF_6, TMP8); 453 454 vis_ld64_2(ref, 16, TMP4); 455 vis_and(TMP6, MASK_fe, TMP6); 456 ref += stride; 457 458 vis_ld64(ref[0], TMP14); 459 vis_mul8x16(CONST_128, TMP6, TMP6); 460 vis_and(TMP8, MASK_fe, TMP8); 461 462 vis_ld64_2(ref, 8, TMP16); 463 vis_mul8x16(CONST_128, TMP8, TMP8); 464 vis_or(REF_0, REF_2, TMP10); 465 466 vis_ld64_2(ref, 16, TMP18); 467 ref += stride; 468 vis_or(REF_4, REF_6, TMP12); 469 470 vis_alignaddr_g0((void *)off); 471 472 vis_faligndata(TMP0, TMP2, REF_0); 473 474 vis_faligndata(TMP2, TMP4, REF_4); 475 476 if (off != 0x7) { 477 vis_alignaddr_g0((void *)off_plus_1); 478 vis_faligndata(TMP0, TMP2, REF_2); 479 vis_faligndata(TMP2, TMP4, REF_6); 480 } else { 481 vis_src1(TMP2, REF_2); 482 vis_src1(TMP4, REF_6); 483 } 484 485 vis_and(TMP6, MASK_7f, TMP6); 486 487 vis_and(TMP8, MASK_7f, TMP8); 488 489 vis_psub16(TMP10, TMP6, TMP6); 490 vis_st64(TMP6, dest[0]); 491 492 vis_psub16(TMP12, TMP8, TMP8); 493 vis_st64_2(TMP8, dest, 8); 494 dest += stride; 495 496 vis_xor(REF_0, REF_2, TMP6); 497 498 vis_xor(REF_4, REF_6, TMP8); 499 500 vis_and(TMP6, MASK_fe, TMP6); 501 502 vis_mul8x16(CONST_128, TMP6, TMP6); 503 vis_and(TMP8, MASK_fe, TMP8); 504 505 vis_mul8x16(CONST_128, TMP8, TMP8); 506 vis_or(REF_0, REF_2, TMP10); 507 508 vis_or(REF_4, REF_6, TMP12); 509 510 vis_alignaddr_g0((void *)off); 511 512 vis_faligndata(TMP14, TMP16, REF_0); 513 514 vis_faligndata(TMP16, TMP18, REF_4); 515 516 if (off != 0x7) { 517 vis_alignaddr_g0((void *)off_plus_1); 518 vis_faligndata(TMP14, TMP16, REF_2); 519 vis_faligndata(TMP16, TMP18, REF_6); 520 } else { 521 vis_src1(TMP16, REF_2); 522 vis_src1(TMP18, REF_6); 523 } 524 525 vis_and(TMP6, MASK_7f, TMP6); 526 527 vis_and(TMP8, MASK_7f, TMP8); 528 529 vis_psub16(TMP10, TMP6, TMP6); 530 vis_st64(TMP6, dest[0]); 531 532 vis_psub16(TMP12, TMP8, TMP8); 533 vis_st64_2(TMP8, dest, 8); 534 dest += stride; 535 } while (--height); 536 537 vis_ld64(ref[0], TMP0); 538 vis_xor(REF_0, REF_2, TMP6); 539 540 vis_ld64_2(ref, 8, TMP2); 541 vis_xor(REF_4, REF_6, TMP8); 542 543 vis_ld64_2(ref, 16, TMP4); 544 vis_and(TMP6, MASK_fe, TMP6); 545 546 vis_mul8x16(CONST_128, TMP6, TMP6); 547 vis_and(TMP8, MASK_fe, TMP8); 548 549 vis_mul8x16(CONST_128, TMP8, TMP8); 550 vis_or(REF_0, REF_2, TMP10); 551 552 vis_or(REF_4, REF_6, TMP12); 553 554 vis_alignaddr_g0((void *)off); 555 556 vis_faligndata(TMP0, TMP2, REF_0); 557 558 vis_faligndata(TMP2, TMP4, REF_4); 559 560 if (off != 0x7) { 561 vis_alignaddr_g0((void *)off_plus_1); 562 vis_faligndata(TMP0, TMP2, REF_2); 563 vis_faligndata(TMP2, TMP4, REF_6); 564 } else { 565 vis_src1(TMP2, REF_2); 566 vis_src1(TMP4, REF_6); 567 } 568 569 vis_and(TMP6, MASK_7f, TMP6); 570 571 vis_and(TMP8, MASK_7f, TMP8); 572 573 vis_psub16(TMP10, TMP6, TMP6); 574 vis_st64(TMP6, dest[0]); 575 576 vis_psub16(TMP12, TMP8, TMP8); 577 vis_st64_2(TMP8, dest, 8); 578 dest += stride; 579 580 vis_xor(REF_0, REF_2, TMP6); 581 582 vis_xor(REF_4, REF_6, TMP8); 583 584 vis_and(TMP6, MASK_fe, TMP6); 585 586 vis_mul8x16(CONST_128, TMP6, TMP6); 587 vis_and(TMP8, MASK_fe, TMP8); 588 589 vis_mul8x16(CONST_128, TMP8, TMP8); 590 vis_or(REF_0, REF_2, TMP10); 591 592 vis_or(REF_4, REF_6, TMP12); 593 594 vis_and(TMP6, MASK_7f, TMP6); 595 596 vis_and(TMP8, MASK_7f, TMP8); 597 598 vis_psub16(TMP10, TMP6, TMP6); 599 vis_st64(TMP6, dest[0]); 600 601 vis_psub16(TMP12, TMP8, TMP8); 602 vis_st64_2(TMP8, dest, 8); 603} 604 605static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * ref, 606 const int stride, int height) 607{ 608 unsigned long off = (unsigned long) ref & 0x7; 609 unsigned long off_plus_1 = off + 1; 610 611 ref = vis_alignaddr(ref); 612 613 vis_ld64(ref[0], TMP0); 614 615 vis_ld64(ref[8], TMP2); 616 617 vis_ld64(constants_fe[0], MASK_fe); 618 619 vis_ld64(constants_7f[0], MASK_7f); 620 621 vis_ld64(constants128[0], CONST_128); 622 vis_faligndata(TMP0, TMP2, REF_0); 623 624 if (off != 0x7) { 625 vis_alignaddr_g0((void *)off_plus_1); 626 vis_faligndata(TMP0, TMP2, REF_2); 627 } else { 628 vis_src1(TMP2, REF_2); 629 } 630 631 ref += stride; 632 height = (height >> 1) - 1; 633 634 do { /* 20 cycles */ 635 vis_ld64(ref[0], TMP0); 636 vis_xor(REF_0, REF_2, TMP4); 637 638 vis_ld64_2(ref, 8, TMP2); 639 vis_and(TMP4, MASK_fe, TMP4); 640 ref += stride; 641 642 vis_ld64(ref[0], TMP8); 643 vis_or(REF_0, REF_2, TMP6); 644 vis_mul8x16(CONST_128, TMP4, TMP4); 645 646 vis_alignaddr_g0((void *)off); 647 648 vis_ld64_2(ref, 8, TMP10); 649 ref += stride; 650 vis_faligndata(TMP0, TMP2, REF_0); 651 652 if (off != 0x7) { 653 vis_alignaddr_g0((void *)off_plus_1); 654 vis_faligndata(TMP0, TMP2, REF_2); 655 } else { 656 vis_src1(TMP2, REF_2); 657 } 658 659 vis_and(TMP4, MASK_7f, TMP4); 660 661 vis_psub16(TMP6, TMP4, DST_0); 662 vis_st64(DST_0, dest[0]); 663 dest += stride; 664 665 vis_xor(REF_0, REF_2, TMP12); 666 667 vis_and(TMP12, MASK_fe, TMP12); 668 669 vis_or(REF_0, REF_2, TMP14); 670 vis_mul8x16(CONST_128, TMP12, TMP12); 671 672 vis_alignaddr_g0((void *)off); 673 vis_faligndata(TMP8, TMP10, REF_0); 674 if (off != 0x7) { 675 vis_alignaddr_g0((void *)off_plus_1); 676 vis_faligndata(TMP8, TMP10, REF_2); 677 } else { 678 vis_src1(TMP10, REF_2); 679 } 680 681 vis_and(TMP12, MASK_7f, TMP12); 682 683 vis_psub16(TMP14, TMP12, DST_0); 684 vis_st64(DST_0, dest[0]); 685 dest += stride; 686 } while (--height); 687 688 vis_ld64(ref[0], TMP0); 689 vis_xor(REF_0, REF_2, TMP4); 690 691 vis_ld64_2(ref, 8, TMP2); 692 vis_and(TMP4, MASK_fe, TMP4); 693 694 vis_or(REF_0, REF_2, TMP6); 695 vis_mul8x16(CONST_128, TMP4, TMP4); 696 697 vis_alignaddr_g0((void *)off); 698 699 vis_faligndata(TMP0, TMP2, REF_0); 700 701 if (off != 0x7) { 702 vis_alignaddr_g0((void *)off_plus_1); 703 vis_faligndata(TMP0, TMP2, REF_2); 704 } else { 705 vis_src1(TMP2, REF_2); 706 } 707 708 vis_and(TMP4, MASK_7f, TMP4); 709 710 vis_psub16(TMP6, TMP4, DST_0); 711 vis_st64(DST_0, dest[0]); 712 dest += stride; 713 714 vis_xor(REF_0, REF_2, TMP12); 715 716 vis_and(TMP12, MASK_fe, TMP12); 717 718 vis_or(REF_0, REF_2, TMP14); 719 vis_mul8x16(CONST_128, TMP12, TMP12); 720 721 vis_and(TMP12, MASK_7f, TMP12); 722 723 vis_psub16(TMP14, TMP12, DST_0); 724 vis_st64(DST_0, dest[0]); 725 dest += stride; 726} 727 728static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * ref, 729 const int stride, int height) 730{ 731 unsigned long off = (unsigned long) ref & 0x7; 732 unsigned long off_plus_1 = off + 1; 733 734 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 735 736 vis_ld64(constants3[0], CONST_3); 737 vis_fzero(ZERO); 738 vis_ld64(constants256_512[0], CONST_256); 739 740 ref = vis_alignaddr(ref); 741 do { /* 26 cycles */ 742 vis_ld64(ref[0], TMP0); 743 744 vis_ld64(ref[8], TMP2); 745 746 vis_alignaddr_g0((void *)off); 747 748 vis_ld64(ref[16], TMP4); 749 750 vis_ld64(dest[0], DST_0); 751 vis_faligndata(TMP0, TMP2, REF_0); 752 753 vis_ld64(dest[8], DST_2); 754 vis_faligndata(TMP2, TMP4, REF_4); 755 756 if (off != 0x7) { 757 vis_alignaddr_g0((void *)off_plus_1); 758 vis_faligndata(TMP0, TMP2, REF_2); 759 vis_faligndata(TMP2, TMP4, REF_6); 760 } else { 761 vis_src1(TMP2, REF_2); 762 vis_src1(TMP4, REF_6); 763 } 764 765 vis_mul8x16au(REF_0, CONST_256, TMP0); 766 767 vis_pmerge(ZERO, REF_2, TMP4); 768 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 769 770 vis_pmerge(ZERO, REF_2_1, TMP6); 771 772 vis_padd16(TMP0, TMP4, TMP0); 773 774 vis_mul8x16al(DST_0, CONST_512, TMP4); 775 vis_padd16(TMP2, TMP6, TMP2); 776 777 vis_mul8x16al(DST_1, CONST_512, TMP6); 778 779 vis_mul8x16au(REF_6, CONST_256, TMP12); 780 781 vis_padd16(TMP0, TMP4, TMP0); 782 vis_mul8x16au(REF_6_1, CONST_256, TMP14); 783 784 vis_padd16(TMP2, TMP6, TMP2); 785 vis_mul8x16au(REF_4, CONST_256, TMP16); 786 787 vis_padd16(TMP0, CONST_3, TMP8); 788 vis_mul8x16au(REF_4_1, CONST_256, TMP18); 789 790 vis_padd16(TMP2, CONST_3, TMP10); 791 vis_pack16(TMP8, DST_0); 792 793 vis_pack16(TMP10, DST_1); 794 vis_padd16(TMP16, TMP12, TMP0); 795 796 vis_st64(DST_0, dest[0]); 797 vis_mul8x16al(DST_2, CONST_512, TMP4); 798 vis_padd16(TMP18, TMP14, TMP2); 799 800 vis_mul8x16al(DST_3, CONST_512, TMP6); 801 vis_padd16(TMP0, CONST_3, TMP0); 802 803 vis_padd16(TMP2, CONST_3, TMP2); 804 805 vis_padd16(TMP0, TMP4, TMP0); 806 807 vis_padd16(TMP2, TMP6, TMP2); 808 vis_pack16(TMP0, DST_2); 809 810 vis_pack16(TMP2, DST_3); 811 vis_st64(DST_2, dest[8]); 812 813 ref += stride; 814 dest += stride; 815 } while (--height); 816} 817 818static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * ref, 819 const int stride, int height) 820{ 821 unsigned long off = (unsigned long) ref & 0x7; 822 unsigned long off_plus_1 = off + 1; 823 int stride_times_2 = stride << 1; 824 825 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 826 827 vis_ld64(constants3[0], CONST_3); 828 vis_fzero(ZERO); 829 vis_ld64(constants256_512[0], CONST_256); 830 831 ref = vis_alignaddr(ref); 832 height >>= 2; 833 do { /* 47 cycles */ 834 vis_ld64(ref[0], TMP0); 835 836 vis_ld64_2(ref, 8, TMP2); 837 ref += stride; 838 839 vis_alignaddr_g0((void *)off); 840 841 vis_ld64(ref[0], TMP4); 842 vis_faligndata(TMP0, TMP2, REF_0); 843 844 vis_ld64_2(ref, 8, TMP6); 845 ref += stride; 846 847 vis_ld64(ref[0], TMP8); 848 849 vis_ld64_2(ref, 8, TMP10); 850 ref += stride; 851 vis_faligndata(TMP4, TMP6, REF_4); 852 853 vis_ld64(ref[0], TMP12); 854 855 vis_ld64_2(ref, 8, TMP14); 856 ref += stride; 857 vis_faligndata(TMP8, TMP10, REF_S0); 858 859 vis_faligndata(TMP12, TMP14, REF_S4); 860 861 if (off != 0x7) { 862 vis_alignaddr_g0((void *)off_plus_1); 863 864 vis_ld64(dest[0], DST_0); 865 vis_faligndata(TMP0, TMP2, REF_2); 866 867 vis_ld64_2(dest, stride, DST_2); 868 vis_faligndata(TMP4, TMP6, REF_6); 869 870 vis_faligndata(TMP8, TMP10, REF_S2); 871 872 vis_faligndata(TMP12, TMP14, REF_S6); 873 } else { 874 vis_ld64(dest[0], DST_0); 875 vis_src1(TMP2, REF_2); 876 877 vis_ld64_2(dest, stride, DST_2); 878 vis_src1(TMP6, REF_6); 879 880 vis_src1(TMP10, REF_S2); 881 882 vis_src1(TMP14, REF_S6); 883 } 884 885 vis_pmerge(ZERO, REF_0, TMP0); 886 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 887 888 vis_pmerge(ZERO, REF_2, TMP4); 889 vis_mul8x16au(REF_2_1, CONST_256, TMP6); 890 891 vis_padd16(TMP0, CONST_3, TMP0); 892 vis_mul8x16al(DST_0, CONST_512, TMP16); 893 894 vis_padd16(TMP2, CONST_3, TMP2); 895 vis_mul8x16al(DST_1, CONST_512, TMP18); 896 897 vis_padd16(TMP0, TMP4, TMP0); 898 vis_mul8x16au(REF_4, CONST_256, TMP8); 899 900 vis_padd16(TMP2, TMP6, TMP2); 901 vis_mul8x16au(REF_4_1, CONST_256, TMP10); 902 903 vis_padd16(TMP0, TMP16, TMP0); 904 vis_mul8x16au(REF_6, CONST_256, TMP12); 905 906 vis_padd16(TMP2, TMP18, TMP2); 907 vis_mul8x16au(REF_6_1, CONST_256, TMP14); 908 909 vis_padd16(TMP8, CONST_3, TMP8); 910 vis_mul8x16al(DST_2, CONST_512, TMP16); 911 912 vis_padd16(TMP8, TMP12, TMP8); 913 vis_mul8x16al(DST_3, CONST_512, TMP18); 914 915 vis_padd16(TMP10, TMP14, TMP10); 916 vis_pack16(TMP0, DST_0); 917 918 vis_pack16(TMP2, DST_1); 919 vis_st64(DST_0, dest[0]); 920 dest += stride; 921 vis_padd16(TMP10, CONST_3, TMP10); 922 923 vis_ld64_2(dest, stride, DST_0); 924 vis_padd16(TMP8, TMP16, TMP8); 925 926 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/); 927 vis_padd16(TMP10, TMP18, TMP10); 928 vis_pack16(TMP8, DST_2); 929 930 vis_pack16(TMP10, DST_3); 931 vis_st64(DST_2, dest[0]); 932 dest += stride; 933 934 vis_mul8x16au(REF_S0_1, CONST_256, TMP2); 935 vis_pmerge(ZERO, REF_S0, TMP0); 936 937 vis_pmerge(ZERO, REF_S2, TMP24); 938 vis_mul8x16au(REF_S2_1, CONST_256, TMP6); 939 940 vis_padd16(TMP0, CONST_3, TMP0); 941 vis_mul8x16au(REF_S4, CONST_256, TMP8); 942 943 vis_padd16(TMP2, CONST_3, TMP2); 944 vis_mul8x16au(REF_S4_1, CONST_256, TMP10); 945 946 vis_padd16(TMP0, TMP24, TMP0); 947 vis_mul8x16au(REF_S6, CONST_256, TMP12); 948 949 vis_padd16(TMP2, TMP6, TMP2); 950 vis_mul8x16au(REF_S6_1, CONST_256, TMP14); 951 952 vis_padd16(TMP8, CONST_3, TMP8); 953 vis_mul8x16al(DST_0, CONST_512, TMP16); 954 955 vis_padd16(TMP10, CONST_3, TMP10); 956 vis_mul8x16al(DST_1, CONST_512, TMP18); 957 958 vis_padd16(TMP8, TMP12, TMP8); 959 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20); 960 961 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22); 962 vis_padd16(TMP0, TMP16, TMP0); 963 964 vis_padd16(TMP2, TMP18, TMP2); 965 vis_pack16(TMP0, DST_0); 966 967 vis_padd16(TMP10, TMP14, TMP10); 968 vis_pack16(TMP2, DST_1); 969 vis_st64(DST_0, dest[0]); 970 dest += stride; 971 972 vis_padd16(TMP8, TMP20, TMP8); 973 974 vis_padd16(TMP10, TMP22, TMP10); 975 vis_pack16(TMP8, DST_2); 976 977 vis_pack16(TMP10, DST_3); 978 vis_st64(DST_2, dest[0]); 979 dest += stride; 980 } while (--height); 981} 982 983static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * ref, 984 const int stride, int height) 985{ 986 ref = vis_alignaddr(ref); 987 vis_ld64(ref[0], TMP0); 988 989 vis_ld64_2(ref, 8, TMP2); 990 991 vis_ld64_2(ref, 16, TMP4); 992 ref += stride; 993 994 vis_ld64(ref[0], TMP6); 995 vis_faligndata(TMP0, TMP2, REF_0); 996 997 vis_ld64_2(ref, 8, TMP8); 998 vis_faligndata(TMP2, TMP4, REF_4); 999 1000 vis_ld64_2(ref, 16, TMP10); 1001 ref += stride; 1002 1003 vis_ld64(constants_fe[0], MASK_fe); 1004 vis_faligndata(TMP6, TMP8, REF_2); 1005 1006 vis_ld64(constants_7f[0], MASK_7f); 1007 vis_faligndata(TMP8, TMP10, REF_6); 1008 1009 vis_ld64(constants128[0], CONST_128); 1010 height = (height >> 1) - 1; 1011 do { /* 24 cycles */ 1012 vis_ld64(ref[0], TMP0); 1013 vis_xor(REF_0, REF_2, TMP12); 1014 1015 vis_ld64_2(ref, 8, TMP2); 1016 vis_xor(REF_4, REF_6, TMP16); 1017 1018 vis_ld64_2(ref, 16, TMP4); 1019 ref += stride; 1020 vis_or(REF_0, REF_2, TMP14); 1021 1022 vis_ld64(ref[0], TMP6); 1023 vis_or(REF_4, REF_6, TMP18); 1024 1025 vis_ld64_2(ref, 8, TMP8); 1026 vis_faligndata(TMP0, TMP2, REF_0); 1027 1028 vis_ld64_2(ref, 16, TMP10); 1029 ref += stride; 1030 vis_faligndata(TMP2, TMP4, REF_4); 1031 1032 vis_and(TMP12, MASK_fe, TMP12); 1033 1034 vis_and(TMP16, MASK_fe, TMP16); 1035 vis_mul8x16(CONST_128, TMP12, TMP12); 1036 1037 vis_mul8x16(CONST_128, TMP16, TMP16); 1038 vis_xor(REF_0, REF_2, TMP0); 1039 1040 vis_xor(REF_4, REF_6, TMP2); 1041 1042 vis_or(REF_0, REF_2, TMP20); 1043 1044 vis_and(TMP12, MASK_7f, TMP12); 1045 1046 vis_and(TMP16, MASK_7f, TMP16); 1047 1048 vis_psub16(TMP14, TMP12, TMP12); 1049 vis_st64(TMP12, dest[0]); 1050 1051 vis_psub16(TMP18, TMP16, TMP16); 1052 vis_st64_2(TMP16, dest, 8); 1053 dest += stride; 1054 1055 vis_or(REF_4, REF_6, TMP18); 1056 1057 vis_and(TMP0, MASK_fe, TMP0); 1058 1059 vis_and(TMP2, MASK_fe, TMP2); 1060 vis_mul8x16(CONST_128, TMP0, TMP0); 1061 1062 vis_faligndata(TMP6, TMP8, REF_2); 1063 vis_mul8x16(CONST_128, TMP2, TMP2); 1064 1065 vis_faligndata(TMP8, TMP10, REF_6); 1066 1067 vis_and(TMP0, MASK_7f, TMP0); 1068 1069 vis_and(TMP2, MASK_7f, TMP2); 1070 1071 vis_psub16(TMP20, TMP0, TMP0); 1072 vis_st64(TMP0, dest[0]); 1073 1074 vis_psub16(TMP18, TMP2, TMP2); 1075 vis_st64_2(TMP2, dest, 8); 1076 dest += stride; 1077 } while (--height); 1078 1079 vis_ld64(ref[0], TMP0); 1080 vis_xor(REF_0, REF_2, TMP12); 1081 1082 vis_ld64_2(ref, 8, TMP2); 1083 vis_xor(REF_4, REF_6, TMP16); 1084 1085 vis_ld64_2(ref, 16, TMP4); 1086 vis_or(REF_0, REF_2, TMP14); 1087 1088 vis_or(REF_4, REF_6, TMP18); 1089 1090 vis_faligndata(TMP0, TMP2, REF_0); 1091 1092 vis_faligndata(TMP2, TMP4, REF_4); 1093 1094 vis_and(TMP12, MASK_fe, TMP12); 1095 1096 vis_and(TMP16, MASK_fe, TMP16); 1097 vis_mul8x16(CONST_128, TMP12, TMP12); 1098 1099 vis_mul8x16(CONST_128, TMP16, TMP16); 1100 vis_xor(REF_0, REF_2, TMP0); 1101 1102 vis_xor(REF_4, REF_6, TMP2); 1103 1104 vis_or(REF_0, REF_2, TMP20); 1105 1106 vis_and(TMP12, MASK_7f, TMP12); 1107 1108 vis_and(TMP16, MASK_7f, TMP16); 1109 1110 vis_psub16(TMP14, TMP12, TMP12); 1111 vis_st64(TMP12, dest[0]); 1112 1113 vis_psub16(TMP18, TMP16, TMP16); 1114 vis_st64_2(TMP16, dest, 8); 1115 dest += stride; 1116 1117 vis_or(REF_4, REF_6, TMP18); 1118 1119 vis_and(TMP0, MASK_fe, TMP0); 1120 1121 vis_and(TMP2, MASK_fe, TMP2); 1122 vis_mul8x16(CONST_128, TMP0, TMP0); 1123 1124 vis_mul8x16(CONST_128, TMP2, TMP2); 1125 1126 vis_and(TMP0, MASK_7f, TMP0); 1127 1128 vis_and(TMP2, MASK_7f, TMP2); 1129 1130 vis_psub16(TMP20, TMP0, TMP0); 1131 vis_st64(TMP0, dest[0]); 1132 1133 vis_psub16(TMP18, TMP2, TMP2); 1134 vis_st64_2(TMP2, dest, 8); 1135} 1136 1137static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * ref, 1138 const int stride, int height) 1139{ 1140 ref = vis_alignaddr(ref); 1141 vis_ld64(ref[0], TMP0); 1142 1143 vis_ld64_2(ref, 8, TMP2); 1144 ref += stride; 1145 1146 vis_ld64(ref[0], TMP4); 1147 1148 vis_ld64_2(ref, 8, TMP6); 1149 ref += stride; 1150 1151 vis_ld64(constants_fe[0], MASK_fe); 1152 vis_faligndata(TMP0, TMP2, REF_0); 1153 1154 vis_ld64(constants_7f[0], MASK_7f); 1155 vis_faligndata(TMP4, TMP6, REF_2); 1156 1157 vis_ld64(constants128[0], CONST_128); 1158 height = (height >> 1) - 1; 1159 do { /* 12 cycles */ 1160 vis_ld64(ref[0], TMP0); 1161 vis_xor(REF_0, REF_2, TMP4); 1162 1163 vis_ld64_2(ref, 8, TMP2); 1164 ref += stride; 1165 vis_and(TMP4, MASK_fe, TMP4); 1166 1167 vis_or(REF_0, REF_2, TMP6); 1168 vis_mul8x16(CONST_128, TMP4, TMP4); 1169 1170 vis_faligndata(TMP0, TMP2, REF_0); 1171 vis_ld64(ref[0], TMP0); 1172 1173 vis_ld64_2(ref, 8, TMP2); 1174 ref += stride; 1175 vis_xor(REF_0, REF_2, TMP12); 1176 1177 vis_and(TMP4, MASK_7f, TMP4); 1178 1179 vis_and(TMP12, MASK_fe, TMP12); 1180 1181 vis_mul8x16(CONST_128, TMP12, TMP12); 1182 vis_or(REF_0, REF_2, TMP14); 1183 1184 vis_psub16(TMP6, TMP4, DST_0); 1185 vis_st64(DST_0, dest[0]); 1186 dest += stride; 1187 1188 vis_faligndata(TMP0, TMP2, REF_2); 1189 1190 vis_and(TMP12, MASK_7f, TMP12); 1191 1192 vis_psub16(TMP14, TMP12, DST_0); 1193 vis_st64(DST_0, dest[0]); 1194 dest += stride; 1195 } while (--height); 1196 1197 vis_ld64(ref[0], TMP0); 1198 vis_xor(REF_0, REF_2, TMP4); 1199 1200 vis_ld64_2(ref, 8, TMP2); 1201 vis_and(TMP4, MASK_fe, TMP4); 1202 1203 vis_or(REF_0, REF_2, TMP6); 1204 vis_mul8x16(CONST_128, TMP4, TMP4); 1205 1206 vis_faligndata(TMP0, TMP2, REF_0); 1207 1208 vis_xor(REF_0, REF_2, TMP12); 1209 1210 vis_and(TMP4, MASK_7f, TMP4); 1211 1212 vis_and(TMP12, MASK_fe, TMP12); 1213 1214 vis_mul8x16(CONST_128, TMP12, TMP12); 1215 vis_or(REF_0, REF_2, TMP14); 1216 1217 vis_psub16(TMP6, TMP4, DST_0); 1218 vis_st64(DST_0, dest[0]); 1219 dest += stride; 1220 1221 vis_and(TMP12, MASK_7f, TMP12); 1222 1223 vis_psub16(TMP14, TMP12, DST_0); 1224 vis_st64(DST_0, dest[0]); 1225} 1226 1227static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * ref, 1228 const int stride, int height) 1229{ 1230 int stride_8 = stride + 8; 1231 int stride_16 = stride + 16; 1232 1233 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 1234 1235 ref = vis_alignaddr(ref); 1236 1237 vis_ld64(ref[ 0], TMP0); 1238 vis_fzero(ZERO); 1239 1240 vis_ld64(ref[ 8], TMP2); 1241 1242 vis_ld64(ref[16], TMP4); 1243 1244 vis_ld64(constants3[0], CONST_3); 1245 vis_faligndata(TMP0, TMP2, REF_2); 1246 1247 vis_ld64(constants256_512[0], CONST_256); 1248 vis_faligndata(TMP2, TMP4, REF_6); 1249 height >>= 1; 1250 1251 do { /* 31 cycles */ 1252 vis_ld64_2(ref, stride, TMP0); 1253 vis_pmerge(ZERO, REF_2, TMP12); 1254 vis_mul8x16au(REF_2_1, CONST_256, TMP14); 1255 1256 vis_ld64_2(ref, stride_8, TMP2); 1257 vis_pmerge(ZERO, REF_6, TMP16); 1258 vis_mul8x16au(REF_6_1, CONST_256, TMP18); 1259 1260 vis_ld64_2(ref, stride_16, TMP4); 1261 ref += stride; 1262 1263 vis_ld64(dest[0], DST_0); 1264 vis_faligndata(TMP0, TMP2, REF_0); 1265 1266 vis_ld64_2(dest, 8, DST_2); 1267 vis_faligndata(TMP2, TMP4, REF_4); 1268 1269 vis_ld64_2(ref, stride, TMP6); 1270 vis_pmerge(ZERO, REF_0, TMP0); 1271 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 1272 1273 vis_ld64_2(ref, stride_8, TMP8); 1274 vis_pmerge(ZERO, REF_4, TMP4); 1275 1276 vis_ld64_2(ref, stride_16, TMP10); 1277 ref += stride; 1278 1279 vis_ld64_2(dest, stride, REF_S0/*DST_4*/); 1280 vis_faligndata(TMP6, TMP8, REF_2); 1281 vis_mul8x16au(REF_4_1, CONST_256, TMP6); 1282 1283 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/); 1284 vis_faligndata(TMP8, TMP10, REF_6); 1285 vis_mul8x16al(DST_0, CONST_512, TMP20); 1286 1287 vis_padd16(TMP0, CONST_3, TMP0); 1288 vis_mul8x16al(DST_1, CONST_512, TMP22); 1289 1290 vis_padd16(TMP2, CONST_3, TMP2); 1291 vis_mul8x16al(DST_2, CONST_512, TMP24); 1292 1293 vis_padd16(TMP4, CONST_3, TMP4); 1294 vis_mul8x16al(DST_3, CONST_512, TMP26); 1295 1296 vis_padd16(TMP6, CONST_3, TMP6); 1297 1298 vis_padd16(TMP12, TMP20, TMP12); 1299 vis_mul8x16al(REF_S0, CONST_512, TMP20); 1300 1301 vis_padd16(TMP14, TMP22, TMP14); 1302 vis_mul8x16al(REF_S0_1, CONST_512, TMP22); 1303 1304 vis_padd16(TMP16, TMP24, TMP16); 1305 vis_mul8x16al(REF_S2, CONST_512, TMP24); 1306 1307 vis_padd16(TMP18, TMP26, TMP18); 1308 vis_mul8x16al(REF_S2_1, CONST_512, TMP26); 1309 1310 vis_padd16(TMP12, TMP0, TMP12); 1311 vis_mul8x16au(REF_2, CONST_256, TMP28); 1312 1313 vis_padd16(TMP14, TMP2, TMP14); 1314 vis_mul8x16au(REF_2_1, CONST_256, TMP30); 1315 1316 vis_padd16(TMP16, TMP4, TMP16); 1317 vis_mul8x16au(REF_6, CONST_256, REF_S4); 1318 1319 vis_padd16(TMP18, TMP6, TMP18); 1320 vis_mul8x16au(REF_6_1, CONST_256, REF_S6); 1321 1322 vis_pack16(TMP12, DST_0); 1323 vis_padd16(TMP28, TMP0, TMP12); 1324 1325 vis_pack16(TMP14, DST_1); 1326 vis_st64(DST_0, dest[0]); 1327 vis_padd16(TMP30, TMP2, TMP14); 1328 1329 vis_pack16(TMP16, DST_2); 1330 vis_padd16(REF_S4, TMP4, TMP16); 1331 1332 vis_pack16(TMP18, DST_3); 1333 vis_st64_2(DST_2, dest, 8); 1334 dest += stride; 1335 vis_padd16(REF_S6, TMP6, TMP18); 1336 1337 vis_padd16(TMP12, TMP20, TMP12); 1338 1339 vis_padd16(TMP14, TMP22, TMP14); 1340 vis_pack16(TMP12, DST_0); 1341 1342 vis_padd16(TMP16, TMP24, TMP16); 1343 vis_pack16(TMP14, DST_1); 1344 vis_st64(DST_0, dest[0]); 1345 1346 vis_padd16(TMP18, TMP26, TMP18); 1347 vis_pack16(TMP16, DST_2); 1348 1349 vis_pack16(TMP18, DST_3); 1350 vis_st64_2(DST_2, dest, 8); 1351 dest += stride; 1352 } while (--height); 1353} 1354 1355static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * ref, 1356 const int stride, int height) 1357{ 1358 int stride_8 = stride + 8; 1359 1360 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 1361 1362 ref = vis_alignaddr(ref); 1363 1364 vis_ld64(ref[ 0], TMP0); 1365 vis_fzero(ZERO); 1366 1367 vis_ld64(ref[ 8], TMP2); 1368 1369 vis_ld64(constants3[0], CONST_3); 1370 vis_faligndata(TMP0, TMP2, REF_2); 1371 1372 vis_ld64(constants256_512[0], CONST_256); 1373 1374 height >>= 1; 1375 do { /* 20 cycles */ 1376 vis_ld64_2(ref, stride, TMP0); 1377 vis_pmerge(ZERO, REF_2, TMP8); 1378 vis_mul8x16au(REF_2_1, CONST_256, TMP10); 1379 1380 vis_ld64_2(ref, stride_8, TMP2); 1381 ref += stride; 1382 1383 vis_ld64(dest[0], DST_0); 1384 1385 vis_ld64_2(dest, stride, DST_2); 1386 vis_faligndata(TMP0, TMP2, REF_0); 1387 1388 vis_ld64_2(ref, stride, TMP4); 1389 vis_mul8x16al(DST_0, CONST_512, TMP16); 1390 vis_pmerge(ZERO, REF_0, TMP12); 1391 1392 vis_ld64_2(ref, stride_8, TMP6); 1393 ref += stride; 1394 vis_mul8x16al(DST_1, CONST_512, TMP18); 1395 vis_pmerge(ZERO, REF_0_1, TMP14); 1396 1397 vis_padd16(TMP12, CONST_3, TMP12); 1398 vis_mul8x16al(DST_2, CONST_512, TMP24); 1399 1400 vis_padd16(TMP14, CONST_3, TMP14); 1401 vis_mul8x16al(DST_3, CONST_512, TMP26); 1402 1403 vis_faligndata(TMP4, TMP6, REF_2); 1404 1405 vis_padd16(TMP8, TMP12, TMP8); 1406 1407 vis_padd16(TMP10, TMP14, TMP10); 1408 vis_mul8x16au(REF_2, CONST_256, TMP20); 1409 1410 vis_padd16(TMP8, TMP16, TMP0); 1411 vis_mul8x16au(REF_2_1, CONST_256, TMP22); 1412 1413 vis_padd16(TMP10, TMP18, TMP2); 1414 vis_pack16(TMP0, DST_0); 1415 1416 vis_pack16(TMP2, DST_1); 1417 vis_st64(DST_0, dest[0]); 1418 dest += stride; 1419 vis_padd16(TMP12, TMP20, TMP12); 1420 1421 vis_padd16(TMP14, TMP22, TMP14); 1422 1423 vis_padd16(TMP12, TMP24, TMP0); 1424 1425 vis_padd16(TMP14, TMP26, TMP2); 1426 vis_pack16(TMP0, DST_2); 1427 1428 vis_pack16(TMP2, DST_3); 1429 vis_st64(DST_2, dest[0]); 1430 dest += stride; 1431 } while (--height); 1432} 1433 1434static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * ref, 1435 const int stride, int height) 1436{ 1437 unsigned long off = (unsigned long) ref & 0x7; 1438 unsigned long off_plus_1 = off + 1; 1439 int stride_8 = stride + 8; 1440 int stride_16 = stride + 16; 1441 1442 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 1443 1444 ref = vis_alignaddr(ref); 1445 1446 vis_ld64(ref[ 0], TMP0); 1447 vis_fzero(ZERO); 1448 1449 vis_ld64(ref[ 8], TMP2); 1450 1451 vis_ld64(ref[16], TMP4); 1452 1453 vis_ld64(constants2[0], CONST_2); 1454 vis_faligndata(TMP0, TMP2, REF_S0); 1455 1456 vis_ld64(constants256_512[0], CONST_256); 1457 vis_faligndata(TMP2, TMP4, REF_S4); 1458 1459 if (off != 0x7) { 1460 vis_alignaddr_g0((void *)off_plus_1); 1461 vis_faligndata(TMP0, TMP2, REF_S2); 1462 vis_faligndata(TMP2, TMP4, REF_S6); 1463 } else { 1464 vis_src1(TMP2, REF_S2); 1465 vis_src1(TMP4, REF_S6); 1466 } 1467 1468 height >>= 1; 1469 do { 1470 vis_ld64_2(ref, stride, TMP0); 1471 vis_mul8x16au(REF_S0, CONST_256, TMP12); 1472 vis_pmerge(ZERO, REF_S0_1, TMP14); 1473 1474 vis_alignaddr_g0((void *)off); 1475 1476 vis_ld64_2(ref, stride_8, TMP2); 1477 vis_mul8x16au(REF_S2, CONST_256, TMP16); 1478 vis_pmerge(ZERO, REF_S2_1, TMP18); 1479 1480 vis_ld64_2(ref, stride_16, TMP4); 1481 ref += stride; 1482 vis_mul8x16au(REF_S4, CONST_256, TMP20); 1483 vis_pmerge(ZERO, REF_S4_1, TMP22); 1484 1485 vis_ld64_2(ref, stride, TMP6); 1486 vis_mul8x16au(REF_S6, CONST_256, TMP24); 1487 vis_pmerge(ZERO, REF_S6_1, TMP26); 1488 1489 vis_ld64_2(ref, stride_8, TMP8); 1490 vis_faligndata(TMP0, TMP2, REF_0); 1491 1492 vis_ld64_2(ref, stride_16, TMP10); 1493 ref += stride; 1494 vis_faligndata(TMP2, TMP4, REF_4); 1495 1496 vis_faligndata(TMP6, TMP8, REF_S0); 1497 1498 vis_faligndata(TMP8, TMP10, REF_S4); 1499 1500 if (off != 0x7) { 1501 vis_alignaddr_g0((void *)off_plus_1); 1502 vis_faligndata(TMP0, TMP2, REF_2); 1503 vis_faligndata(TMP2, TMP4, REF_6); 1504 vis_faligndata(TMP6, TMP8, REF_S2); 1505 vis_faligndata(TMP8, TMP10, REF_S6); 1506 } else { 1507 vis_src1(TMP2, REF_2); 1508 vis_src1(TMP4, REF_6); 1509 vis_src1(TMP8, REF_S2); 1510 vis_src1(TMP10, REF_S6); 1511 } 1512 1513 vis_mul8x16au(REF_0, CONST_256, TMP0); 1514 vis_pmerge(ZERO, REF_0_1, TMP2); 1515 1516 vis_mul8x16au(REF_2, CONST_256, TMP4); 1517 vis_pmerge(ZERO, REF_2_1, TMP6); 1518 1519 vis_padd16(TMP0, CONST_2, TMP8); 1520 vis_mul8x16au(REF_4, CONST_256, TMP0); 1521 1522 vis_padd16(TMP2, CONST_2, TMP10); 1523 vis_mul8x16au(REF_4_1, CONST_256, TMP2); 1524 1525 vis_padd16(TMP8, TMP4, TMP8); 1526 vis_mul8x16au(REF_6, CONST_256, TMP4); 1527 1528 vis_padd16(TMP10, TMP6, TMP10); 1529 vis_mul8x16au(REF_6_1, CONST_256, TMP6); 1530 1531 vis_padd16(TMP12, TMP8, TMP12); 1532 1533 vis_padd16(TMP14, TMP10, TMP14); 1534 1535 vis_padd16(TMP12, TMP16, TMP12); 1536 1537 vis_padd16(TMP14, TMP18, TMP14); 1538 vis_pack16(TMP12, DST_0); 1539 1540 vis_pack16(TMP14, DST_1); 1541 vis_st64(DST_0, dest[0]); 1542 vis_padd16(TMP0, CONST_2, TMP12); 1543 1544 vis_mul8x16au(REF_S0, CONST_256, TMP0); 1545 vis_padd16(TMP2, CONST_2, TMP14); 1546 1547 vis_mul8x16au(REF_S0_1, CONST_256, TMP2); 1548 vis_padd16(TMP12, TMP4, TMP12); 1549 1550 vis_mul8x16au(REF_S2, CONST_256, TMP4); 1551 vis_padd16(TMP14, TMP6, TMP14); 1552 1553 vis_mul8x16au(REF_S2_1, CONST_256, TMP6); 1554 vis_padd16(TMP20, TMP12, TMP20); 1555 1556 vis_padd16(TMP22, TMP14, TMP22); 1557 1558 vis_padd16(TMP20, TMP24, TMP20); 1559 1560 vis_padd16(TMP22, TMP26, TMP22); 1561 vis_pack16(TMP20, DST_2); 1562 1563 vis_pack16(TMP22, DST_3); 1564 vis_st64_2(DST_2, dest, 8); 1565 dest += stride; 1566 vis_padd16(TMP0, TMP4, TMP24); 1567 1568 vis_mul8x16au(REF_S4, CONST_256, TMP0); 1569 vis_padd16(TMP2, TMP6, TMP26); 1570 1571 vis_mul8x16au(REF_S4_1, CONST_256, TMP2); 1572 vis_padd16(TMP24, TMP8, TMP24); 1573 1574 vis_padd16(TMP26, TMP10, TMP26); 1575 vis_pack16(TMP24, DST_0); 1576 1577 vis_pack16(TMP26, DST_1); 1578 vis_st64(DST_0, dest[0]); 1579 vis_pmerge(ZERO, REF_S6, TMP4); 1580 1581 vis_pmerge(ZERO, REF_S6_1, TMP6); 1582 1583 vis_padd16(TMP0, TMP4, TMP0); 1584 1585 vis_padd16(TMP2, TMP6, TMP2); 1586 1587 vis_padd16(TMP0, TMP12, TMP0); 1588 1589 vis_padd16(TMP2, TMP14, TMP2); 1590 vis_pack16(TMP0, DST_2); 1591 1592 vis_pack16(TMP2, DST_3); 1593 vis_st64_2(DST_2, dest, 8); 1594 dest += stride; 1595 } while (--height); 1596} 1597 1598static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * ref, 1599 const int stride, int height) 1600{ 1601 unsigned long off = (unsigned long) ref & 0x7; 1602 unsigned long off_plus_1 = off + 1; 1603 int stride_8 = stride + 8; 1604 1605 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 1606 1607 ref = vis_alignaddr(ref); 1608 1609 vis_ld64(ref[ 0], TMP0); 1610 vis_fzero(ZERO); 1611 1612 vis_ld64(ref[ 8], TMP2); 1613 1614 vis_ld64(constants2[0], CONST_2); 1615 1616 vis_ld64(constants256_512[0], CONST_256); 1617 vis_faligndata(TMP0, TMP2, REF_S0); 1618 1619 if (off != 0x7) { 1620 vis_alignaddr_g0((void *)off_plus_1); 1621 vis_faligndata(TMP0, TMP2, REF_S2); 1622 } else { 1623 vis_src1(TMP2, REF_S2); 1624 } 1625 1626 height >>= 1; 1627 do { /* 26 cycles */ 1628 vis_ld64_2(ref, stride, TMP0); 1629 vis_mul8x16au(REF_S0, CONST_256, TMP8); 1630 vis_pmerge(ZERO, REF_S2, TMP12); 1631 1632 vis_alignaddr_g0((void *)off); 1633 1634 vis_ld64_2(ref, stride_8, TMP2); 1635 ref += stride; 1636 vis_mul8x16au(REF_S0_1, CONST_256, TMP10); 1637 vis_pmerge(ZERO, REF_S2_1, TMP14); 1638 1639 vis_ld64_2(ref, stride, TMP4); 1640 1641 vis_ld64_2(ref, stride_8, TMP6); 1642 ref += stride; 1643 vis_faligndata(TMP0, TMP2, REF_S4); 1644 1645 vis_pmerge(ZERO, REF_S4, TMP18); 1646 1647 vis_pmerge(ZERO, REF_S4_1, TMP20); 1648 1649 vis_faligndata(TMP4, TMP6, REF_S0); 1650 1651 if (off != 0x7) { 1652 vis_alignaddr_g0((void *)off_plus_1); 1653 vis_faligndata(TMP0, TMP2, REF_S6); 1654 vis_faligndata(TMP4, TMP6, REF_S2); 1655 } else { 1656 vis_src1(TMP2, REF_S6); 1657 vis_src1(TMP6, REF_S2); 1658 } 1659 1660 vis_padd16(TMP18, CONST_2, TMP18); 1661 vis_mul8x16au(REF_S6, CONST_256, TMP22); 1662 1663 vis_padd16(TMP20, CONST_2, TMP20); 1664 vis_mul8x16au(REF_S6_1, CONST_256, TMP24); 1665 1666 vis_mul8x16au(REF_S0, CONST_256, TMP26); 1667 vis_pmerge(ZERO, REF_S0_1, TMP28); 1668 1669 vis_mul8x16au(REF_S2, CONST_256, TMP30); 1670 vis_padd16(TMP18, TMP22, TMP18); 1671 1672 vis_mul8x16au(REF_S2_1, CONST_256, TMP32); 1673 vis_padd16(TMP20, TMP24, TMP20); 1674 1675 vis_padd16(TMP8, TMP18, TMP8); 1676 1677 vis_padd16(TMP10, TMP20, TMP10); 1678 1679 vis_padd16(TMP8, TMP12, TMP8); 1680 1681 vis_padd16(TMP10, TMP14, TMP10); 1682 vis_pack16(TMP8, DST_0); 1683 1684 vis_pack16(TMP10, DST_1); 1685 vis_st64(DST_0, dest[0]); 1686 dest += stride; 1687 vis_padd16(TMP18, TMP26, TMP18); 1688 1689 vis_padd16(TMP20, TMP28, TMP20); 1690 1691 vis_padd16(TMP18, TMP30, TMP18); 1692 1693 vis_padd16(TMP20, TMP32, TMP20); 1694 vis_pack16(TMP18, DST_2); 1695 1696 vis_pack16(TMP20, DST_3); 1697 vis_st64(DST_2, dest[0]); 1698 dest += stride; 1699 } while (--height); 1700} 1701 1702static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * ref, 1703 const int stride, int height) 1704{ 1705 unsigned long off = (unsigned long) ref & 0x7; 1706 unsigned long off_plus_1 = off + 1; 1707 int stride_8 = stride + 8; 1708 int stride_16 = stride + 16; 1709 1710 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT); 1711 1712 ref = vis_alignaddr(ref); 1713 1714 vis_ld64(ref[ 0], TMP0); 1715 vis_fzero(ZERO); 1716 1717 vis_ld64(ref[ 8], TMP2); 1718 1719 vis_ld64(ref[16], TMP4); 1720 1721 vis_ld64(constants6[0], CONST_6); 1722 vis_faligndata(TMP0, TMP2, REF_S0); 1723 1724 vis_ld64(constants256_1024[0], CONST_256); 1725 vis_faligndata(TMP2, TMP4, REF_S4); 1726 1727 if (off != 0x7) { 1728 vis_alignaddr_g0((void *)off_plus_1); 1729 vis_faligndata(TMP0, TMP2, REF_S2); 1730 vis_faligndata(TMP2, TMP4, REF_S6); 1731 } else { 1732 vis_src1(TMP2, REF_S2); 1733 vis_src1(TMP4, REF_S6); 1734 } 1735 1736 height >>= 1; 1737 do { /* 55 cycles */ 1738 vis_ld64_2(ref, stride, TMP0); 1739 vis_mul8x16au(REF_S0, CONST_256, TMP12); 1740 vis_pmerge(ZERO, REF_S0_1, TMP14); 1741 1742 vis_alignaddr_g0((void *)off); 1743 1744 vis_ld64_2(ref, stride_8, TMP2); 1745 vis_mul8x16au(REF_S2, CONST_256, TMP16); 1746 vis_pmerge(ZERO, REF_S2_1, TMP18); 1747 1748 vis_ld64_2(ref, stride_16, TMP4); 1749 ref += stride; 1750 vis_mul8x16au(REF_S4, CONST_256, TMP20); 1751 vis_pmerge(ZERO, REF_S4_1, TMP22); 1752 1753 vis_ld64_2(ref, stride, TMP6); 1754 vis_mul8x16au(REF_S6, CONST_256, TMP24); 1755 vis_pmerge(ZERO, REF_S6_1, TMP26); 1756 1757 vis_ld64_2(ref, stride_8, TMP8); 1758 vis_faligndata(TMP0, TMP2, REF_0); 1759 1760 vis_ld64_2(ref, stride_16, TMP10); 1761 ref += stride; 1762 vis_faligndata(TMP2, TMP4, REF_4); 1763 1764 vis_ld64(dest[0], DST_0); 1765 vis_faligndata(TMP6, TMP8, REF_S0); 1766 1767 vis_ld64_2(dest, 8, DST_2); 1768 vis_faligndata(TMP8, TMP10, REF_S4); 1769 1770 if (off != 0x7) { 1771 vis_alignaddr_g0((void *)off_plus_1); 1772 vis_faligndata(TMP0, TMP2, REF_2); 1773 vis_faligndata(TMP2, TMP4, REF_6); 1774 vis_faligndata(TMP6, TMP8, REF_S2); 1775 vis_faligndata(TMP8, TMP10, REF_S6); 1776 } else { 1777 vis_src1(TMP2, REF_2); 1778 vis_src1(TMP4, REF_6); 1779 vis_src1(TMP8, REF_S2); 1780 vis_src1(TMP10, REF_S6); 1781 } 1782 1783 vis_mul8x16al(DST_0, CONST_1024, TMP30); 1784 vis_pmerge(ZERO, REF_0, TMP0); 1785 1786 vis_mul8x16al(DST_1, CONST_1024, TMP32); 1787 vis_pmerge(ZERO, REF_0_1, TMP2); 1788 1789 vis_mul8x16au(REF_2, CONST_256, TMP4); 1790 vis_pmerge(ZERO, REF_2_1, TMP6); 1791 1792 vis_mul8x16al(DST_2, CONST_1024, REF_0); 1793 vis_padd16(TMP0, CONST_6, TMP0); 1794 1795 vis_mul8x16al(DST_3, CONST_1024, REF_2); 1796 vis_padd16(TMP2, CONST_6, TMP2); 1797 1798 vis_padd16(TMP0, TMP4, TMP0); 1799 vis_mul8x16au(REF_4, CONST_256, TMP4); 1800 1801 vis_padd16(TMP2, TMP6, TMP2); 1802 vis_mul8x16au(REF_4_1, CONST_256, TMP6); 1803 1804 vis_padd16(TMP12, TMP0, TMP12); 1805 vis_mul8x16au(REF_6, CONST_256, TMP8); 1806 1807 vis_padd16(TMP14, TMP2, TMP14); 1808 vis_mul8x16au(REF_6_1, CONST_256, TMP10); 1809 1810 vis_padd16(TMP12, TMP16, TMP12); 1811 vis_mul8x16au(REF_S0, CONST_256, REF_4); 1812 1813 vis_padd16(TMP14, TMP18, TMP14); 1814 vis_mul8x16au(REF_S0_1, CONST_256, REF_6); 1815 1816 vis_padd16(TMP12, TMP30, TMP12); 1817 1818 vis_padd16(TMP14, TMP32, TMP14); 1819 vis_pack16(TMP12, DST_0); 1820 1821 vis_pack16(TMP14, DST_1); 1822 vis_st64(DST_0, dest[0]); 1823 vis_padd16(TMP4, CONST_6, TMP4); 1824 1825 vis_ld64_2(dest, stride, DST_0); 1826 vis_padd16(TMP6, CONST_6, TMP6); 1827 vis_mul8x16au(REF_S2, CONST_256, TMP12); 1828 1829 vis_padd16(TMP4, TMP8, TMP4); 1830 vis_mul8x16au(REF_S2_1, CONST_256, TMP14); 1831 1832 vis_padd16(TMP6, TMP10, TMP6); 1833 1834 vis_padd16(TMP20, TMP4, TMP20); 1835 1836 vis_padd16(TMP22, TMP6, TMP22); 1837 1838 vis_padd16(TMP20, TMP24, TMP20); 1839 1840 vis_padd16(TMP22, TMP26, TMP22); 1841 1842 vis_padd16(TMP20, REF_0, TMP20); 1843 vis_mul8x16au(REF_S4, CONST_256, REF_0); 1844 1845 vis_padd16(TMP22, REF_2, TMP22); 1846 vis_pack16(TMP20, DST_2); 1847 1848 vis_pack16(TMP22, DST_3); 1849 vis_st64_2(DST_2, dest, 8); 1850 dest += stride; 1851 1852 vis_ld64_2(dest, 8, DST_2); 1853 vis_mul8x16al(DST_0, CONST_1024, TMP30); 1854 vis_pmerge(ZERO, REF_S4_1, REF_2); 1855 1856 vis_mul8x16al(DST_1, CONST_1024, TMP32); 1857 vis_padd16(REF_4, TMP0, TMP8); 1858 1859 vis_mul8x16au(REF_S6, CONST_256, REF_4); 1860 vis_padd16(REF_6, TMP2, TMP10); 1861 1862 vis_mul8x16au(REF_S6_1, CONST_256, REF_6); 1863 vis_padd16(TMP8, TMP12, TMP8); 1864 1865 vis_padd16(TMP10, TMP14, TMP10); 1866 1867 vis_padd16(TMP8, TMP30, TMP8); 1868 1869 vis_padd16(TMP10, TMP32, TMP10); 1870 vis_pack16(TMP8, DST_0); 1871 1872 vis_pack16(TMP10, DST_1); 1873 vis_st64(DST_0, dest[0]); 1874 1875 vis_padd16(REF_0, TMP4, REF_0); 1876 1877 vis_mul8x16al(DST_2, CONST_1024, TMP30); 1878 vis_padd16(REF_2, TMP6, REF_2); 1879 1880 vis_mul8x16al(DST_3, CONST_1024, TMP32); 1881 vis_padd16(REF_0, REF_4, REF_0); 1882 1883 vis_padd16(REF_2, REF_6, REF_2); 1884 1885 vis_padd16(REF_0, TMP30, REF_0); 1886 1887 /* stall */ 1888 1889 vis_padd16(REF_2, TMP32, REF_2); 1890 vis_pack16(REF_0, DST_2); 1891 1892 vis_pack16(REF_2, DST_3); 1893 vis_st64_2(DST_2, dest, 8); 1894 dest += stride; 1895 } while (--height); 1896} 1897 1898static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * ref, 1899 const int stride, int height) 1900{ 1901 unsigned long off = (unsigned long) ref & 0x7; 1902 unsigned long off_plus_1 = off + 1; 1903 int stride_8 = stride + 8; 1904 1905 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT); 1906 1907 ref = vis_alignaddr(ref); 1908 1909 vis_ld64(ref[0], TMP0); 1910 vis_fzero(ZERO); 1911 1912 vis_ld64_2(ref, 8, TMP2); 1913 1914 vis_ld64(constants6[0], CONST_6); 1915 1916 vis_ld64(constants256_1024[0], CONST_256); 1917 vis_faligndata(TMP0, TMP2, REF_S0); 1918 1919 if (off != 0x7) { 1920 vis_alignaddr_g0((void *)off_plus_1); 1921 vis_faligndata(TMP0, TMP2, REF_S2); 1922 } else { 1923 vis_src1(TMP2, REF_S2); 1924 } 1925 1926 height >>= 1; 1927 do { /* 31 cycles */ 1928 vis_ld64_2(ref, stride, TMP0); 1929 vis_mul8x16au(REF_S0, CONST_256, TMP8); 1930 vis_pmerge(ZERO, REF_S0_1, TMP10); 1931 1932 vis_ld64_2(ref, stride_8, TMP2); 1933 ref += stride; 1934 vis_mul8x16au(REF_S2, CONST_256, TMP12); 1935 vis_pmerge(ZERO, REF_S2_1, TMP14); 1936 1937 vis_alignaddr_g0((void *)off); 1938 1939 vis_ld64_2(ref, stride, TMP4); 1940 vis_faligndata(TMP0, TMP2, REF_S4); 1941 1942 vis_ld64_2(ref, stride_8, TMP6); 1943 ref += stride; 1944 1945 vis_ld64(dest[0], DST_0); 1946 vis_faligndata(TMP4, TMP6, REF_S0); 1947 1948 vis_ld64_2(dest, stride, DST_2); 1949 1950 if (off != 0x7) { 1951 vis_alignaddr_g0((void *)off_plus_1); 1952 vis_faligndata(TMP0, TMP2, REF_S6); 1953 vis_faligndata(TMP4, TMP6, REF_S2); 1954 } else { 1955 vis_src1(TMP2, REF_S6); 1956 vis_src1(TMP6, REF_S2); 1957 } 1958 1959 vis_mul8x16al(DST_0, CONST_1024, TMP30); 1960 vis_pmerge(ZERO, REF_S4, TMP22); 1961 1962 vis_mul8x16al(DST_1, CONST_1024, TMP32); 1963 vis_pmerge(ZERO, REF_S4_1, TMP24); 1964 1965 vis_mul8x16au(REF_S6, CONST_256, TMP26); 1966 vis_pmerge(ZERO, REF_S6_1, TMP28); 1967 1968 vis_mul8x16au(REF_S0, CONST_256, REF_S4); 1969 vis_padd16(TMP22, CONST_6, TMP22); 1970 1971 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6); 1972 vis_padd16(TMP24, CONST_6, TMP24); 1973 1974 vis_mul8x16al(DST_2, CONST_1024, REF_0); 1975 vis_padd16(TMP22, TMP26, TMP22); 1976 1977 vis_mul8x16al(DST_3, CONST_1024, REF_2); 1978 vis_padd16(TMP24, TMP28, TMP24); 1979 1980 vis_mul8x16au(REF_S2, CONST_256, TMP26); 1981 vis_padd16(TMP8, TMP22, TMP8); 1982 1983 vis_mul8x16au(REF_S2_1, CONST_256, TMP28); 1984 vis_padd16(TMP10, TMP24, TMP10); 1985 1986 vis_padd16(TMP8, TMP12, TMP8); 1987 1988 vis_padd16(TMP10, TMP14, TMP10); 1989 1990 vis_padd16(TMP8, TMP30, TMP8); 1991 1992 vis_padd16(TMP10, TMP32, TMP10); 1993 vis_pack16(TMP8, DST_0); 1994 1995 vis_pack16(TMP10, DST_1); 1996 vis_st64(DST_0, dest[0]); 1997 dest += stride; 1998 1999 vis_padd16(REF_S4, TMP22, TMP12); 2000 2001 vis_padd16(REF_S6, TMP24, TMP14); 2002 2003 vis_padd16(TMP12, TMP26, TMP12); 2004 2005 vis_padd16(TMP14, TMP28, TMP14); 2006 2007 vis_padd16(TMP12, REF_0, TMP12); 2008 2009 vis_padd16(TMP14, REF_2, TMP14); 2010 vis_pack16(TMP12, DST_2); 2011 2012 vis_pack16(TMP14, DST_3); 2013 vis_st64(DST_2, dest[0]); 2014 dest += stride; 2015 } while (--height); 2016} 2017 2018/* End of rounding code */ 2019 2020/* Start of no rounding code */ 2021/* The trick used in some of this file is the formula from the MMX 2022 * motion comp code, which is: 2023 * 2024 * (x+y)>>1 == (x&y)+((x^y)>>1) 2025 * 2026 * This allows us to average 8 bytes at a time in a 64-bit FPU reg. 2027 * We avoid overflows by masking before we do the shift, and we 2028 * implement the shift by multiplying by 1/2 using mul8x16. So in 2029 * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask 2030 * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and 2031 * the value 0x80808080 is in f8): 2032 * 2033 * fxor f0, f2, f10 2034 * fand f10, f4, f10 2035 * fmul8x16 f8, f10, f10 2036 * fand f10, f6, f10 2037 * fand f0, f2, f12 2038 * fpadd16 f12, f10, f10 2039 */ 2040 2041static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref, 2042 const int stride, int height) 2043{ 2044 ref = vis_alignaddr(ref); 2045 do { /* 5 cycles */ 2046 vis_ld64(ref[0], TMP0); 2047 2048 vis_ld64_2(ref, 8, TMP2); 2049 2050 vis_ld64_2(ref, 16, TMP4); 2051 ref += stride; 2052 2053 vis_faligndata(TMP0, TMP2, REF_0); 2054 vis_st64(REF_0, dest[0]); 2055 2056 vis_faligndata(TMP2, TMP4, REF_2); 2057 vis_st64_2(REF_2, dest, 8); 2058 dest += stride; 2059 } while (--height); 2060} 2061 2062static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref, 2063 const int stride, int height) 2064{ 2065 ref = vis_alignaddr(ref); 2066 do { /* 4 cycles */ 2067 vis_ld64(ref[0], TMP0); 2068 2069 vis_ld64(ref[8], TMP2); 2070 ref += stride; 2071 2072 /* stall */ 2073 2074 vis_faligndata(TMP0, TMP2, REF_0); 2075 vis_st64(REF_0, dest[0]); 2076 dest += stride; 2077 } while (--height); 2078} 2079 2080 2081static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref, 2082 const int stride, int height) 2083{ 2084 int stride_8 = stride + 8; 2085 2086 ref = vis_alignaddr(ref); 2087 2088 vis_ld64(ref[0], TMP0); 2089 2090 vis_ld64(ref[8], TMP2); 2091 2092 vis_ld64(ref[16], TMP4); 2093 2094 vis_ld64(dest[0], DST_0); 2095 2096 vis_ld64(dest[8], DST_2); 2097 2098 vis_ld64(constants_fe[0], MASK_fe); 2099 vis_faligndata(TMP0, TMP2, REF_0); 2100 2101 vis_ld64(constants_7f[0], MASK_7f); 2102 vis_faligndata(TMP2, TMP4, REF_2); 2103 2104 vis_ld64(constants128[0], CONST_128); 2105 2106 ref += stride; 2107 height = (height >> 1) - 1; 2108 2109 do { /* 24 cycles */ 2110 vis_ld64(ref[0], TMP0); 2111 vis_xor(DST_0, REF_0, TMP6); 2112 2113 vis_ld64_2(ref, 8, TMP2); 2114 vis_and(TMP6, MASK_fe, TMP6); 2115 2116 vis_ld64_2(ref, 16, TMP4); 2117 ref += stride; 2118 vis_mul8x16(CONST_128, TMP6, TMP6); 2119 vis_xor(DST_2, REF_2, TMP8); 2120 2121 vis_and(TMP8, MASK_fe, TMP8); 2122 2123 vis_and(DST_0, REF_0, TMP10); 2124 vis_ld64_2(dest, stride, DST_0); 2125 vis_mul8x16(CONST_128, TMP8, TMP8); 2126 2127 vis_and(DST_2, REF_2, TMP12); 2128 vis_ld64_2(dest, stride_8, DST_2); 2129 2130 vis_ld64(ref[0], TMP14); 2131 vis_and(TMP6, MASK_7f, TMP6); 2132 2133 vis_and(TMP8, MASK_7f, TMP8); 2134 2135 vis_padd16(TMP10, TMP6, TMP6); 2136 vis_st64(TMP6, dest[0]); 2137 2138 vis_padd16(TMP12, TMP8, TMP8); 2139 vis_st64_2(TMP8, dest, 8); 2140 2141 dest += stride; 2142 vis_ld64_2(ref, 8, TMP16); 2143 vis_faligndata(TMP0, TMP2, REF_0); 2144 2145 vis_ld64_2(ref, 16, TMP18); 2146 vis_faligndata(TMP2, TMP4, REF_2); 2147 ref += stride; 2148 2149 vis_xor(DST_0, REF_0, TMP20); 2150 2151 vis_and(TMP20, MASK_fe, TMP20); 2152 2153 vis_xor(DST_2, REF_2, TMP22); 2154 vis_mul8x16(CONST_128, TMP20, TMP20); 2155 2156 vis_and(TMP22, MASK_fe, TMP22); 2157 2158 vis_and(DST_0, REF_0, TMP24); 2159 vis_mul8x16(CONST_128, TMP22, TMP22); 2160 2161 vis_and(DST_2, REF_2, TMP26); 2162 2163 vis_ld64_2(dest, stride, DST_0); 2164 vis_faligndata(TMP14, TMP16, REF_0); 2165 2166 vis_ld64_2(dest, stride_8, DST_2); 2167 vis_faligndata(TMP16, TMP18, REF_2); 2168 2169 vis_and(TMP20, MASK_7f, TMP20); 2170 2171 vis_and(TMP22, MASK_7f, TMP22); 2172 2173 vis_padd16(TMP24, TMP20, TMP20); 2174 vis_st64(TMP20, dest[0]); 2175 2176 vis_padd16(TMP26, TMP22, TMP22); 2177 vis_st64_2(TMP22, dest, 8); 2178 dest += stride; 2179 } while (--height); 2180 2181 vis_ld64(ref[0], TMP0); 2182 vis_xor(DST_0, REF_0, TMP6); 2183 2184 vis_ld64_2(ref, 8, TMP2); 2185 vis_and(TMP6, MASK_fe, TMP6); 2186 2187 vis_ld64_2(ref, 16, TMP4); 2188 vis_mul8x16(CONST_128, TMP6, TMP6); 2189 vis_xor(DST_2, REF_2, TMP8); 2190 2191 vis_and(TMP8, MASK_fe, TMP8); 2192 2193 vis_and(DST_0, REF_0, TMP10); 2194 vis_ld64_2(dest, stride, DST_0); 2195 vis_mul8x16(CONST_128, TMP8, TMP8); 2196 2197 vis_and(DST_2, REF_2, TMP12); 2198 vis_ld64_2(dest, stride_8, DST_2); 2199 2200 vis_ld64(ref[0], TMP14); 2201 vis_and(TMP6, MASK_7f, TMP6); 2202 2203 vis_and(TMP8, MASK_7f, TMP8); 2204 2205 vis_padd16(TMP10, TMP6, TMP6); 2206 vis_st64(TMP6, dest[0]); 2207 2208 vis_padd16(TMP12, TMP8, TMP8); 2209 vis_st64_2(TMP8, dest, 8); 2210 2211 dest += stride; 2212 vis_faligndata(TMP0, TMP2, REF_0); 2213 2214 vis_faligndata(TMP2, TMP4, REF_2); 2215 2216 vis_xor(DST_0, REF_0, TMP20); 2217 2218 vis_and(TMP20, MASK_fe, TMP20); 2219 2220 vis_xor(DST_2, REF_2, TMP22); 2221 vis_mul8x16(CONST_128, TMP20, TMP20); 2222 2223 vis_and(TMP22, MASK_fe, TMP22); 2224 2225 vis_and(DST_0, REF_0, TMP24); 2226 vis_mul8x16(CONST_128, TMP22, TMP22); 2227 2228 vis_and(DST_2, REF_2, TMP26); 2229 2230 vis_and(TMP20, MASK_7f, TMP20); 2231 2232 vis_and(TMP22, MASK_7f, TMP22); 2233 2234 vis_padd16(TMP24, TMP20, TMP20); 2235 vis_st64(TMP20, dest[0]); 2236 2237 vis_padd16(TMP26, TMP22, TMP22); 2238 vis_st64_2(TMP22, dest, 8); 2239} 2240 2241static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref, 2242 const int stride, int height) 2243{ 2244 ref = vis_alignaddr(ref); 2245 2246 vis_ld64(ref[0], TMP0); 2247 2248 vis_ld64(ref[8], TMP2); 2249 2250 vis_ld64(dest[0], DST_0); 2251 2252 vis_ld64(constants_fe[0], MASK_fe); 2253 2254 vis_ld64(constants_7f[0], MASK_7f); 2255 vis_faligndata(TMP0, TMP2, REF_0); 2256 2257 vis_ld64(constants128[0], CONST_128); 2258 2259 ref += stride; 2260 height = (height >> 1) - 1; 2261 2262 do { /* 12 cycles */ 2263 vis_ld64(ref[0], TMP0); 2264 vis_xor(DST_0, REF_0, TMP4); 2265 2266 vis_ld64(ref[8], TMP2); 2267 vis_and(TMP4, MASK_fe, TMP4); 2268 2269 vis_and(DST_0, REF_0, TMP6); 2270 vis_ld64_2(dest, stride, DST_0); 2271 ref += stride; 2272 vis_mul8x16(CONST_128, TMP4, TMP4); 2273 2274 vis_ld64(ref[0], TMP12); 2275 vis_faligndata(TMP0, TMP2, REF_0); 2276 2277 vis_ld64(ref[8], TMP2); 2278 vis_xor(DST_0, REF_0, TMP0); 2279 ref += stride; 2280 2281 vis_and(TMP0, MASK_fe, TMP0); 2282 2283 vis_and(TMP4, MASK_7f, TMP4); 2284 2285 vis_padd16(TMP6, TMP4, TMP4); 2286 vis_st64(TMP4, dest[0]); 2287 dest += stride; 2288 vis_mul8x16(CONST_128, TMP0, TMP0); 2289 2290 vis_and(DST_0, REF_0, TMP6); 2291 vis_ld64_2(dest, stride, DST_0); 2292 2293 vis_faligndata(TMP12, TMP2, REF_0); 2294 2295 vis_and(TMP0, MASK_7f, TMP0); 2296 2297 vis_padd16(TMP6, TMP0, TMP4); 2298 vis_st64(TMP4, dest[0]); 2299 dest += stride; 2300 } while (--height); 2301 2302 vis_ld64(ref[0], TMP0); 2303 vis_xor(DST_0, REF_0, TMP4); 2304 2305 vis_ld64(ref[8], TMP2); 2306 vis_and(TMP4, MASK_fe, TMP4); 2307 2308 vis_and(DST_0, REF_0, TMP6); 2309 vis_ld64_2(dest, stride, DST_0); 2310 vis_mul8x16(CONST_128, TMP4, TMP4); 2311 2312 vis_faligndata(TMP0, TMP2, REF_0); 2313 2314 vis_xor(DST_0, REF_0, TMP0); 2315 2316 vis_and(TMP0, MASK_fe, TMP0); 2317 2318 vis_and(TMP4, MASK_7f, TMP4); 2319 2320 vis_padd16(TMP6, TMP4, TMP4); 2321 vis_st64(TMP4, dest[0]); 2322 dest += stride; 2323 vis_mul8x16(CONST_128, TMP0, TMP0); 2324 2325 vis_and(DST_0, REF_0, TMP6); 2326 2327 vis_and(TMP0, MASK_7f, TMP0); 2328 2329 vis_padd16(TMP6, TMP0, TMP4); 2330 vis_st64(TMP4, dest[0]); 2331} 2332 2333static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref, 2334 const int stride, int height) 2335{ 2336 unsigned long off = (unsigned long) ref & 0x7; 2337 unsigned long off_plus_1 = off + 1; 2338 2339 ref = vis_alignaddr(ref); 2340 2341 vis_ld64(ref[0], TMP0); 2342 2343 vis_ld64_2(ref, 8, TMP2); 2344 2345 vis_ld64_2(ref, 16, TMP4); 2346 2347 vis_ld64(constants_fe[0], MASK_fe); 2348 2349 vis_ld64(constants_7f[0], MASK_7f); 2350 vis_faligndata(TMP0, TMP2, REF_0); 2351 2352 vis_ld64(constants128[0], CONST_128); 2353 vis_faligndata(TMP2, TMP4, REF_4); 2354 2355 if (off != 0x7) { 2356 vis_alignaddr_g0((void *)off_plus_1); 2357 vis_faligndata(TMP0, TMP2, REF_2); 2358 vis_faligndata(TMP2, TMP4, REF_6); 2359 } else { 2360 vis_src1(TMP2, REF_2); 2361 vis_src1(TMP4, REF_6); 2362 } 2363 2364 ref += stride; 2365 height = (height >> 1) - 1; 2366 2367 do { /* 34 cycles */ 2368 vis_ld64(ref[0], TMP0); 2369 vis_xor(REF_0, REF_2, TMP6); 2370 2371 vis_ld64_2(ref, 8, TMP2); 2372 vis_xor(REF_4, REF_6, TMP8); 2373 2374 vis_ld64_2(ref, 16, TMP4); 2375 vis_and(TMP6, MASK_fe, TMP6); 2376 ref += stride; 2377 2378 vis_ld64(ref[0], TMP14); 2379 vis_mul8x16(CONST_128, TMP6, TMP6); 2380 vis_and(TMP8, MASK_fe, TMP8); 2381 2382 vis_ld64_2(ref, 8, TMP16); 2383 vis_mul8x16(CONST_128, TMP8, TMP8); 2384 vis_and(REF_0, REF_2, TMP10); 2385 2386 vis_ld64_2(ref, 16, TMP18); 2387 ref += stride; 2388 vis_and(REF_4, REF_6, TMP12); 2389 2390 vis_alignaddr_g0((void *)off); 2391 2392 vis_faligndata(TMP0, TMP2, REF_0); 2393 2394 vis_faligndata(TMP2, TMP4, REF_4); 2395 2396 if (off != 0x7) { 2397 vis_alignaddr_g0((void *)off_plus_1); 2398 vis_faligndata(TMP0, TMP2, REF_2); 2399 vis_faligndata(TMP2, TMP4, REF_6); 2400 } else { 2401 vis_src1(TMP2, REF_2); 2402 vis_src1(TMP4, REF_6); 2403 } 2404 2405 vis_and(TMP6, MASK_7f, TMP6); 2406 2407 vis_and(TMP8, MASK_7f, TMP8); 2408 2409 vis_padd16(TMP10, TMP6, TMP6); 2410 vis_st64(TMP6, dest[0]); 2411 2412 vis_padd16(TMP12, TMP8, TMP8); 2413 vis_st64_2(TMP8, dest, 8); 2414 dest += stride; 2415 2416 vis_xor(REF_0, REF_2, TMP6); 2417 2418 vis_xor(REF_4, REF_6, TMP8); 2419 2420 vis_and(TMP6, MASK_fe, TMP6); 2421 2422 vis_mul8x16(CONST_128, TMP6, TMP6); 2423 vis_and(TMP8, MASK_fe, TMP8); 2424 2425 vis_mul8x16(CONST_128, TMP8, TMP8); 2426 vis_and(REF_0, REF_2, TMP10); 2427 2428 vis_and(REF_4, REF_6, TMP12); 2429 2430 vis_alignaddr_g0((void *)off); 2431 2432 vis_faligndata(TMP14, TMP16, REF_0); 2433 2434 vis_faligndata(TMP16, TMP18, REF_4); 2435 2436 if (off != 0x7) { 2437 vis_alignaddr_g0((void *)off_plus_1); 2438 vis_faligndata(TMP14, TMP16, REF_2); 2439 vis_faligndata(TMP16, TMP18, REF_6); 2440 } else { 2441 vis_src1(TMP16, REF_2); 2442 vis_src1(TMP18, REF_6); 2443 } 2444 2445 vis_and(TMP6, MASK_7f, TMP6); 2446 2447 vis_and(TMP8, MASK_7f, TMP8); 2448 2449 vis_padd16(TMP10, TMP6, TMP6); 2450 vis_st64(TMP6, dest[0]); 2451 2452 vis_padd16(TMP12, TMP8, TMP8); 2453 vis_st64_2(TMP8, dest, 8); 2454 dest += stride; 2455 } while (--height); 2456 2457 vis_ld64(ref[0], TMP0); 2458 vis_xor(REF_0, REF_2, TMP6); 2459 2460 vis_ld64_2(ref, 8, TMP2); 2461 vis_xor(REF_4, REF_6, TMP8); 2462 2463 vis_ld64_2(ref, 16, TMP4); 2464 vis_and(TMP6, MASK_fe, TMP6); 2465 2466 vis_mul8x16(CONST_128, TMP6, TMP6); 2467 vis_and(TMP8, MASK_fe, TMP8); 2468 2469 vis_mul8x16(CONST_128, TMP8, TMP8); 2470 vis_and(REF_0, REF_2, TMP10); 2471 2472 vis_and(REF_4, REF_6, TMP12); 2473 2474 vis_alignaddr_g0((void *)off); 2475 2476 vis_faligndata(TMP0, TMP2, REF_0); 2477 2478 vis_faligndata(TMP2, TMP4, REF_4); 2479 2480 if (off != 0x7) { 2481 vis_alignaddr_g0((void *)off_plus_1); 2482 vis_faligndata(TMP0, TMP2, REF_2); 2483 vis_faligndata(TMP2, TMP4, REF_6); 2484 } else { 2485 vis_src1(TMP2, REF_2); 2486 vis_src1(TMP4, REF_6); 2487 } 2488 2489 vis_and(TMP6, MASK_7f, TMP6); 2490 2491 vis_and(TMP8, MASK_7f, TMP8); 2492 2493 vis_padd16(TMP10, TMP6, TMP6); 2494 vis_st64(TMP6, dest[0]); 2495 2496 vis_padd16(TMP12, TMP8, TMP8); 2497 vis_st64_2(TMP8, dest, 8); 2498 dest += stride; 2499 2500 vis_xor(REF_0, REF_2, TMP6); 2501 2502 vis_xor(REF_4, REF_6, TMP8); 2503 2504 vis_and(TMP6, MASK_fe, TMP6); 2505 2506 vis_mul8x16(CONST_128, TMP6, TMP6); 2507 vis_and(TMP8, MASK_fe, TMP8); 2508 2509 vis_mul8x16(CONST_128, TMP8, TMP8); 2510 vis_and(REF_0, REF_2, TMP10); 2511 2512 vis_and(REF_4, REF_6, TMP12); 2513 2514 vis_and(TMP6, MASK_7f, TMP6); 2515 2516 vis_and(TMP8, MASK_7f, TMP8); 2517 2518 vis_padd16(TMP10, TMP6, TMP6); 2519 vis_st64(TMP6, dest[0]); 2520 2521 vis_padd16(TMP12, TMP8, TMP8); 2522 vis_st64_2(TMP8, dest, 8); 2523} 2524 2525static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref, 2526 const int stride, int height) 2527{ 2528 unsigned long off = (unsigned long) ref & 0x7; 2529 unsigned long off_plus_1 = off + 1; 2530 2531 ref = vis_alignaddr(ref); 2532 2533 vis_ld64(ref[0], TMP0); 2534 2535 vis_ld64(ref[8], TMP2); 2536 2537 vis_ld64(constants_fe[0], MASK_fe); 2538 2539 vis_ld64(constants_7f[0], MASK_7f); 2540 2541 vis_ld64(constants128[0], CONST_128); 2542 vis_faligndata(TMP0, TMP2, REF_0); 2543 2544 if (off != 0x7) { 2545 vis_alignaddr_g0((void *)off_plus_1); 2546 vis_faligndata(TMP0, TMP2, REF_2); 2547 } else { 2548 vis_src1(TMP2, REF_2); 2549 } 2550 2551 ref += stride; 2552 height = (height >> 1) - 1; 2553 2554 do { /* 20 cycles */ 2555 vis_ld64(ref[0], TMP0); 2556 vis_xor(REF_0, REF_2, TMP4); 2557 2558 vis_ld64_2(ref, 8, TMP2); 2559 vis_and(TMP4, MASK_fe, TMP4); 2560 ref += stride; 2561 2562 vis_ld64(ref[0], TMP8); 2563 vis_and(REF_0, REF_2, TMP6); 2564 vis_mul8x16(CONST_128, TMP4, TMP4); 2565 2566 vis_alignaddr_g0((void *)off); 2567 2568 vis_ld64_2(ref, 8, TMP10); 2569 ref += stride; 2570 vis_faligndata(TMP0, TMP2, REF_0); 2571 2572 if (off != 0x7) { 2573 vis_alignaddr_g0((void *)off_plus_1); 2574 vis_faligndata(TMP0, TMP2, REF_2); 2575 } else { 2576 vis_src1(TMP2, REF_2); 2577 } 2578 2579 vis_and(TMP4, MASK_7f, TMP4); 2580 2581 vis_padd16(TMP6, TMP4, DST_0); 2582 vis_st64(DST_0, dest[0]); 2583 dest += stride; 2584 2585 vis_xor(REF_0, REF_2, TMP12); 2586 2587 vis_and(TMP12, MASK_fe, TMP12); 2588 2589 vis_and(REF_0, REF_2, TMP14); 2590 vis_mul8x16(CONST_128, TMP12, TMP12); 2591 2592 vis_alignaddr_g0((void *)off); 2593 vis_faligndata(TMP8, TMP10, REF_0); 2594 if (off != 0x7) { 2595 vis_alignaddr_g0((void *)off_plus_1); 2596 vis_faligndata(TMP8, TMP10, REF_2); 2597 } else { 2598 vis_src1(TMP10, REF_2); 2599 } 2600 2601 vis_and(TMP12, MASK_7f, TMP12); 2602 2603 vis_padd16(TMP14, TMP12, DST_0); 2604 vis_st64(DST_0, dest[0]); 2605 dest += stride; 2606 } while (--height); 2607 2608 vis_ld64(ref[0], TMP0); 2609 vis_xor(REF_0, REF_2, TMP4); 2610 2611 vis_ld64_2(ref, 8, TMP2); 2612 vis_and(TMP4, MASK_fe, TMP4); 2613 2614 vis_and(REF_0, REF_2, TMP6); 2615 vis_mul8x16(CONST_128, TMP4, TMP4); 2616 2617 vis_alignaddr_g0((void *)off); 2618 2619 vis_faligndata(TMP0, TMP2, REF_0); 2620 2621 if (off != 0x7) { 2622 vis_alignaddr_g0((void *)off_plus_1); 2623 vis_faligndata(TMP0, TMP2, REF_2); 2624 } else { 2625 vis_src1(TMP2, REF_2); 2626 } 2627 2628 vis_and(TMP4, MASK_7f, TMP4); 2629 2630 vis_padd16(TMP6, TMP4, DST_0); 2631 vis_st64(DST_0, dest[0]); 2632 dest += stride; 2633 2634 vis_xor(REF_0, REF_2, TMP12); 2635 2636 vis_and(TMP12, MASK_fe, TMP12); 2637 2638 vis_and(REF_0, REF_2, TMP14); 2639 vis_mul8x16(CONST_128, TMP12, TMP12); 2640 2641 vis_and(TMP12, MASK_7f, TMP12); 2642 2643 vis_padd16(TMP14, TMP12, DST_0); 2644 vis_st64(DST_0, dest[0]); 2645 dest += stride; 2646} 2647 2648static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref, 2649 const int stride, int height) 2650{ 2651 unsigned long off = (unsigned long) ref & 0x7; 2652 unsigned long off_plus_1 = off + 1; 2653 2654 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 2655 2656 vis_ld64(constants3[0], CONST_3); 2657 vis_fzero(ZERO); 2658 vis_ld64(constants256_512[0], CONST_256); 2659 2660 ref = vis_alignaddr(ref); 2661 do { /* 26 cycles */ 2662 vis_ld64(ref[0], TMP0); 2663 2664 vis_ld64(ref[8], TMP2); 2665 2666 vis_alignaddr_g0((void *)off); 2667 2668 vis_ld64(ref[16], TMP4); 2669 2670 vis_ld64(dest[0], DST_0); 2671 vis_faligndata(TMP0, TMP2, REF_0); 2672 2673 vis_ld64(dest[8], DST_2); 2674 vis_faligndata(TMP2, TMP4, REF_4); 2675 2676 if (off != 0x7) { 2677 vis_alignaddr_g0((void *)off_plus_1); 2678 vis_faligndata(TMP0, TMP2, REF_2); 2679 vis_faligndata(TMP2, TMP4, REF_6); 2680 } else { 2681 vis_src1(TMP2, REF_2); 2682 vis_src1(TMP4, REF_6); 2683 } 2684 2685 vis_mul8x16au(REF_0, CONST_256, TMP0); 2686 2687 vis_pmerge(ZERO, REF_2, TMP4); 2688 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 2689 2690 vis_pmerge(ZERO, REF_2_1, TMP6); 2691 2692 vis_padd16(TMP0, TMP4, TMP0); 2693 2694 vis_mul8x16al(DST_0, CONST_512, TMP4); 2695 vis_padd16(TMP2, TMP6, TMP2); 2696 2697 vis_mul8x16al(DST_1, CONST_512, TMP6); 2698 2699 vis_mul8x16au(REF_6, CONST_256, TMP12); 2700 2701 vis_padd16(TMP0, TMP4, TMP0); 2702 vis_mul8x16au(REF_6_1, CONST_256, TMP14); 2703 2704 vis_padd16(TMP2, TMP6, TMP2); 2705 vis_mul8x16au(REF_4, CONST_256, TMP16); 2706 2707 vis_padd16(TMP0, CONST_3, TMP8); 2708 vis_mul8x16au(REF_4_1, CONST_256, TMP18); 2709 2710 vis_padd16(TMP2, CONST_3, TMP10); 2711 vis_pack16(TMP8, DST_0); 2712 2713 vis_pack16(TMP10, DST_1); 2714 vis_padd16(TMP16, TMP12, TMP0); 2715 2716 vis_st64(DST_0, dest[0]); 2717 vis_mul8x16al(DST_2, CONST_512, TMP4); 2718 vis_padd16(TMP18, TMP14, TMP2); 2719 2720 vis_mul8x16al(DST_3, CONST_512, TMP6); 2721 vis_padd16(TMP0, CONST_3, TMP0); 2722 2723 vis_padd16(TMP2, CONST_3, TMP2); 2724 2725 vis_padd16(TMP0, TMP4, TMP0); 2726 2727 vis_padd16(TMP2, TMP6, TMP2); 2728 vis_pack16(TMP0, DST_2); 2729 2730 vis_pack16(TMP2, DST_3); 2731 vis_st64(DST_2, dest[8]); 2732 2733 ref += stride; 2734 dest += stride; 2735 } while (--height); 2736} 2737 2738static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref, 2739 const int stride, int height) 2740{ 2741 unsigned long off = (unsigned long) ref & 0x7; 2742 unsigned long off_plus_1 = off + 1; 2743 int stride_times_2 = stride << 1; 2744 2745 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 2746 2747 vis_ld64(constants3[0], CONST_3); 2748 vis_fzero(ZERO); 2749 vis_ld64(constants256_512[0], CONST_256); 2750 2751 ref = vis_alignaddr(ref); 2752 height >>= 2; 2753 do { /* 47 cycles */ 2754 vis_ld64(ref[0], TMP0); 2755 2756 vis_ld64_2(ref, 8, TMP2); 2757 ref += stride; 2758 2759 vis_alignaddr_g0((void *)off); 2760 2761 vis_ld64(ref[0], TMP4); 2762 vis_faligndata(TMP0, TMP2, REF_0); 2763 2764 vis_ld64_2(ref, 8, TMP6); 2765 ref += stride; 2766 2767 vis_ld64(ref[0], TMP8); 2768 2769 vis_ld64_2(ref, 8, TMP10); 2770 ref += stride; 2771 vis_faligndata(TMP4, TMP6, REF_4); 2772 2773 vis_ld64(ref[0], TMP12); 2774 2775 vis_ld64_2(ref, 8, TMP14); 2776 ref += stride; 2777 vis_faligndata(TMP8, TMP10, REF_S0); 2778 2779 vis_faligndata(TMP12, TMP14, REF_S4); 2780 2781 if (off != 0x7) { 2782 vis_alignaddr_g0((void *)off_plus_1); 2783 2784 vis_ld64(dest[0], DST_0); 2785 vis_faligndata(TMP0, TMP2, REF_2); 2786 2787 vis_ld64_2(dest, stride, DST_2); 2788 vis_faligndata(TMP4, TMP6, REF_6); 2789 2790 vis_faligndata(TMP8, TMP10, REF_S2); 2791 2792 vis_faligndata(TMP12, TMP14, REF_S6); 2793 } else { 2794 vis_ld64(dest[0], DST_0); 2795 vis_src1(TMP2, REF_2); 2796 2797 vis_ld64_2(dest, stride, DST_2); 2798 vis_src1(TMP6, REF_6); 2799 2800 vis_src1(TMP10, REF_S2); 2801 2802 vis_src1(TMP14, REF_S6); 2803 } 2804 2805 vis_pmerge(ZERO, REF_0, TMP0); 2806 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 2807 2808 vis_pmerge(ZERO, REF_2, TMP4); 2809 vis_mul8x16au(REF_2_1, CONST_256, TMP6); 2810 2811 vis_padd16(TMP0, CONST_3, TMP0); 2812 vis_mul8x16al(DST_0, CONST_512, TMP16); 2813 2814 vis_padd16(TMP2, CONST_3, TMP2); 2815 vis_mul8x16al(DST_1, CONST_512, TMP18); 2816 2817 vis_padd16(TMP0, TMP4, TMP0); 2818 vis_mul8x16au(REF_4, CONST_256, TMP8); 2819 2820 vis_padd16(TMP2, TMP6, TMP2); 2821 vis_mul8x16au(REF_4_1, CONST_256, TMP10); 2822 2823 vis_padd16(TMP0, TMP16, TMP0); 2824 vis_mul8x16au(REF_6, CONST_256, TMP12); 2825 2826 vis_padd16(TMP2, TMP18, TMP2); 2827 vis_mul8x16au(REF_6_1, CONST_256, TMP14); 2828 2829 vis_padd16(TMP8, CONST_3, TMP8); 2830 vis_mul8x16al(DST_2, CONST_512, TMP16); 2831 2832 vis_padd16(TMP8, TMP12, TMP8); 2833 vis_mul8x16al(DST_3, CONST_512, TMP18); 2834 2835 vis_padd16(TMP10, TMP14, TMP10); 2836 vis_pack16(TMP0, DST_0); 2837 2838 vis_pack16(TMP2, DST_1); 2839 vis_st64(DST_0, dest[0]); 2840 dest += stride; 2841 vis_padd16(TMP10, CONST_3, TMP10); 2842 2843 vis_ld64_2(dest, stride, DST_0); 2844 vis_padd16(TMP8, TMP16, TMP8); 2845 2846 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/); 2847 vis_padd16(TMP10, TMP18, TMP10); 2848 vis_pack16(TMP8, DST_2); 2849 2850 vis_pack16(TMP10, DST_3); 2851 vis_st64(DST_2, dest[0]); 2852 dest += stride; 2853 2854 vis_mul8x16au(REF_S0_1, CONST_256, TMP2); 2855 vis_pmerge(ZERO, REF_S0, TMP0); 2856 2857 vis_pmerge(ZERO, REF_S2, TMP24); 2858 vis_mul8x16au(REF_S2_1, CONST_256, TMP6); 2859 2860 vis_padd16(TMP0, CONST_3, TMP0); 2861 vis_mul8x16au(REF_S4, CONST_256, TMP8); 2862 2863 vis_padd16(TMP2, CONST_3, TMP2); 2864 vis_mul8x16au(REF_S4_1, CONST_256, TMP10); 2865 2866 vis_padd16(TMP0, TMP24, TMP0); 2867 vis_mul8x16au(REF_S6, CONST_256, TMP12); 2868 2869 vis_padd16(TMP2, TMP6, TMP2); 2870 vis_mul8x16au(REF_S6_1, CONST_256, TMP14); 2871 2872 vis_padd16(TMP8, CONST_3, TMP8); 2873 vis_mul8x16al(DST_0, CONST_512, TMP16); 2874 2875 vis_padd16(TMP10, CONST_3, TMP10); 2876 vis_mul8x16al(DST_1, CONST_512, TMP18); 2877 2878 vis_padd16(TMP8, TMP12, TMP8); 2879 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20); 2880 2881 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22); 2882 vis_padd16(TMP0, TMP16, TMP0); 2883 2884 vis_padd16(TMP2, TMP18, TMP2); 2885 vis_pack16(TMP0, DST_0); 2886 2887 vis_padd16(TMP10, TMP14, TMP10); 2888 vis_pack16(TMP2, DST_1); 2889 vis_st64(DST_0, dest[0]); 2890 dest += stride; 2891 2892 vis_padd16(TMP8, TMP20, TMP8); 2893 2894 vis_padd16(TMP10, TMP22, TMP10); 2895 vis_pack16(TMP8, DST_2); 2896 2897 vis_pack16(TMP10, DST_3); 2898 vis_st64(DST_2, dest[0]); 2899 dest += stride; 2900 } while (--height); 2901} 2902 2903static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref, 2904 const int stride, int height) 2905{ 2906 ref = vis_alignaddr(ref); 2907 vis_ld64(ref[0], TMP0); 2908 2909 vis_ld64_2(ref, 8, TMP2); 2910 2911 vis_ld64_2(ref, 16, TMP4); 2912 ref += stride; 2913 2914 vis_ld64(ref[0], TMP6); 2915 vis_faligndata(TMP0, TMP2, REF_0); 2916 2917 vis_ld64_2(ref, 8, TMP8); 2918 vis_faligndata(TMP2, TMP4, REF_4); 2919 2920 vis_ld64_2(ref, 16, TMP10); 2921 ref += stride; 2922 2923 vis_ld64(constants_fe[0], MASK_fe); 2924 vis_faligndata(TMP6, TMP8, REF_2); 2925 2926 vis_ld64(constants_7f[0], MASK_7f); 2927 vis_faligndata(TMP8, TMP10, REF_6); 2928 2929 vis_ld64(constants128[0], CONST_128); 2930 height = (height >> 1) - 1; 2931 do { /* 24 cycles */ 2932 vis_ld64(ref[0], TMP0); 2933 vis_xor(REF_0, REF_2, TMP12); 2934 2935 vis_ld64_2(ref, 8, TMP2); 2936 vis_xor(REF_4, REF_6, TMP16); 2937 2938 vis_ld64_2(ref, 16, TMP4); 2939 ref += stride; 2940 vis_and(REF_0, REF_2, TMP14); 2941 2942 vis_ld64(ref[0], TMP6); 2943 vis_and(REF_4, REF_6, TMP18); 2944 2945 vis_ld64_2(ref, 8, TMP8); 2946 vis_faligndata(TMP0, TMP2, REF_0); 2947 2948 vis_ld64_2(ref, 16, TMP10); 2949 ref += stride; 2950 vis_faligndata(TMP2, TMP4, REF_4); 2951 2952 vis_and(TMP12, MASK_fe, TMP12); 2953 2954 vis_and(TMP16, MASK_fe, TMP16); 2955 vis_mul8x16(CONST_128, TMP12, TMP12); 2956 2957 vis_mul8x16(CONST_128, TMP16, TMP16); 2958 vis_xor(REF_0, REF_2, TMP0); 2959 2960 vis_xor(REF_4, REF_6, TMP2); 2961 2962 vis_and(REF_0, REF_2, TMP20); 2963 2964 vis_and(TMP12, MASK_7f, TMP12); 2965 2966 vis_and(TMP16, MASK_7f, TMP16); 2967 2968 vis_padd16(TMP14, TMP12, TMP12); 2969 vis_st64(TMP12, dest[0]); 2970 2971 vis_padd16(TMP18, TMP16, TMP16); 2972 vis_st64_2(TMP16, dest, 8); 2973 dest += stride; 2974 2975 vis_and(REF_4, REF_6, TMP18); 2976 2977 vis_and(TMP0, MASK_fe, TMP0); 2978 2979 vis_and(TMP2, MASK_fe, TMP2); 2980 vis_mul8x16(CONST_128, TMP0, TMP0); 2981 2982 vis_faligndata(TMP6, TMP8, REF_2); 2983 vis_mul8x16(CONST_128, TMP2, TMP2); 2984 2985 vis_faligndata(TMP8, TMP10, REF_6); 2986 2987 vis_and(TMP0, MASK_7f, TMP0); 2988 2989 vis_and(TMP2, MASK_7f, TMP2); 2990 2991 vis_padd16(TMP20, TMP0, TMP0); 2992 vis_st64(TMP0, dest[0]); 2993 2994 vis_padd16(TMP18, TMP2, TMP2); 2995 vis_st64_2(TMP2, dest, 8); 2996 dest += stride; 2997 } while (--height); 2998 2999 vis_ld64(ref[0], TMP0); 3000 vis_xor(REF_0, REF_2, TMP12); 3001 3002 vis_ld64_2(ref, 8, TMP2); 3003 vis_xor(REF_4, REF_6, TMP16); 3004 3005 vis_ld64_2(ref, 16, TMP4); 3006 vis_and(REF_0, REF_2, TMP14); 3007 3008 vis_and(REF_4, REF_6, TMP18); 3009 3010 vis_faligndata(TMP0, TMP2, REF_0); 3011 3012 vis_faligndata(TMP2, TMP4, REF_4); 3013 3014 vis_and(TMP12, MASK_fe, TMP12); 3015 3016 vis_and(TMP16, MASK_fe, TMP16); 3017 vis_mul8x16(CONST_128, TMP12, TMP12); 3018 3019 vis_mul8x16(CONST_128, TMP16, TMP16); 3020 vis_xor(REF_0, REF_2, TMP0); 3021 3022 vis_xor(REF_4, REF_6, TMP2); 3023 3024 vis_and(REF_0, REF_2, TMP20); 3025 3026 vis_and(TMP12, MASK_7f, TMP12); 3027 3028 vis_and(TMP16, MASK_7f, TMP16); 3029 3030 vis_padd16(TMP14, TMP12, TMP12); 3031 vis_st64(TMP12, dest[0]); 3032 3033 vis_padd16(TMP18, TMP16, TMP16); 3034 vis_st64_2(TMP16, dest, 8); 3035 dest += stride; 3036 3037 vis_and(REF_4, REF_6, TMP18); 3038 3039 vis_and(TMP0, MASK_fe, TMP0); 3040 3041 vis_and(TMP2, MASK_fe, TMP2); 3042 vis_mul8x16(CONST_128, TMP0, TMP0); 3043 3044 vis_mul8x16(CONST_128, TMP2, TMP2); 3045 3046 vis_and(TMP0, MASK_7f, TMP0); 3047 3048 vis_and(TMP2, MASK_7f, TMP2); 3049 3050 vis_padd16(TMP20, TMP0, TMP0); 3051 vis_st64(TMP0, dest[0]); 3052 3053 vis_padd16(TMP18, TMP2, TMP2); 3054 vis_st64_2(TMP2, dest, 8); 3055} 3056 3057static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref, 3058 const int stride, int height) 3059{ 3060 ref = vis_alignaddr(ref); 3061 vis_ld64(ref[0], TMP0); 3062 3063 vis_ld64_2(ref, 8, TMP2); 3064 ref += stride; 3065 3066 vis_ld64(ref[0], TMP4); 3067 3068 vis_ld64_2(ref, 8, TMP6); 3069 ref += stride; 3070 3071 vis_ld64(constants_fe[0], MASK_fe); 3072 vis_faligndata(TMP0, TMP2, REF_0); 3073 3074 vis_ld64(constants_7f[0], MASK_7f); 3075 vis_faligndata(TMP4, TMP6, REF_2); 3076 3077 vis_ld64(constants128[0], CONST_128); 3078 height = (height >> 1) - 1; 3079 do { /* 12 cycles */ 3080 vis_ld64(ref[0], TMP0); 3081 vis_xor(REF_0, REF_2, TMP4); 3082 3083 vis_ld64_2(ref, 8, TMP2); 3084 ref += stride; 3085 vis_and(TMP4, MASK_fe, TMP4); 3086 3087 vis_and(REF_0, REF_2, TMP6); 3088 vis_mul8x16(CONST_128, TMP4, TMP4); 3089 3090 vis_faligndata(TMP0, TMP2, REF_0); 3091 vis_ld64(ref[0], TMP0); 3092 3093 vis_ld64_2(ref, 8, TMP2); 3094 ref += stride; 3095 vis_xor(REF_0, REF_2, TMP12); 3096 3097 vis_and(TMP4, MASK_7f, TMP4); 3098 3099 vis_and(TMP12, MASK_fe, TMP12); 3100 3101 vis_mul8x16(CONST_128, TMP12, TMP12); 3102 vis_and(REF_0, REF_2, TMP14); 3103 3104 vis_padd16(TMP6, TMP4, DST_0); 3105 vis_st64(DST_0, dest[0]); 3106 dest += stride; 3107 3108 vis_faligndata(TMP0, TMP2, REF_2); 3109 3110 vis_and(TMP12, MASK_7f, TMP12); 3111 3112 vis_padd16(TMP14, TMP12, DST_0); 3113 vis_st64(DST_0, dest[0]); 3114 dest += stride; 3115 } while (--height); 3116 3117 vis_ld64(ref[0], TMP0); 3118 vis_xor(REF_0, REF_2, TMP4); 3119 3120 vis_ld64_2(ref, 8, TMP2); 3121 vis_and(TMP4, MASK_fe, TMP4); 3122 3123 vis_and(REF_0, REF_2, TMP6); 3124 vis_mul8x16(CONST_128, TMP4, TMP4); 3125 3126 vis_faligndata(TMP0, TMP2, REF_0); 3127 3128 vis_xor(REF_0, REF_2, TMP12); 3129 3130 vis_and(TMP4, MASK_7f, TMP4); 3131 3132 vis_and(TMP12, MASK_fe, TMP12); 3133 3134 vis_mul8x16(CONST_128, TMP12, TMP12); 3135 vis_and(REF_0, REF_2, TMP14); 3136 3137 vis_padd16(TMP6, TMP4, DST_0); 3138 vis_st64(DST_0, dest[0]); 3139 dest += stride; 3140 3141 vis_and(TMP12, MASK_7f, TMP12); 3142 3143 vis_padd16(TMP14, TMP12, DST_0); 3144 vis_st64(DST_0, dest[0]); 3145} 3146 3147static void MC_avg_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref, 3148 const int stride, int height) 3149{ 3150 int stride_8 = stride + 8; 3151 int stride_16 = stride + 16; 3152 3153 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 3154 3155 ref = vis_alignaddr(ref); 3156 3157 vis_ld64(ref[ 0], TMP0); 3158 vis_fzero(ZERO); 3159 3160 vis_ld64(ref[ 8], TMP2); 3161 3162 vis_ld64(ref[16], TMP4); 3163 3164 vis_ld64(constants3[0], CONST_3); 3165 vis_faligndata(TMP0, TMP2, REF_2); 3166 3167 vis_ld64(constants256_512[0], CONST_256); 3168 vis_faligndata(TMP2, TMP4, REF_6); 3169 height >>= 1; 3170 3171 do { /* 31 cycles */ 3172 vis_ld64_2(ref, stride, TMP0); 3173 vis_pmerge(ZERO, REF_2, TMP12); 3174 vis_mul8x16au(REF_2_1, CONST_256, TMP14); 3175 3176 vis_ld64_2(ref, stride_8, TMP2); 3177 vis_pmerge(ZERO, REF_6, TMP16); 3178 vis_mul8x16au(REF_6_1, CONST_256, TMP18); 3179 3180 vis_ld64_2(ref, stride_16, TMP4); 3181 ref += stride; 3182 3183 vis_ld64(dest[0], DST_0); 3184 vis_faligndata(TMP0, TMP2, REF_0); 3185 3186 vis_ld64_2(dest, 8, DST_2); 3187 vis_faligndata(TMP2, TMP4, REF_4); 3188 3189 vis_ld64_2(ref, stride, TMP6); 3190 vis_pmerge(ZERO, REF_0, TMP0); 3191 vis_mul8x16au(REF_0_1, CONST_256, TMP2); 3192 3193 vis_ld64_2(ref, stride_8, TMP8); 3194 vis_pmerge(ZERO, REF_4, TMP4); 3195 3196 vis_ld64_2(ref, stride_16, TMP10); 3197 ref += stride; 3198 3199 vis_ld64_2(dest, stride, REF_S0/*DST_4*/); 3200 vis_faligndata(TMP6, TMP8, REF_2); 3201 vis_mul8x16au(REF_4_1, CONST_256, TMP6); 3202 3203 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/); 3204 vis_faligndata(TMP8, TMP10, REF_6); 3205 vis_mul8x16al(DST_0, CONST_512, TMP20); 3206 3207 vis_padd16(TMP0, CONST_3, TMP0); 3208 vis_mul8x16al(DST_1, CONST_512, TMP22); 3209 3210 vis_padd16(TMP2, CONST_3, TMP2); 3211 vis_mul8x16al(DST_2, CONST_512, TMP24); 3212 3213 vis_padd16(TMP4, CONST_3, TMP4); 3214 vis_mul8x16al(DST_3, CONST_512, TMP26); 3215 3216 vis_padd16(TMP6, CONST_3, TMP6); 3217 3218 vis_padd16(TMP12, TMP20, TMP12); 3219 vis_mul8x16al(REF_S0, CONST_512, TMP20); 3220 3221 vis_padd16(TMP14, TMP22, TMP14); 3222 vis_mul8x16al(REF_S0_1, CONST_512, TMP22); 3223 3224 vis_padd16(TMP16, TMP24, TMP16); 3225 vis_mul8x16al(REF_S2, CONST_512, TMP24); 3226 3227 vis_padd16(TMP18, TMP26, TMP18); 3228 vis_mul8x16al(REF_S2_1, CONST_512, TMP26); 3229 3230 vis_padd16(TMP12, TMP0, TMP12); 3231 vis_mul8x16au(REF_2, CONST_256, TMP28); 3232 3233 vis_padd16(TMP14, TMP2, TMP14); 3234 vis_mul8x16au(REF_2_1, CONST_256, TMP30); 3235 3236 vis_padd16(TMP16, TMP4, TMP16); 3237 vis_mul8x16au(REF_6, CONST_256, REF_S4); 3238 3239 vis_padd16(TMP18, TMP6, TMP18); 3240 vis_mul8x16au(REF_6_1, CONST_256, REF_S6); 3241 3242 vis_pack16(TMP12, DST_0); 3243 vis_padd16(TMP28, TMP0, TMP12); 3244 3245 vis_pack16(TMP14, DST_1); 3246 vis_st64(DST_0, dest[0]); 3247 vis_padd16(TMP30, TMP2, TMP14); 3248 3249 vis_pack16(TMP16, DST_2); 3250 vis_padd16(REF_S4, TMP4, TMP16); 3251 3252 vis_pack16(TMP18, DST_3); 3253 vis_st64_2(DST_2, dest, 8); 3254 dest += stride; 3255 vis_padd16(REF_S6, TMP6, TMP18); 3256 3257 vis_padd16(TMP12, TMP20, TMP12); 3258 3259 vis_padd16(TMP14, TMP22, TMP14); 3260 vis_pack16(TMP12, DST_0); 3261 3262 vis_padd16(TMP16, TMP24, TMP16); 3263 vis_pack16(TMP14, DST_1); 3264 vis_st64(DST_0, dest[0]); 3265 3266 vis_padd16(TMP18, TMP26, TMP18); 3267 vis_pack16(TMP16, DST_2); 3268 3269 vis_pack16(TMP18, DST_3); 3270 vis_st64_2(DST_2, dest, 8); 3271 dest += stride; 3272 } while (--height); 3273} 3274 3275static void MC_avg_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref, 3276 const int stride, int height) 3277{ 3278 int stride_8 = stride + 8; 3279 3280 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 3281 3282 ref = vis_alignaddr(ref); 3283 3284 vis_ld64(ref[ 0], TMP0); 3285 vis_fzero(ZERO); 3286 3287 vis_ld64(ref[ 8], TMP2); 3288 3289 vis_ld64(constants3[0], CONST_3); 3290 vis_faligndata(TMP0, TMP2, REF_2); 3291 3292 vis_ld64(constants256_512[0], CONST_256); 3293 3294 height >>= 1; 3295 do { /* 20 cycles */ 3296 vis_ld64_2(ref, stride, TMP0); 3297 vis_pmerge(ZERO, REF_2, TMP8); 3298 vis_mul8x16au(REF_2_1, CONST_256, TMP10); 3299 3300 vis_ld64_2(ref, stride_8, TMP2); 3301 ref += stride; 3302 3303 vis_ld64(dest[0], DST_0); 3304 3305 vis_ld64_2(dest, stride, DST_2); 3306 vis_faligndata(TMP0, TMP2, REF_0); 3307 3308 vis_ld64_2(ref, stride, TMP4); 3309 vis_mul8x16al(DST_0, CONST_512, TMP16); 3310 vis_pmerge(ZERO, REF_0, TMP12); 3311 3312 vis_ld64_2(ref, stride_8, TMP6); 3313 ref += stride; 3314 vis_mul8x16al(DST_1, CONST_512, TMP18); 3315 vis_pmerge(ZERO, REF_0_1, TMP14); 3316 3317 vis_padd16(TMP12, CONST_3, TMP12); 3318 vis_mul8x16al(DST_2, CONST_512, TMP24); 3319 3320 vis_padd16(TMP14, CONST_3, TMP14); 3321 vis_mul8x16al(DST_3, CONST_512, TMP26); 3322 3323 vis_faligndata(TMP4, TMP6, REF_2); 3324 3325 vis_padd16(TMP8, TMP12, TMP8); 3326 3327 vis_padd16(TMP10, TMP14, TMP10); 3328 vis_mul8x16au(REF_2, CONST_256, TMP20); 3329 3330 vis_padd16(TMP8, TMP16, TMP0); 3331 vis_mul8x16au(REF_2_1, CONST_256, TMP22); 3332 3333 vis_padd16(TMP10, TMP18, TMP2); 3334 vis_pack16(TMP0, DST_0); 3335 3336 vis_pack16(TMP2, DST_1); 3337 vis_st64(DST_0, dest[0]); 3338 dest += stride; 3339 vis_padd16(TMP12, TMP20, TMP12); 3340 3341 vis_padd16(TMP14, TMP22, TMP14); 3342 3343 vis_padd16(TMP12, TMP24, TMP0); 3344 3345 vis_padd16(TMP14, TMP26, TMP2); 3346 vis_pack16(TMP0, DST_2); 3347 3348 vis_pack16(TMP2, DST_3); 3349 vis_st64(DST_2, dest[0]); 3350 dest += stride; 3351 } while (--height); 3352} 3353 3354static void MC_put_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref, 3355 const int stride, int height) 3356{ 3357 unsigned long off = (unsigned long) ref & 0x7; 3358 unsigned long off_plus_1 = off + 1; 3359 int stride_8 = stride + 8; 3360 int stride_16 = stride + 16; 3361 3362 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 3363 3364 ref = vis_alignaddr(ref); 3365 3366 vis_ld64(ref[ 0], TMP0); 3367 vis_fzero(ZERO); 3368 3369 vis_ld64(ref[ 8], TMP2); 3370 3371 vis_ld64(ref[16], TMP4); 3372 3373 vis_ld64(constants1[0], CONST_1); 3374 vis_faligndata(TMP0, TMP2, REF_S0); 3375 3376 vis_ld64(constants256_512[0], CONST_256); 3377 vis_faligndata(TMP2, TMP4, REF_S4); 3378 3379 if (off != 0x7) { 3380 vis_alignaddr_g0((void *)off_plus_1); 3381 vis_faligndata(TMP0, TMP2, REF_S2); 3382 vis_faligndata(TMP2, TMP4, REF_S6); 3383 } else { 3384 vis_src1(TMP2, REF_S2); 3385 vis_src1(TMP4, REF_S6); 3386 } 3387 3388 height >>= 1; 3389 do { 3390 vis_ld64_2(ref, stride, TMP0); 3391 vis_mul8x16au(REF_S0, CONST_256, TMP12); 3392 vis_pmerge(ZERO, REF_S0_1, TMP14); 3393 3394 vis_alignaddr_g0((void *)off); 3395 3396 vis_ld64_2(ref, stride_8, TMP2); 3397 vis_mul8x16au(REF_S2, CONST_256, TMP16); 3398 vis_pmerge(ZERO, REF_S2_1, TMP18); 3399 3400 vis_ld64_2(ref, stride_16, TMP4); 3401 ref += stride; 3402 vis_mul8x16au(REF_S4, CONST_256, TMP20); 3403 vis_pmerge(ZERO, REF_S4_1, TMP22); 3404 3405 vis_ld64_2(ref, stride, TMP6); 3406 vis_mul8x16au(REF_S6, CONST_256, TMP24); 3407 vis_pmerge(ZERO, REF_S6_1, TMP26); 3408 3409 vis_ld64_2(ref, stride_8, TMP8); 3410 vis_faligndata(TMP0, TMP2, REF_0); 3411 3412 vis_ld64_2(ref, stride_16, TMP10); 3413 ref += stride; 3414 vis_faligndata(TMP2, TMP4, REF_4); 3415 3416 vis_faligndata(TMP6, TMP8, REF_S0); 3417 3418 vis_faligndata(TMP8, TMP10, REF_S4); 3419 3420 if (off != 0x7) { 3421 vis_alignaddr_g0((void *)off_plus_1); 3422 vis_faligndata(TMP0, TMP2, REF_2); 3423 vis_faligndata(TMP2, TMP4, REF_6); 3424 vis_faligndata(TMP6, TMP8, REF_S2); 3425 vis_faligndata(TMP8, TMP10, REF_S6); 3426 } else { 3427 vis_src1(TMP2, REF_2); 3428 vis_src1(TMP4, REF_6); 3429 vis_src1(TMP8, REF_S2); 3430 vis_src1(TMP10, REF_S6); 3431 } 3432 3433 vis_mul8x16au(REF_0, CONST_256, TMP0); 3434 vis_pmerge(ZERO, REF_0_1, TMP2); 3435 3436 vis_mul8x16au(REF_2, CONST_256, TMP4); 3437 vis_pmerge(ZERO, REF_2_1, TMP6); 3438 3439 vis_padd16(TMP0, CONST_2, TMP8); 3440 vis_mul8x16au(REF_4, CONST_256, TMP0); 3441 3442 vis_padd16(TMP2, CONST_1, TMP10); 3443 vis_mul8x16au(REF_4_1, CONST_256, TMP2); 3444 3445 vis_padd16(TMP8, TMP4, TMP8); 3446 vis_mul8x16au(REF_6, CONST_256, TMP4); 3447 3448 vis_padd16(TMP10, TMP6, TMP10); 3449 vis_mul8x16au(REF_6_1, CONST_256, TMP6); 3450 3451 vis_padd16(TMP12, TMP8, TMP12); 3452 3453 vis_padd16(TMP14, TMP10, TMP14); 3454 3455 vis_padd16(TMP12, TMP16, TMP12); 3456 3457 vis_padd16(TMP14, TMP18, TMP14); 3458 vis_pack16(TMP12, DST_0); 3459 3460 vis_pack16(TMP14, DST_1); 3461 vis_st64(DST_0, dest[0]); 3462 vis_padd16(TMP0, CONST_1, TMP12); 3463 3464 vis_mul8x16au(REF_S0, CONST_256, TMP0); 3465 vis_padd16(TMP2, CONST_1, TMP14); 3466 3467 vis_mul8x16au(REF_S0_1, CONST_256, TMP2); 3468 vis_padd16(TMP12, TMP4, TMP12); 3469 3470 vis_mul8x16au(REF_S2, CONST_256, TMP4); 3471 vis_padd16(TMP14, TMP6, TMP14); 3472 3473 vis_mul8x16au(REF_S2_1, CONST_256, TMP6); 3474 vis_padd16(TMP20, TMP12, TMP20); 3475 3476 vis_padd16(TMP22, TMP14, TMP22); 3477 3478 vis_padd16(TMP20, TMP24, TMP20); 3479 3480 vis_padd16(TMP22, TMP26, TMP22); 3481 vis_pack16(TMP20, DST_2); 3482 3483 vis_pack16(TMP22, DST_3); 3484 vis_st64_2(DST_2, dest, 8); 3485 dest += stride; 3486 vis_padd16(TMP0, TMP4, TMP24); 3487 3488 vis_mul8x16au(REF_S4, CONST_256, TMP0); 3489 vis_padd16(TMP2, TMP6, TMP26); 3490 3491 vis_mul8x16au(REF_S4_1, CONST_256, TMP2); 3492 vis_padd16(TMP24, TMP8, TMP24); 3493 3494 vis_padd16(TMP26, TMP10, TMP26); 3495 vis_pack16(TMP24, DST_0); 3496 3497 vis_pack16(TMP26, DST_1); 3498 vis_st64(DST_0, dest[0]); 3499 vis_pmerge(ZERO, REF_S6, TMP4); 3500 3501 vis_pmerge(ZERO, REF_S6_1, TMP6); 3502 3503 vis_padd16(TMP0, TMP4, TMP0); 3504 3505 vis_padd16(TMP2, TMP6, TMP2); 3506 3507 vis_padd16(TMP0, TMP12, TMP0); 3508 3509 vis_padd16(TMP2, TMP14, TMP2); 3510 vis_pack16(TMP0, DST_2); 3511 3512 vis_pack16(TMP2, DST_3); 3513 vis_st64_2(DST_2, dest, 8); 3514 dest += stride; 3515 } while (--height); 3516} 3517 3518static void MC_put_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref, 3519 const int stride, int height) 3520{ 3521 unsigned long off = (unsigned long) ref & 0x7; 3522 unsigned long off_plus_1 = off + 1; 3523 int stride_8 = stride + 8; 3524 3525 vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT); 3526 3527 ref = vis_alignaddr(ref); 3528 3529 vis_ld64(ref[ 0], TMP0); 3530 vis_fzero(ZERO); 3531 3532 vis_ld64(ref[ 8], TMP2); 3533 3534 vis_ld64(constants1[0], CONST_1); 3535 3536 vis_ld64(constants256_512[0], CONST_256); 3537 vis_faligndata(TMP0, TMP2, REF_S0); 3538 3539 if (off != 0x7) { 3540 vis_alignaddr_g0((void *)off_plus_1); 3541 vis_faligndata(TMP0, TMP2, REF_S2); 3542 } else { 3543 vis_src1(TMP2, REF_S2); 3544 } 3545 3546 height >>= 1; 3547 do { /* 26 cycles */ 3548 vis_ld64_2(ref, stride, TMP0); 3549 vis_mul8x16au(REF_S0, CONST_256, TMP8); 3550 vis_pmerge(ZERO, REF_S2, TMP12); 3551 3552 vis_alignaddr_g0((void *)off); 3553 3554 vis_ld64_2(ref, stride_8, TMP2); 3555 ref += stride; 3556 vis_mul8x16au(REF_S0_1, CONST_256, TMP10); 3557 vis_pmerge(ZERO, REF_S2_1, TMP14); 3558 3559 vis_ld64_2(ref, stride, TMP4); 3560 3561 vis_ld64_2(ref, stride_8, TMP6); 3562 ref += stride; 3563 vis_faligndata(TMP0, TMP2, REF_S4); 3564 3565 vis_pmerge(ZERO, REF_S4, TMP18); 3566 3567 vis_pmerge(ZERO, REF_S4_1, TMP20); 3568 3569 vis_faligndata(TMP4, TMP6, REF_S0); 3570 3571 if (off != 0x7) { 3572 vis_alignaddr_g0((void *)off_plus_1); 3573 vis_faligndata(TMP0, TMP2, REF_S6); 3574 vis_faligndata(TMP4, TMP6, REF_S2); 3575 } else { 3576 vis_src1(TMP2, REF_S6); 3577 vis_src1(TMP6, REF_S2); 3578 } 3579 3580 vis_padd16(TMP18, CONST_1, TMP18); 3581 vis_mul8x16au(REF_S6, CONST_256, TMP22); 3582 3583 vis_padd16(TMP20, CONST_1, TMP20); 3584 vis_mul8x16au(REF_S6_1, CONST_256, TMP24); 3585 3586 vis_mul8x16au(REF_S0, CONST_256, TMP26); 3587 vis_pmerge(ZERO, REF_S0_1, TMP28); 3588 3589 vis_mul8x16au(REF_S2, CONST_256, TMP30); 3590 vis_padd16(TMP18, TMP22, TMP18); 3591 3592 vis_mul8x16au(REF_S2_1, CONST_256, TMP32); 3593 vis_padd16(TMP20, TMP24, TMP20); 3594 3595 vis_padd16(TMP8, TMP18, TMP8); 3596 3597 vis_padd16(TMP10, TMP20, TMP10); 3598 3599 vis_padd16(TMP8, TMP12, TMP8); 3600 3601 vis_padd16(TMP10, TMP14, TMP10); 3602 vis_pack16(TMP8, DST_0); 3603 3604 vis_pack16(TMP10, DST_1); 3605 vis_st64(DST_0, dest[0]); 3606 dest += stride; 3607 vis_padd16(TMP18, TMP26, TMP18); 3608 3609 vis_padd16(TMP20, TMP28, TMP20); 3610 3611 vis_padd16(TMP18, TMP30, TMP18); 3612 3613 vis_padd16(TMP20, TMP32, TMP20); 3614 vis_pack16(TMP18, DST_2); 3615 3616 vis_pack16(TMP20, DST_3); 3617 vis_st64(DST_2, dest[0]); 3618 dest += stride; 3619 } while (--height); 3620} 3621 3622static void MC_avg_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref, 3623 const int stride, int height) 3624{ 3625 unsigned long off = (unsigned long) ref & 0x7; 3626 unsigned long off_plus_1 = off + 1; 3627 int stride_8 = stride + 8; 3628 int stride_16 = stride + 16; 3629 3630 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT); 3631 3632 ref = vis_alignaddr(ref); 3633 3634 vis_ld64(ref[ 0], TMP0); 3635 vis_fzero(ZERO); 3636 3637 vis_ld64(ref[ 8], TMP2); 3638 3639 vis_ld64(ref[16], TMP4); 3640 3641 vis_ld64(constants6[0], CONST_6); 3642 vis_faligndata(TMP0, TMP2, REF_S0); 3643 3644 vis_ld64(constants256_1024[0], CONST_256); 3645 vis_faligndata(TMP2, TMP4, REF_S4); 3646 3647 if (off != 0x7) { 3648 vis_alignaddr_g0((void *)off_plus_1); 3649 vis_faligndata(TMP0, TMP2, REF_S2); 3650 vis_faligndata(TMP2, TMP4, REF_S6); 3651 } else { 3652 vis_src1(TMP2, REF_S2); 3653 vis_src1(TMP4, REF_S6); 3654 } 3655 3656 height >>= 1; 3657 do { /* 55 cycles */ 3658 vis_ld64_2(ref, stride, TMP0); 3659 vis_mul8x16au(REF_S0, CONST_256, TMP12); 3660 vis_pmerge(ZERO, REF_S0_1, TMP14); 3661 3662 vis_alignaddr_g0((void *)off); 3663 3664 vis_ld64_2(ref, stride_8, TMP2); 3665 vis_mul8x16au(REF_S2, CONST_256, TMP16); 3666 vis_pmerge(ZERO, REF_S2_1, TMP18); 3667 3668 vis_ld64_2(ref, stride_16, TMP4); 3669 ref += stride; 3670 vis_mul8x16au(REF_S4, CONST_256, TMP20); 3671 vis_pmerge(ZERO, REF_S4_1, TMP22); 3672 3673 vis_ld64_2(ref, stride, TMP6); 3674 vis_mul8x16au(REF_S6, CONST_256, TMP24); 3675 vis_pmerge(ZERO, REF_S6_1, TMP26); 3676 3677 vis_ld64_2(ref, stride_8, TMP8); 3678 vis_faligndata(TMP0, TMP2, REF_0); 3679 3680 vis_ld64_2(ref, stride_16, TMP10); 3681 ref += stride; 3682 vis_faligndata(TMP2, TMP4, REF_4); 3683 3684 vis_ld64(dest[0], DST_0); 3685 vis_faligndata(TMP6, TMP8, REF_S0); 3686 3687 vis_ld64_2(dest, 8, DST_2); 3688 vis_faligndata(TMP8, TMP10, REF_S4); 3689 3690 if (off != 0x7) { 3691 vis_alignaddr_g0((void *)off_plus_1); 3692 vis_faligndata(TMP0, TMP2, REF_2); 3693 vis_faligndata(TMP2, TMP4, REF_6); 3694 vis_faligndata(TMP6, TMP8, REF_S2); 3695 vis_faligndata(TMP8, TMP10, REF_S6); 3696 } else { 3697 vis_src1(TMP2, REF_2); 3698 vis_src1(TMP4, REF_6); 3699 vis_src1(TMP8, REF_S2); 3700 vis_src1(TMP10, REF_S6); 3701 } 3702 3703 vis_mul8x16al(DST_0, CONST_1024, TMP30); 3704 vis_pmerge(ZERO, REF_0, TMP0); 3705 3706 vis_mul8x16al(DST_1, CONST_1024, TMP32); 3707 vis_pmerge(ZERO, REF_0_1, TMP2); 3708 3709 vis_mul8x16au(REF_2, CONST_256, TMP4); 3710 vis_pmerge(ZERO, REF_2_1, TMP6); 3711 3712 vis_mul8x16al(DST_2, CONST_1024, REF_0); 3713 vis_padd16(TMP0, CONST_6, TMP0); 3714 3715 vis_mul8x16al(DST_3, CONST_1024, REF_2); 3716 vis_padd16(TMP2, CONST_6, TMP2); 3717 3718 vis_padd16(TMP0, TMP4, TMP0); 3719 vis_mul8x16au(REF_4, CONST_256, TMP4); 3720 3721 vis_padd16(TMP2, TMP6, TMP2); 3722 vis_mul8x16au(REF_4_1, CONST_256, TMP6); 3723 3724 vis_padd16(TMP12, TMP0, TMP12); 3725 vis_mul8x16au(REF_6, CONST_256, TMP8); 3726 3727 vis_padd16(TMP14, TMP2, TMP14); 3728 vis_mul8x16au(REF_6_1, CONST_256, TMP10); 3729 3730 vis_padd16(TMP12, TMP16, TMP12); 3731 vis_mul8x16au(REF_S0, CONST_256, REF_4); 3732 3733 vis_padd16(TMP14, TMP18, TMP14); 3734 vis_mul8x16au(REF_S0_1, CONST_256, REF_6); 3735 3736 vis_padd16(TMP12, TMP30, TMP12); 3737 3738 vis_padd16(TMP14, TMP32, TMP14); 3739 vis_pack16(TMP12, DST_0); 3740 3741 vis_pack16(TMP14, DST_1); 3742 vis_st64(DST_0, dest[0]); 3743 vis_padd16(TMP4, CONST_6, TMP4); 3744 3745 vis_ld64_2(dest, stride, DST_0); 3746 vis_padd16(TMP6, CONST_6, TMP6); 3747 vis_mul8x16au(REF_S2, CONST_256, TMP12); 3748 3749 vis_padd16(TMP4, TMP8, TMP4); 3750 vis_mul8x16au(REF_S2_1, CONST_256, TMP14); 3751 3752 vis_padd16(TMP6, TMP10, TMP6); 3753 3754 vis_padd16(TMP20, TMP4, TMP20); 3755 3756 vis_padd16(TMP22, TMP6, TMP22); 3757 3758 vis_padd16(TMP20, TMP24, TMP20); 3759 3760 vis_padd16(TMP22, TMP26, TMP22); 3761 3762 vis_padd16(TMP20, REF_0, TMP20); 3763 vis_mul8x16au(REF_S4, CONST_256, REF_0); 3764 3765 vis_padd16(TMP22, REF_2, TMP22); 3766 vis_pack16(TMP20, DST_2); 3767 3768 vis_pack16(TMP22, DST_3); 3769 vis_st64_2(DST_2, dest, 8); 3770 dest += stride; 3771 3772 vis_ld64_2(dest, 8, DST_2); 3773 vis_mul8x16al(DST_0, CONST_1024, TMP30); 3774 vis_pmerge(ZERO, REF_S4_1, REF_2); 3775 3776 vis_mul8x16al(DST_1, CONST_1024, TMP32); 3777 vis_padd16(REF_4, TMP0, TMP8); 3778 3779 vis_mul8x16au(REF_S6, CONST_256, REF_4); 3780 vis_padd16(REF_6, TMP2, TMP10); 3781 3782 vis_mul8x16au(REF_S6_1, CONST_256, REF_6); 3783 vis_padd16(TMP8, TMP12, TMP8); 3784 3785 vis_padd16(TMP10, TMP14, TMP10); 3786 3787 vis_padd16(TMP8, TMP30, TMP8); 3788 3789 vis_padd16(TMP10, TMP32, TMP10); 3790 vis_pack16(TMP8, DST_0); 3791 3792 vis_pack16(TMP10, DST_1); 3793 vis_st64(DST_0, dest[0]); 3794 3795 vis_padd16(REF_0, TMP4, REF_0); 3796 3797 vis_mul8x16al(DST_2, CONST_1024, TMP30); 3798 vis_padd16(REF_2, TMP6, REF_2); 3799 3800 vis_mul8x16al(DST_3, CONST_1024, TMP32); 3801 vis_padd16(REF_0, REF_4, REF_0); 3802 3803 vis_padd16(REF_2, REF_6, REF_2); 3804 3805 vis_padd16(REF_0, TMP30, REF_0); 3806 3807 /* stall */ 3808 3809 vis_padd16(REF_2, TMP32, REF_2); 3810 vis_pack16(REF_0, DST_2); 3811 3812 vis_pack16(REF_2, DST_3); 3813 vis_st64_2(DST_2, dest, 8); 3814 dest += stride; 3815 } while (--height); 3816} 3817 3818static void MC_avg_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref, 3819 const int stride, int height) 3820{ 3821 unsigned long off = (unsigned long) ref & 0x7; 3822 unsigned long off_plus_1 = off + 1; 3823 int stride_8 = stride + 8; 3824 3825 vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT); 3826 3827 ref = vis_alignaddr(ref); 3828 3829 vis_ld64(ref[0], TMP0); 3830 vis_fzero(ZERO); 3831 3832 vis_ld64_2(ref, 8, TMP2); 3833 3834 vis_ld64(constants6[0], CONST_6); 3835 3836 vis_ld64(constants256_1024[0], CONST_256); 3837 vis_faligndata(TMP0, TMP2, REF_S0); 3838 3839 if (off != 0x7) { 3840 vis_alignaddr_g0((void *)off_plus_1); 3841 vis_faligndata(TMP0, TMP2, REF_S2); 3842 } else { 3843 vis_src1(TMP2, REF_S2); 3844 } 3845 3846 height >>= 1; 3847 do { /* 31 cycles */ 3848 vis_ld64_2(ref, stride, TMP0); 3849 vis_mul8x16au(REF_S0, CONST_256, TMP8); 3850 vis_pmerge(ZERO, REF_S0_1, TMP10); 3851 3852 vis_ld64_2(ref, stride_8, TMP2); 3853 ref += stride; 3854 vis_mul8x16au(REF_S2, CONST_256, TMP12); 3855 vis_pmerge(ZERO, REF_S2_1, TMP14); 3856 3857 vis_alignaddr_g0((void *)off); 3858 3859 vis_ld64_2(ref, stride, TMP4); 3860 vis_faligndata(TMP0, TMP2, REF_S4); 3861 3862 vis_ld64_2(ref, stride_8, TMP6); 3863 ref += stride; 3864 3865 vis_ld64(dest[0], DST_0); 3866 vis_faligndata(TMP4, TMP6, REF_S0); 3867 3868 vis_ld64_2(dest, stride, DST_2); 3869 3870 if (off != 0x7) { 3871 vis_alignaddr_g0((void *)off_plus_1); 3872 vis_faligndata(TMP0, TMP2, REF_S6); 3873 vis_faligndata(TMP4, TMP6, REF_S2); 3874 } else { 3875 vis_src1(TMP2, REF_S6); 3876 vis_src1(TMP6, REF_S2); 3877 } 3878 3879 vis_mul8x16al(DST_0, CONST_1024, TMP30); 3880 vis_pmerge(ZERO, REF_S4, TMP22); 3881 3882 vis_mul8x16al(DST_1, CONST_1024, TMP32); 3883 vis_pmerge(ZERO, REF_S4_1, TMP24); 3884 3885 vis_mul8x16au(REF_S6, CONST_256, TMP26); 3886 vis_pmerge(ZERO, REF_S6_1, TMP28); 3887 3888 vis_mul8x16au(REF_S0, CONST_256, REF_S4); 3889 vis_padd16(TMP22, CONST_6, TMP22); 3890 3891 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6); 3892 vis_padd16(TMP24, CONST_6, TMP24); 3893 3894 vis_mul8x16al(DST_2, CONST_1024, REF_0); 3895 vis_padd16(TMP22, TMP26, TMP22); 3896 3897 vis_mul8x16al(DST_3, CONST_1024, REF_2); 3898 vis_padd16(TMP24, TMP28, TMP24); 3899 3900 vis_mul8x16au(REF_S2, CONST_256, TMP26); 3901 vis_padd16(TMP8, TMP22, TMP8); 3902 3903 vis_mul8x16au(REF_S2_1, CONST_256, TMP28); 3904 vis_padd16(TMP10, TMP24, TMP10); 3905 3906 vis_padd16(TMP8, TMP12, TMP8); 3907 3908 vis_padd16(TMP10, TMP14, TMP10); 3909 3910 vis_padd16(TMP8, TMP30, TMP8); 3911 3912 vis_padd16(TMP10, TMP32, TMP10); 3913 vis_pack16(TMP8, DST_0); 3914 3915 vis_pack16(TMP10, DST_1); 3916 vis_st64(DST_0, dest[0]); 3917 dest += stride; 3918 3919 vis_padd16(REF_S4, TMP22, TMP12); 3920 3921 vis_padd16(REF_S6, TMP24, TMP14); 3922 3923 vis_padd16(TMP12, TMP26, TMP12); 3924 3925 vis_padd16(TMP14, TMP28, TMP14); 3926 3927 vis_padd16(TMP12, REF_0, TMP12); 3928 3929 vis_padd16(TMP14, REF_2, TMP14); 3930 vis_pack16(TMP12, DST_2); 3931 3932 vis_pack16(TMP14, DST_3); 3933 vis_st64(DST_2, dest[0]); 3934 dest += stride; 3935 } while (--height); 3936} 3937 3938/* End of no rounding code */ 3939 3940#define ACCEL_SPARC_VIS 1 3941#define ACCEL_SPARC_VIS2 2 3942 3943static int vis_level(void) 3944{ 3945 int accel = 0; 3946 accel |= ACCEL_SPARC_VIS; 3947 accel |= ACCEL_SPARC_VIS2; 3948 return accel; 3949} 3950 3951/* libavcodec initialization code */ 3952void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx) 3953{ 3954 /* VIS-specific optimizations */ 3955 int accel = vis_level (); 3956 3957 if (accel & ACCEL_SPARC_VIS) { 3958 if(avctx->idct_algo==FF_IDCT_SIMPLEVIS){ 3959 c->idct_put = ff_simple_idct_put_vis; 3960 c->idct_add = ff_simple_idct_add_vis; 3961 c->idct = ff_simple_idct_vis; 3962 c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM; 3963 } 3964 3965 c->put_pixels_tab[0][0] = MC_put_o_16_vis; 3966 c->put_pixels_tab[0][1] = MC_put_x_16_vis; 3967 c->put_pixels_tab[0][2] = MC_put_y_16_vis; 3968 c->put_pixels_tab[0][3] = MC_put_xy_16_vis; 3969 3970 c->put_pixels_tab[1][0] = MC_put_o_8_vis; 3971 c->put_pixels_tab[1][1] = MC_put_x_8_vis; 3972 c->put_pixels_tab[1][2] = MC_put_y_8_vis; 3973 c->put_pixels_tab[1][3] = MC_put_xy_8_vis; 3974 3975 c->avg_pixels_tab[0][0] = MC_avg_o_16_vis; 3976 c->avg_pixels_tab[0][1] = MC_avg_x_16_vis; 3977 c->avg_pixels_tab[0][2] = MC_avg_y_16_vis; 3978 c->avg_pixels_tab[0][3] = MC_avg_xy_16_vis; 3979 3980 c->avg_pixels_tab[1][0] = MC_avg_o_8_vis; 3981 c->avg_pixels_tab[1][1] = MC_avg_x_8_vis; 3982 c->avg_pixels_tab[1][2] = MC_avg_y_8_vis; 3983 c->avg_pixels_tab[1][3] = MC_avg_xy_8_vis; 3984 3985 c->put_no_rnd_pixels_tab[0][0] = MC_put_no_round_o_16_vis; 3986 c->put_no_rnd_pixels_tab[0][1] = MC_put_no_round_x_16_vis; 3987 c->put_no_rnd_pixels_tab[0][2] = MC_put_no_round_y_16_vis; 3988 c->put_no_rnd_pixels_tab[0][3] = MC_put_no_round_xy_16_vis; 3989 3990 c->put_no_rnd_pixels_tab[1][0] = MC_put_no_round_o_8_vis; 3991 c->put_no_rnd_pixels_tab[1][1] = MC_put_no_round_x_8_vis; 3992 c->put_no_rnd_pixels_tab[1][2] = MC_put_no_round_y_8_vis; 3993 c->put_no_rnd_pixels_tab[1][3] = MC_put_no_round_xy_8_vis; 3994 3995 c->avg_no_rnd_pixels_tab[0][0] = MC_avg_no_round_o_16_vis; 3996 c->avg_no_rnd_pixels_tab[0][1] = MC_avg_no_round_x_16_vis; 3997 c->avg_no_rnd_pixels_tab[0][2] = MC_avg_no_round_y_16_vis; 3998 c->avg_no_rnd_pixels_tab[0][3] = MC_avg_no_round_xy_16_vis; 3999 4000 c->avg_no_rnd_pixels_tab[1][0] = MC_avg_no_round_o_8_vis; 4001 c->avg_no_rnd_pixels_tab[1][1] = MC_avg_no_round_x_8_vis; 4002 c->avg_no_rnd_pixels_tab[1][2] = MC_avg_no_round_y_8_vis; 4003 c->avg_no_rnd_pixels_tab[1][3] = MC_avg_no_round_xy_8_vis; 4004 } 4005} 4006