git.sesse.net Git - ffmpeg/blob - libavcodec/sparc/dsputil_vis.c

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