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

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