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

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