falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
38308 Commits
32 Branches
283MB
Tree: ce1e8045e0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ce1e8045e0'
${ noResults }
FFmpeg/libavcodec/sparc/hpeldsp_vis.c

3525 lines
104KB
Raw Blame History 

  1. /*

  2.  * Copyright (C) 2003 David S. Miller <davem@redhat.com>

  3.  *

  4.  * This file is part of Libav.

  5.  *

  6.  * Libav 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.  * Libav 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 Libav; 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. }