Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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