libavcodec/sparc/dsputil_vis.c

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