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.
23348 Commits
32 Branches
444MB
Tree: ad40380240
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ad40380240'
${ noResults }
FFmpeg/libavcodec/sparc/dsputil_vis.c

4050 lines
119KB
Raw Blame History 

  1. /*

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

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2.1 of the License, or (at your option) any later version.

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with FFmpeg; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. /* The *no_round* functions have been added by James A. Morrison, 2003,2004.

  22.    The vis code from libmpeg2 was adapted for ffmpeg by James A. Morrison.

  23.  */

  24. 

  25. #include "config.h"

  26. 

  27. #include <inttypes.h>

  28. 

  29. #include "libavcodec/dsputil.h"

  30. #include "dsputil_vis.h"

  31. 

  32. #include "vis.h"

  33. 

  34. /* The trick used in some of this file is the formula from the MMX

  35.  * motion comp code, which is:

  36.  *

  37.  * (x+y+1)>>1 == (x|y)-((x^y)>>1)

  38.  *

  39.  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.

  40.  * We avoid overflows by masking before we do the shift, and we

  41.  * implement the shift by multiplying by 1/2 using mul8x16.  So in

  42.  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask

  43.  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and

  44.  * the value 0x80808080 is in f8):

  45.  *

  46.  *      fxor            f0,   f2, f10

  47.  *      fand            f10,  f4, f10

  48.  *      fmul8x16        f8,  f10, f10

  49.  *      fand            f10,  f6, f10

  50.  *      for             f0,   f2, f12

  51.  *      fpsub16         f12, f10, f10

  52.  */

  53. 

  54. #define ATTR_ALIGN(alignd) __attribute__ ((aligned(alignd)))

  55. 

  56. #define DUP4(x) {x, x, x, x}

  57. #define DUP8(x) {x, x, x, x, x, x, x, x}

  58. static const int16_t constants1[] ATTR_ALIGN(8) = DUP4 (1);

  59. static const int16_t constants2[] ATTR_ALIGN(8) = DUP4 (2);

  60. static const int16_t constants3[] ATTR_ALIGN(8) = DUP4 (3);

  61. static const int16_t constants6[] ATTR_ALIGN(8) = DUP4 (6);

  62. static const int8_t constants_fe[] ATTR_ALIGN(8) = DUP8 (0xfe);

  63. static const int8_t constants_7f[] ATTR_ALIGN(8) = DUP8 (0x7f);

  64. static const int8_t constants128[] ATTR_ALIGN(8) = DUP8 (128);

  65. static const int16_t constants256_512[] ATTR_ALIGN(8) =

  66.         {256, 512, 256, 512};

  67. static const int16_t constants256_1024[] ATTR_ALIGN(8) =

  68.         {256, 1024, 256, 1024};

  69. 

  70. #define REF_0           0

  71. #define REF_0_1         1

  72. #define REF_2           2

  73. #define REF_2_1         3

  74. #define REF_4           4

  75. #define REF_4_1         5

  76. #define REF_6           6

  77. #define REF_6_1         7

  78. #define REF_S0          8

  79. #define REF_S0_1        9

  80. #define REF_S2          10

  81. #define REF_S2_1        11

  82. #define REF_S4          12

  83. #define REF_S4_1        13

  84. #define REF_S6          14

  85. #define REF_S6_1        15

  86. #define DST_0           16

  87. #define DST_1           17

  88. #define DST_2           18

  89. #define DST_3           19

  90. #define CONST_1         20

  91. #define CONST_2         20

  92. #define CONST_3         20

  93. #define CONST_6         20

  94. #define MASK_fe         20

  95. #define CONST_128       22

  96. #define CONST_256       22

  97. #define CONST_512       22

  98. #define CONST_1024      22

  99. #define TMP0            24

  100. #define TMP1            25

  101. #define TMP2            26

  102. #define TMP3            27

  103. #define TMP4            28

  104. #define TMP5            29

  105. #define ZERO            30

  106. #define MASK_7f         30

  107. 

  108. #define TMP6            32

  109. #define TMP8            34

  110. #define TMP10           36

  111. #define TMP12           38

  112. #define TMP14           40

  113. #define TMP16           42

  114. #define TMP18           44

  115. #define TMP20           46

  116. #define TMP22           48

  117. #define TMP24           50

  118. #define TMP26           52

  119. #define TMP28           54

  120. #define TMP30           56

  121. #define TMP32           58

  122. 

  123. static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * _ref,

  124.                              const int stride, int height)

  125. {

  126.         uint8_t *ref = (uint8_t *) _ref;

  127. 

  128.         ref = vis_alignaddr(ref);

  129.         do {    /* 5 cycles */

  130.                 vis_ld64(ref[0], TMP0);

  131. 

  132.                 vis_ld64_2(ref, 8, TMP2);

  133. 

  134.                 vis_ld64_2(ref, 16, TMP4);

  135.                 ref += stride;

  136. 

  137.                 vis_faligndata(TMP0, TMP2, REF_0);

  138.                 vis_st64(REF_0, dest[0]);

  139. 

  140.                 vis_faligndata(TMP2, TMP4, REF_2);

  141.                 vis_st64_2(REF_2, dest, 8);

  142.                 dest += stride;

  143.         } while (--height);

  144. }

  145. 

  146. static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * _ref,

  147.                             const int stride, int height)

  148. {

  149.         uint8_t *ref = (uint8_t *) _ref;

  150. 

  151.         ref = vis_alignaddr(ref);

  152.         do {    /* 4 cycles */

  153.                 vis_ld64(ref[0], TMP0);

  154. 

  155.                 vis_ld64(ref[8], TMP2);

  156.                 ref += stride;

  157. 

  158.                 /* stall */

  159. 

  160.                 vis_faligndata(TMP0, TMP2, REF_0);

  161.                 vis_st64(REF_0, dest[0]);

  162.                 dest += stride;

  163.         } while (--height);

  164. }

  165. 

  166. 

  167. static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * _ref,

  168.                              const int stride, int height)

  169. {

  170.         uint8_t *ref = (uint8_t *) _ref;

  171.         int stride_8 = stride + 8;

  172. 

  173.         ref = vis_alignaddr(ref);

  174. 

  175.         vis_ld64(ref[0], TMP0);

  176. 

  177.         vis_ld64(ref[8], TMP2);

  178. 

  179.         vis_ld64(ref[16], TMP4);

  180. 

  181.         vis_ld64(dest[0], DST_0);

  182. 

  183.         vis_ld64(dest[8], DST_2);

  184. 

  185.         vis_ld64(constants_fe[0], MASK_fe);

  186.         vis_faligndata(TMP0, TMP2, REF_0);

  187. 

  188.         vis_ld64(constants_7f[0], MASK_7f);

  189.         vis_faligndata(TMP2, TMP4, REF_2);

  190. 

  191.         vis_ld64(constants128[0], CONST_128);

  192. 

  193.         ref += stride;

  194.         height = (height >> 1) - 1;

  195. 

  196.         do {    /* 24 cycles */

  197.                 vis_ld64(ref[0], TMP0);

  198.                 vis_xor(DST_0, REF_0, TMP6);

  199. 

  200.                 vis_ld64_2(ref, 8, TMP2);

  201.                 vis_and(TMP6, MASK_fe, TMP6);

  202. 

  203.                 vis_ld64_2(ref, 16, TMP4);

  204.                 ref += stride;

  205.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  206.                 vis_xor(DST_2, REF_2, TMP8);

  207. 

  208.                 vis_and(TMP8, MASK_fe, TMP8);

  209. 

  210.                 vis_or(DST_0, REF_0, TMP10);

  211.                 vis_ld64_2(dest, stride, DST_0);

  212.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  213. 

  214.                 vis_or(DST_2, REF_2, TMP12);

  215.                 vis_ld64_2(dest, stride_8, DST_2);

  216. 

  217.                 vis_ld64(ref[0], TMP14);

  218.                 vis_and(TMP6, MASK_7f, TMP6);

  219. 

  220.                 vis_and(TMP8, MASK_7f, TMP8);

  221. 

  222.                 vis_psub16(TMP10, TMP6, TMP6);

  223.                 vis_st64(TMP6, dest[0]);

  224. 

  225.                 vis_psub16(TMP12, TMP8, TMP8);

  226.                 vis_st64_2(TMP8, dest, 8);

  227. 

  228.                 dest += stride;

  229.                 vis_ld64_2(ref, 8, TMP16);

  230.                 vis_faligndata(TMP0, TMP2, REF_0);

  231. 

  232.                 vis_ld64_2(ref, 16, TMP18);

  233.                 vis_faligndata(TMP2, TMP4, REF_2);

  234.                 ref += stride;

  235. 

  236.                 vis_xor(DST_0, REF_0, TMP20);

  237. 

  238.                 vis_and(TMP20, MASK_fe, TMP20);

  239. 

  240.                 vis_xor(DST_2, REF_2, TMP22);

  241.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  242. 

  243.                 vis_and(TMP22, MASK_fe, TMP22);

  244. 

  245.                 vis_or(DST_0, REF_0, TMP24);

  246.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  247. 

  248.                 vis_or(DST_2, REF_2, TMP26);

  249. 

  250.                 vis_ld64_2(dest, stride, DST_0);

  251.                 vis_faligndata(TMP14, TMP16, REF_0);

  252. 

  253.                 vis_ld64_2(dest, stride_8, DST_2);

  254.                 vis_faligndata(TMP16, TMP18, REF_2);

  255. 

  256.                 vis_and(TMP20, MASK_7f, TMP20);

  257. 

  258.                 vis_and(TMP22, MASK_7f, TMP22);

  259. 

  260.                 vis_psub16(TMP24, TMP20, TMP20);

  261.                 vis_st64(TMP20, dest[0]);

  262. 

  263.                 vis_psub16(TMP26, TMP22, TMP22);

  264.                 vis_st64_2(TMP22, dest, 8);

  265.                 dest += stride;

  266.         } while (--height);

  267. 

  268.         vis_ld64(ref[0], TMP0);

  269.         vis_xor(DST_0, REF_0, TMP6);

  270. 

  271.         vis_ld64_2(ref, 8, TMP2);

  272.         vis_and(TMP6, MASK_fe, TMP6);

  273. 

  274.         vis_ld64_2(ref, 16, TMP4);

  275.         vis_mul8x16(CONST_128, TMP6, TMP6);

  276.         vis_xor(DST_2, REF_2, TMP8);

  277. 

  278.         vis_and(TMP8, MASK_fe, TMP8);

  279. 

  280.         vis_or(DST_0, REF_0, TMP10);

  281.         vis_ld64_2(dest, stride, DST_0);

  282.         vis_mul8x16(CONST_128, TMP8, TMP8);

  283. 

  284.         vis_or(DST_2, REF_2, TMP12);

  285.         vis_ld64_2(dest, stride_8, DST_2);

  286. 

  287.         vis_ld64(ref[0], TMP14);

  288.         vis_and(TMP6, MASK_7f, TMP6);

  289. 

  290.         vis_and(TMP8, MASK_7f, TMP8);

  291. 

  292.         vis_psub16(TMP10, TMP6, TMP6);

  293.         vis_st64(TMP6, dest[0]);

  294. 

  295.         vis_psub16(TMP12, TMP8, TMP8);

  296.         vis_st64_2(TMP8, dest, 8);

  297. 

  298.         dest += stride;

  299.         vis_faligndata(TMP0, TMP2, REF_0);

  300. 

  301.         vis_faligndata(TMP2, TMP4, REF_2);

  302. 

  303.         vis_xor(DST_0, REF_0, TMP20);

  304. 

  305.         vis_and(TMP20, MASK_fe, TMP20);

  306. 

  307.         vis_xor(DST_2, REF_2, TMP22);

  308.         vis_mul8x16(CONST_128, TMP20, TMP20);

  309. 

  310.         vis_and(TMP22, MASK_fe, TMP22);

  311. 

  312.         vis_or(DST_0, REF_0, TMP24);

  313.         vis_mul8x16(CONST_128, TMP22, TMP22);

  314. 

  315.         vis_or(DST_2, REF_2, TMP26);

  316. 

  317.         vis_and(TMP20, MASK_7f, TMP20);

  318. 

  319.         vis_and(TMP22, MASK_7f, TMP22);

  320. 

  321.         vis_psub16(TMP24, TMP20, TMP20);

  322.         vis_st64(TMP20, dest[0]);

  323. 

  324.         vis_psub16(TMP26, TMP22, TMP22);

  325.         vis_st64_2(TMP22, dest, 8);

  326. }

  327. 

  328. static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * _ref,

  329.                             const int stride, int height)

  330. {

  331.         uint8_t *ref = (uint8_t *) _ref;

  332. 

  333.         ref = vis_alignaddr(ref);

  334. 

  335.         vis_ld64(ref[0], TMP0);

  336. 

  337.         vis_ld64(ref[8], TMP2);

  338. 

  339.         vis_ld64(dest[0], DST_0);

  340. 

  341.         vis_ld64(constants_fe[0], MASK_fe);

  342. 

  343.         vis_ld64(constants_7f[0], MASK_7f);

  344.         vis_faligndata(TMP0, TMP2, REF_0);

  345. 

  346.         vis_ld64(constants128[0], CONST_128);

  347. 

  348.         ref += stride;

  349.         height = (height >> 1) - 1;

  350. 

  351.         do {    /* 12 cycles */

  352.                 vis_ld64(ref[0], TMP0);

  353.                 vis_xor(DST_0, REF_0, TMP4);

  354. 

  355.                 vis_ld64(ref[8], TMP2);

  356.                 vis_and(TMP4, MASK_fe, TMP4);

  357. 

  358.                 vis_or(DST_0, REF_0, TMP6);

  359.                 vis_ld64_2(dest, stride, DST_0);

  360.                 ref += stride;

  361.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  362. 

  363.                 vis_ld64(ref[0], TMP12);

  364.                 vis_faligndata(TMP0, TMP2, REF_0);

  365. 

  366.                 vis_ld64(ref[8], TMP2);

  367.                 vis_xor(DST_0, REF_0, TMP0);

  368.                 ref += stride;

  369. 

  370.                 vis_and(TMP0, MASK_fe, TMP0);

  371. 

  372.                 vis_and(TMP4, MASK_7f, TMP4);

  373. 

  374.                 vis_psub16(TMP6, TMP4, TMP4);

  375.                 vis_st64(TMP4, dest[0]);

  376.                 dest += stride;

  377.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  378. 

  379.                 vis_or(DST_0, REF_0, TMP6);

  380.                 vis_ld64_2(dest, stride, DST_0);

  381. 

  382.                 vis_faligndata(TMP12, TMP2, REF_0);

  383. 

  384.                 vis_and(TMP0, MASK_7f, TMP0);

  385. 

  386.                 vis_psub16(TMP6, TMP0, TMP4);

  387.                 vis_st64(TMP4, dest[0]);

  388.                 dest += stride;

  389.         } while (--height);

  390. 

  391.         vis_ld64(ref[0], TMP0);

  392.         vis_xor(DST_0, REF_0, TMP4);

  393. 

  394.         vis_ld64(ref[8], TMP2);

  395.         vis_and(TMP4, MASK_fe, TMP4);

  396. 

  397.         vis_or(DST_0, REF_0, TMP6);

  398.         vis_ld64_2(dest, stride, DST_0);

  399.         vis_mul8x16(CONST_128, TMP4, TMP4);

  400. 

  401.         vis_faligndata(TMP0, TMP2, REF_0);

  402. 

  403.         vis_xor(DST_0, REF_0, TMP0);

  404. 

  405.         vis_and(TMP0, MASK_fe, TMP0);

  406. 

  407.         vis_and(TMP4, MASK_7f, TMP4);

  408. 

  409.         vis_psub16(TMP6, TMP4, TMP4);

  410.         vis_st64(TMP4, dest[0]);

  411.         dest += stride;

  412.         vis_mul8x16(CONST_128, TMP0, TMP0);

  413. 

  414.         vis_or(DST_0, REF_0, TMP6);

  415. 

  416.         vis_and(TMP0, MASK_7f, TMP0);

  417. 

  418.         vis_psub16(TMP6, TMP0, TMP4);

  419.         vis_st64(TMP4, dest[0]);

  420. }

  421. 

  422. static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * _ref,

  423.                              const int stride, int height)

  424. {

  425.         uint8_t *ref = (uint8_t *) _ref;

  426.         unsigned long off = (unsigned long) ref & 0x7;

  427.         unsigned long off_plus_1 = off + 1;

  428. 

  429.         ref = vis_alignaddr(ref);

  430. 

  431.         vis_ld64(ref[0],    TMP0);

  432. 

  433.         vis_ld64_2(ref, 8,  TMP2);

  434. 

  435.         vis_ld64_2(ref, 16, TMP4);

  436. 

  437.         vis_ld64(constants_fe[0], MASK_fe);

  438. 

  439.         vis_ld64(constants_7f[0], MASK_7f);

  440.         vis_faligndata(TMP0, TMP2, REF_0);

  441. 

  442.         vis_ld64(constants128[0], CONST_128);

  443.         vis_faligndata(TMP2, TMP4, REF_4);

  444. 

  445.         if (off != 0x7) {

  446.                 vis_alignaddr_g0((void *)off_plus_1);

  447.                 vis_faligndata(TMP0, TMP2, REF_2);

  448.                 vis_faligndata(TMP2, TMP4, REF_6);

  449.         } else {

  450.                 vis_src1(TMP2, REF_2);

  451.                 vis_src1(TMP4, REF_6);

  452.         }

  453. 

  454.         ref += stride;

  455.         height = (height >> 1) - 1;

  456. 

  457.         do {    /* 34 cycles */

  458.                 vis_ld64(ref[0],    TMP0);

  459.                 vis_xor(REF_0, REF_2, TMP6);

  460. 

  461.                 vis_ld64_2(ref, 8,  TMP2);

  462.                 vis_xor(REF_4, REF_6, TMP8);

  463. 

  464.                 vis_ld64_2(ref, 16, TMP4);

  465.                 vis_and(TMP6, MASK_fe, TMP6);

  466.                 ref += stride;

  467. 

  468.                 vis_ld64(ref[0],    TMP14);

  469.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  470.                 vis_and(TMP8, MASK_fe, TMP8);

  471. 

  472.                 vis_ld64_2(ref, 8,  TMP16);

  473.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  474.                 vis_or(REF_0, REF_2, TMP10);

  475. 

  476.                 vis_ld64_2(ref, 16, TMP18);

  477.                 ref += stride;

  478.                 vis_or(REF_4, REF_6, TMP12);

  479. 

  480.                 vis_alignaddr_g0((void *)off);

  481. 

  482.                 vis_faligndata(TMP0, TMP2, REF_0);

  483. 

  484.                 vis_faligndata(TMP2, TMP4, REF_4);

  485. 

  486.                 if (off != 0x7) {

  487.                         vis_alignaddr_g0((void *)off_plus_1);

  488.                         vis_faligndata(TMP0, TMP2, REF_2);

  489.                         vis_faligndata(TMP2, TMP4, REF_6);

  490.                 } else {

  491.                         vis_src1(TMP2, REF_2);

  492.                         vis_src1(TMP4, REF_6);

  493.                 }

  494. 

  495.                 vis_and(TMP6, MASK_7f, TMP6);

  496. 

  497.                 vis_and(TMP8, MASK_7f, TMP8);

  498. 

  499.                 vis_psub16(TMP10, TMP6, TMP6);

  500.                 vis_st64(TMP6, dest[0]);

  501. 

  502.                 vis_psub16(TMP12, TMP8, TMP8);

  503.                 vis_st64_2(TMP8, dest, 8);

  504.                 dest += stride;

  505. 

  506.                 vis_xor(REF_0, REF_2, TMP6);

  507. 

  508.                 vis_xor(REF_4, REF_6, TMP8);

  509. 

  510.                 vis_and(TMP6, MASK_fe, TMP6);

  511. 

  512.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  513.                 vis_and(TMP8, MASK_fe, TMP8);

  514. 

  515.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  516.                 vis_or(REF_0, REF_2, TMP10);

  517. 

  518.                 vis_or(REF_4, REF_6, TMP12);

  519. 

  520.                 vis_alignaddr_g0((void *)off);

  521. 

  522.                 vis_faligndata(TMP14, TMP16, REF_0);

  523. 

  524.                 vis_faligndata(TMP16, TMP18, REF_4);

  525. 

  526.                 if (off != 0x7) {

  527.                         vis_alignaddr_g0((void *)off_plus_1);

  528.                         vis_faligndata(TMP14, TMP16, REF_2);

  529.                         vis_faligndata(TMP16, TMP18, REF_6);

  530.                 } else {

  531.                         vis_src1(TMP16, REF_2);

  532.                         vis_src1(TMP18, REF_6);

  533.                 }

  534. 

  535.                 vis_and(TMP6, MASK_7f, TMP6);

  536. 

  537.                 vis_and(TMP8, MASK_7f, TMP8);

  538. 

  539.                 vis_psub16(TMP10, TMP6, TMP6);

  540.                 vis_st64(TMP6, dest[0]);

  541. 

  542.                 vis_psub16(TMP12, TMP8, TMP8);

  543.                 vis_st64_2(TMP8, dest, 8);

  544.                 dest += stride;

  545.         } while (--height);

  546. 

  547.         vis_ld64(ref[0],    TMP0);

  548.         vis_xor(REF_0, REF_2, TMP6);

  549. 

  550.         vis_ld64_2(ref, 8,  TMP2);

  551.         vis_xor(REF_4, REF_6, TMP8);

  552. 

  553.         vis_ld64_2(ref, 16, TMP4);

  554.         vis_and(TMP6, MASK_fe, TMP6);

  555. 

  556.         vis_mul8x16(CONST_128, TMP6, TMP6);

  557.         vis_and(TMP8, MASK_fe, TMP8);

  558. 

  559.         vis_mul8x16(CONST_128, TMP8, TMP8);

  560.         vis_or(REF_0, REF_2, TMP10);

  561. 

  562.         vis_or(REF_4, REF_6, TMP12);

  563. 

  564.         vis_alignaddr_g0((void *)off);

  565. 

  566.         vis_faligndata(TMP0, TMP2, REF_0);

  567. 

  568.         vis_faligndata(TMP2, TMP4, REF_4);

  569. 

  570.         if (off != 0x7) {

  571.                 vis_alignaddr_g0((void *)off_plus_1);

  572.                 vis_faligndata(TMP0, TMP2, REF_2);

  573.                 vis_faligndata(TMP2, TMP4, REF_6);

  574.         } else {

  575.                 vis_src1(TMP2, REF_2);

  576.                 vis_src1(TMP4, REF_6);

  577.         }

  578. 

  579.         vis_and(TMP6, MASK_7f, TMP6);

  580. 

  581.         vis_and(TMP8, MASK_7f, TMP8);

  582. 

  583.         vis_psub16(TMP10, TMP6, TMP6);

  584.         vis_st64(TMP6, dest[0]);

  585. 

  586.         vis_psub16(TMP12, TMP8, TMP8);

  587.         vis_st64_2(TMP8, dest, 8);

  588.         dest += stride;

  589. 

  590.         vis_xor(REF_0, REF_2, TMP6);

  591. 

  592.         vis_xor(REF_4, REF_6, TMP8);

  593. 

  594.         vis_and(TMP6, MASK_fe, TMP6);

  595. 

  596.         vis_mul8x16(CONST_128, TMP6, TMP6);

  597.         vis_and(TMP8, MASK_fe, TMP8);

  598. 

  599.         vis_mul8x16(CONST_128, TMP8, TMP8);

  600.         vis_or(REF_0, REF_2, TMP10);

  601. 

  602.         vis_or(REF_4, REF_6, TMP12);

  603. 

  604.         vis_and(TMP6, MASK_7f, TMP6);

  605. 

  606.         vis_and(TMP8, MASK_7f, TMP8);

  607. 

  608.         vis_psub16(TMP10, TMP6, TMP6);

  609.         vis_st64(TMP6, dest[0]);

  610. 

  611.         vis_psub16(TMP12, TMP8, TMP8);

  612.         vis_st64_2(TMP8, dest, 8);

  613. }

  614. 

  615. static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * _ref,

  616.                             const int stride, int height)

  617. {

  618.         uint8_t *ref = (uint8_t *) _ref;

  619.         unsigned long off = (unsigned long) ref & 0x7;

  620.         unsigned long off_plus_1 = off + 1;

  621. 

  622.         ref = vis_alignaddr(ref);

  623. 

  624.         vis_ld64(ref[0], TMP0);

  625. 

  626.         vis_ld64(ref[8], TMP2);

  627. 

  628.         vis_ld64(constants_fe[0], MASK_fe);

  629. 

  630.         vis_ld64(constants_7f[0], MASK_7f);

  631. 

  632.         vis_ld64(constants128[0], CONST_128);

  633.         vis_faligndata(TMP0, TMP2, REF_0);

  634. 

  635.         if (off != 0x7) {

  636.                 vis_alignaddr_g0((void *)off_plus_1);

  637.                 vis_faligndata(TMP0, TMP2, REF_2);

  638.         } else {

  639.                 vis_src1(TMP2, REF_2);

  640.         }

  641. 

  642.         ref += stride;

  643.         height = (height >> 1) - 1;

  644. 

  645.         do {    /* 20 cycles */

  646.                 vis_ld64(ref[0], TMP0);

  647.                 vis_xor(REF_0, REF_2, TMP4);

  648. 

  649.                 vis_ld64_2(ref, 8, TMP2);

  650.                 vis_and(TMP4, MASK_fe, TMP4);

  651.                 ref += stride;

  652. 

  653.                 vis_ld64(ref[0], TMP8);

  654.                 vis_or(REF_0, REF_2, TMP6);

  655.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  656. 

  657.                 vis_alignaddr_g0((void *)off);

  658. 

  659.                 vis_ld64_2(ref, 8, TMP10);

  660.                 ref += stride;

  661.                 vis_faligndata(TMP0, TMP2, REF_0);

  662. 

  663.                 if (off != 0x7) {

  664.                         vis_alignaddr_g0((void *)off_plus_1);

  665.                         vis_faligndata(TMP0, TMP2, REF_2);

  666.                 } else {

  667.                         vis_src1(TMP2, REF_2);

  668.                 }

  669. 

  670.                 vis_and(TMP4, MASK_7f, TMP4);

  671. 

  672.                 vis_psub16(TMP6, TMP4, DST_0);

  673.                 vis_st64(DST_0, dest[0]);

  674.                 dest += stride;

  675. 

  676.                 vis_xor(REF_0, REF_2, TMP12);

  677. 

  678.                 vis_and(TMP12, MASK_fe, TMP12);

  679. 

  680.                 vis_or(REF_0, REF_2, TMP14);

  681.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  682. 

  683.                 vis_alignaddr_g0((void *)off);

  684.                 vis_faligndata(TMP8, TMP10, REF_0);

  685.                 if (off != 0x7) {

  686.                         vis_alignaddr_g0((void *)off_plus_1);

  687.                         vis_faligndata(TMP8, TMP10, REF_2);

  688.                 } else {

  689.                         vis_src1(TMP10, REF_2);

  690.                 }

  691. 

  692.                 vis_and(TMP12, MASK_7f, TMP12);

  693. 

  694.                 vis_psub16(TMP14, TMP12, DST_0);

  695.                 vis_st64(DST_0, dest[0]);

  696.                 dest += stride;

  697.         } while (--height);

  698. 

  699.         vis_ld64(ref[0], TMP0);

  700.         vis_xor(REF_0, REF_2, TMP4);

  701. 

  702.         vis_ld64_2(ref, 8, TMP2);

  703.         vis_and(TMP4, MASK_fe, TMP4);

  704. 

  705.         vis_or(REF_0, REF_2, TMP6);

  706.         vis_mul8x16(CONST_128, TMP4, TMP4);

  707. 

  708.         vis_alignaddr_g0((void *)off);

  709. 

  710.         vis_faligndata(TMP0, TMP2, REF_0);

  711. 

  712.         if (off != 0x7) {

  713.                 vis_alignaddr_g0((void *)off_plus_1);

  714.                 vis_faligndata(TMP0, TMP2, REF_2);

  715.         } else {

  716.                 vis_src1(TMP2, REF_2);

  717.         }

  718. 

  719.         vis_and(TMP4, MASK_7f, TMP4);

  720. 

  721.         vis_psub16(TMP6, TMP4, DST_0);

  722.         vis_st64(DST_0, dest[0]);

  723.         dest += stride;

  724. 

  725.         vis_xor(REF_0, REF_2, TMP12);

  726. 

  727.         vis_and(TMP12, MASK_fe, TMP12);

  728. 

  729.         vis_or(REF_0, REF_2, TMP14);

  730.         vis_mul8x16(CONST_128, TMP12, TMP12);

  731. 

  732.         vis_and(TMP12, MASK_7f, TMP12);

  733. 

  734.         vis_psub16(TMP14, TMP12, DST_0);

  735.         vis_st64(DST_0, dest[0]);

  736.         dest += stride;

  737. }

  738. 

  739. static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * _ref,

  740.                              const int stride, int height)

  741. {

  742.         uint8_t *ref = (uint8_t *) _ref;

  743.         unsigned long off = (unsigned long) ref & 0x7;

  744.         unsigned long off_plus_1 = off + 1;

  745. 

  746.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  747. 

  748.         vis_ld64(constants3[0], CONST_3);

  749.         vis_fzero(ZERO);

  750.         vis_ld64(constants256_512[0], CONST_256);

  751. 

  752.         ref = vis_alignaddr(ref);

  753.         do {    /* 26 cycles */

  754.                 vis_ld64(ref[0], TMP0);

  755. 

  756.                 vis_ld64(ref[8], TMP2);

  757. 

  758.                 vis_alignaddr_g0((void *)off);

  759. 

  760.                 vis_ld64(ref[16], TMP4);

  761. 

  762.                 vis_ld64(dest[0], DST_0);

  763.                 vis_faligndata(TMP0, TMP2, REF_0);

  764. 

  765.                 vis_ld64(dest[8], DST_2);

  766.                 vis_faligndata(TMP2, TMP4, REF_4);

  767. 

  768.                 if (off != 0x7) {

  769.                         vis_alignaddr_g0((void *)off_plus_1);

  770.                         vis_faligndata(TMP0, TMP2, REF_2);

  771.                         vis_faligndata(TMP2, TMP4, REF_6);

  772.                 } else {

  773.                         vis_src1(TMP2, REF_2);

  774.                         vis_src1(TMP4, REF_6);

  775.                 }

  776. 

  777.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  778. 

  779.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  780.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  781. 

  782.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  783. 

  784.                 vis_padd16(TMP0, TMP4, TMP0);

  785. 

  786.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  787.                 vis_padd16(TMP2, TMP6, TMP2);

  788. 

  789.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  790. 

  791.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  792. 

  793.                 vis_padd16(TMP0, TMP4, TMP0);

  794.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  795. 

  796.                 vis_padd16(TMP2, TMP6, TMP2);

  797.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  798. 

  799.                 vis_padd16(TMP0, CONST_3, TMP8);

  800.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  801. 

  802.                 vis_padd16(TMP2, CONST_3, TMP10);

  803.                 vis_pack16(TMP8, DST_0);

  804. 

  805.                 vis_pack16(TMP10, DST_1);

  806.                 vis_padd16(TMP16, TMP12, TMP0);

  807. 

  808.                 vis_st64(DST_0, dest[0]);

  809.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  810.                 vis_padd16(TMP18, TMP14, TMP2);

  811. 

  812.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  813.                 vis_padd16(TMP0, CONST_3, TMP0);

  814. 

  815.                 vis_padd16(TMP2, CONST_3, TMP2);

  816. 

  817.                 vis_padd16(TMP0, TMP4, TMP0);

  818. 

  819.                 vis_padd16(TMP2, TMP6, TMP2);

  820.                 vis_pack16(TMP0, DST_2);

  821. 

  822.                 vis_pack16(TMP2, DST_3);

  823.                 vis_st64(DST_2, dest[8]);

  824. 

  825.                 ref += stride;

  826.                 dest += stride;

  827.         } while (--height);

  828. }

  829. 

  830. static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * _ref,

  831.                             const int stride, int height)

  832. {

  833.         uint8_t *ref = (uint8_t *) _ref;

  834.         unsigned long off = (unsigned long) ref & 0x7;

  835.         unsigned long off_plus_1 = off + 1;

  836.         int stride_times_2 = stride << 1;

  837. 

  838.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  839. 

  840.         vis_ld64(constants3[0], CONST_3);

  841.         vis_fzero(ZERO);

  842.         vis_ld64(constants256_512[0], CONST_256);

  843. 

  844.         ref = vis_alignaddr(ref);

  845.         height >>= 2;

  846.         do {    /* 47 cycles */

  847.                 vis_ld64(ref[0],   TMP0);

  848. 

  849.                 vis_ld64_2(ref, 8, TMP2);

  850.                 ref += stride;

  851. 

  852.                 vis_alignaddr_g0((void *)off);

  853. 

  854.                 vis_ld64(ref[0],   TMP4);

  855.                 vis_faligndata(TMP0, TMP2, REF_0);

  856. 

  857.                 vis_ld64_2(ref, 8, TMP6);

  858.                 ref += stride;

  859. 

  860.                 vis_ld64(ref[0],   TMP8);

  861. 

  862.                 vis_ld64_2(ref, 8, TMP10);

  863.                 ref += stride;

  864.                 vis_faligndata(TMP4, TMP6, REF_4);

  865. 

  866.                 vis_ld64(ref[0],   TMP12);

  867. 

  868.                 vis_ld64_2(ref, 8, TMP14);

  869.                 ref += stride;

  870.                 vis_faligndata(TMP8, TMP10, REF_S0);

  871. 

  872.                 vis_faligndata(TMP12, TMP14, REF_S4);

  873. 

  874.                 if (off != 0x7) {

  875.                         vis_alignaddr_g0((void *)off_plus_1);

  876. 

  877.                         vis_ld64(dest[0], DST_0);

  878.                         vis_faligndata(TMP0, TMP2, REF_2);

  879. 

  880.                         vis_ld64_2(dest, stride, DST_2);

  881.                         vis_faligndata(TMP4, TMP6, REF_6);

  882. 

  883.                         vis_faligndata(TMP8, TMP10, REF_S2);

  884. 

  885.                         vis_faligndata(TMP12, TMP14, REF_S6);

  886.                 } else {

  887.                         vis_ld64(dest[0], DST_0);

  888.                         vis_src1(TMP2, REF_2);

  889. 

  890.                         vis_ld64_2(dest, stride, DST_2);

  891.                         vis_src1(TMP6, REF_6);

  892. 

  893.                         vis_src1(TMP10, REF_S2);

  894. 

  895.                         vis_src1(TMP14, REF_S6);

  896.                 }

  897. 

  898.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  899.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  900. 

  901.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  902.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  903. 

  904.                 vis_padd16(TMP0, CONST_3, TMP0);

  905.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  906. 

  907.                 vis_padd16(TMP2, CONST_3, TMP2);

  908.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  909. 

  910.                 vis_padd16(TMP0, TMP4, TMP0);

  911.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  912. 

  913.                 vis_padd16(TMP2, TMP6, TMP2);

  914.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  915. 

  916.                 vis_padd16(TMP0, TMP16, TMP0);

  917.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  918. 

  919.                 vis_padd16(TMP2, TMP18, TMP2);

  920.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  921. 

  922.                 vis_padd16(TMP8, CONST_3, TMP8);

  923.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  924. 

  925.                 vis_padd16(TMP8, TMP12, TMP8);

  926.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  927. 

  928.                 vis_padd16(TMP10, TMP14, TMP10);

  929.                 vis_pack16(TMP0, DST_0);

  930. 

  931.                 vis_pack16(TMP2, DST_1);

  932.                 vis_st64(DST_0, dest[0]);

  933.                 dest += stride;

  934.                 vis_padd16(TMP10, CONST_3, TMP10);

  935. 

  936.                 vis_ld64_2(dest, stride, DST_0);

  937.                 vis_padd16(TMP8, TMP16, TMP8);

  938. 

  939.                 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);

  940.                 vis_padd16(TMP10, TMP18, TMP10);

  941.                 vis_pack16(TMP8, DST_2);

  942. 

  943.                 vis_pack16(TMP10, DST_3);

  944.                 vis_st64(DST_2, dest[0]);

  945.                 dest += stride;

  946. 

  947.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  948.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  949. 

  950.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  951.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  952. 

  953.                 vis_padd16(TMP0, CONST_3, TMP0);

  954.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  955. 

  956.                 vis_padd16(TMP2, CONST_3, TMP2);

  957.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  958. 

  959.                 vis_padd16(TMP0, TMP24, TMP0);

  960.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  961. 

  962.                 vis_padd16(TMP2, TMP6, TMP2);

  963.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  964. 

  965.                 vis_padd16(TMP8, CONST_3, TMP8);

  966.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  967. 

  968.                 vis_padd16(TMP10, CONST_3, TMP10);

  969.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  970. 

  971.                 vis_padd16(TMP8, TMP12, TMP8);

  972.                 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);

  973. 

  974.                 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);

  975.                 vis_padd16(TMP0, TMP16, TMP0);

  976. 

  977.                 vis_padd16(TMP2, TMP18, TMP2);

  978.                 vis_pack16(TMP0, DST_0);

  979. 

  980.                 vis_padd16(TMP10, TMP14, TMP10);

  981.                 vis_pack16(TMP2, DST_1);

  982.                 vis_st64(DST_0, dest[0]);

  983.                 dest += stride;

  984. 

  985.                 vis_padd16(TMP8, TMP20, TMP8);

  986. 

  987.                 vis_padd16(TMP10, TMP22, TMP10);

  988.                 vis_pack16(TMP8, DST_2);

  989. 

  990.                 vis_pack16(TMP10, DST_3);

  991.                 vis_st64(DST_2, dest[0]);

  992.                 dest += stride;

  993.         } while (--height);

  994. }

  995. 

  996. static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * _ref,

  997.                              const int stride, int height)

  998. {

  999.         uint8_t *ref = (uint8_t *) _ref;

  1000. 

  1001.         ref = vis_alignaddr(ref);

  1002.         vis_ld64(ref[0], TMP0);

  1003. 

  1004.         vis_ld64_2(ref, 8, TMP2);

  1005. 

  1006.         vis_ld64_2(ref, 16, TMP4);

  1007.         ref += stride;

  1008. 

  1009.         vis_ld64(ref[0], TMP6);

  1010.         vis_faligndata(TMP0, TMP2, REF_0);

  1011. 

  1012.         vis_ld64_2(ref, 8, TMP8);

  1013.         vis_faligndata(TMP2, TMP4, REF_4);

  1014. 

  1015.         vis_ld64_2(ref, 16, TMP10);

  1016.         ref += stride;

  1017. 

  1018.         vis_ld64(constants_fe[0], MASK_fe);

  1019.         vis_faligndata(TMP6, TMP8, REF_2);

  1020. 

  1021.         vis_ld64(constants_7f[0], MASK_7f);

  1022.         vis_faligndata(TMP8, TMP10, REF_6);

  1023. 

  1024.         vis_ld64(constants128[0], CONST_128);

  1025.         height = (height >> 1) - 1;

  1026.         do {    /* 24 cycles */

  1027.                 vis_ld64(ref[0], TMP0);

  1028.                 vis_xor(REF_0, REF_2, TMP12);

  1029. 

  1030.                 vis_ld64_2(ref, 8, TMP2);

  1031.                 vis_xor(REF_4, REF_6, TMP16);

  1032. 

  1033.                 vis_ld64_2(ref, 16, TMP4);

  1034.                 ref += stride;

  1035.                 vis_or(REF_0, REF_2, TMP14);

  1036. 

  1037.                 vis_ld64(ref[0], TMP6);

  1038.                 vis_or(REF_4, REF_6, TMP18);

  1039. 

  1040.                 vis_ld64_2(ref, 8, TMP8);

  1041.                 vis_faligndata(TMP0, TMP2, REF_0);

  1042. 

  1043.                 vis_ld64_2(ref, 16, TMP10);

  1044.                 ref += stride;

  1045.                 vis_faligndata(TMP2, TMP4, REF_4);

  1046. 

  1047.                 vis_and(TMP12, MASK_fe, TMP12);

  1048. 

  1049.                 vis_and(TMP16, MASK_fe, TMP16);

  1050.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1051. 

  1052.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  1053.                 vis_xor(REF_0, REF_2, TMP0);

  1054. 

  1055.                 vis_xor(REF_4, REF_6, TMP2);

  1056. 

  1057.                 vis_or(REF_0, REF_2, TMP20);

  1058. 

  1059.                 vis_and(TMP12, MASK_7f, TMP12);

  1060. 

  1061.                 vis_and(TMP16, MASK_7f, TMP16);

  1062. 

  1063.                 vis_psub16(TMP14, TMP12, TMP12);

  1064.                 vis_st64(TMP12, dest[0]);

  1065. 

  1066.                 vis_psub16(TMP18, TMP16, TMP16);

  1067.                 vis_st64_2(TMP16, dest, 8);

  1068.                 dest += stride;

  1069. 

  1070.                 vis_or(REF_4, REF_6, TMP18);

  1071. 

  1072.                 vis_and(TMP0, MASK_fe, TMP0);

  1073. 

  1074.                 vis_and(TMP2, MASK_fe, TMP2);

  1075.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  1076. 

  1077.                 vis_faligndata(TMP6, TMP8, REF_2);

  1078.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  1079. 

  1080.                 vis_faligndata(TMP8, TMP10, REF_6);

  1081. 

  1082.                 vis_and(TMP0, MASK_7f, TMP0);

  1083. 

  1084.                 vis_and(TMP2, MASK_7f, TMP2);

  1085. 

  1086.                 vis_psub16(TMP20, TMP0, TMP0);

  1087.                 vis_st64(TMP0, dest[0]);

  1088. 

  1089.                 vis_psub16(TMP18, TMP2, TMP2);

  1090.                 vis_st64_2(TMP2, dest, 8);

  1091.                 dest += stride;

  1092.         } while (--height);

  1093. 

  1094.         vis_ld64(ref[0], TMP0);

  1095.         vis_xor(REF_0, REF_2, TMP12);

  1096. 

  1097.         vis_ld64_2(ref, 8, TMP2);

  1098.         vis_xor(REF_4, REF_6, TMP16);

  1099. 

  1100.         vis_ld64_2(ref, 16, TMP4);

  1101.         vis_or(REF_0, REF_2, TMP14);

  1102. 

  1103.         vis_or(REF_4, REF_6, TMP18);

  1104. 

  1105.         vis_faligndata(TMP0, TMP2, REF_0);

  1106. 

  1107.         vis_faligndata(TMP2, TMP4, REF_4);

  1108. 

  1109.         vis_and(TMP12, MASK_fe, TMP12);

  1110. 

  1111.         vis_and(TMP16, MASK_fe, TMP16);

  1112.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1113. 

  1114.         vis_mul8x16(CONST_128, TMP16, TMP16);

  1115.         vis_xor(REF_0, REF_2, TMP0);

  1116. 

  1117.         vis_xor(REF_4, REF_6, TMP2);

  1118. 

  1119.         vis_or(REF_0, REF_2, TMP20);

  1120. 

  1121.         vis_and(TMP12, MASK_7f, TMP12);

  1122. 

  1123.         vis_and(TMP16, MASK_7f, TMP16);

  1124. 

  1125.         vis_psub16(TMP14, TMP12, TMP12);

  1126.         vis_st64(TMP12, dest[0]);

  1127. 

  1128.         vis_psub16(TMP18, TMP16, TMP16);

  1129.         vis_st64_2(TMP16, dest, 8);

  1130.         dest += stride;

  1131. 

  1132.         vis_or(REF_4, REF_6, TMP18);

  1133. 

  1134.         vis_and(TMP0, MASK_fe, TMP0);

  1135. 

  1136.         vis_and(TMP2, MASK_fe, TMP2);

  1137.         vis_mul8x16(CONST_128, TMP0, TMP0);

  1138. 

  1139.         vis_mul8x16(CONST_128, TMP2, TMP2);

  1140. 

  1141.         vis_and(TMP0, MASK_7f, TMP0);

  1142. 

  1143.         vis_and(TMP2, MASK_7f, TMP2);

  1144. 

  1145.         vis_psub16(TMP20, TMP0, TMP0);

  1146.         vis_st64(TMP0, dest[0]);

  1147. 

  1148.         vis_psub16(TMP18, TMP2, TMP2);

  1149.         vis_st64_2(TMP2, dest, 8);

  1150. }

  1151. 

  1152. static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * _ref,

  1153.                             const int stride, int height)

  1154. {

  1155.         uint8_t *ref = (uint8_t *) _ref;

  1156. 

  1157.         ref = vis_alignaddr(ref);

  1158.         vis_ld64(ref[0], TMP0);

  1159. 

  1160.         vis_ld64_2(ref, 8, TMP2);

  1161.         ref += stride;

  1162. 

  1163.         vis_ld64(ref[0], TMP4);

  1164. 

  1165.         vis_ld64_2(ref, 8, TMP6);

  1166.         ref += stride;

  1167. 

  1168.         vis_ld64(constants_fe[0], MASK_fe);

  1169.         vis_faligndata(TMP0, TMP2, REF_0);

  1170. 

  1171.         vis_ld64(constants_7f[0], MASK_7f);

  1172.         vis_faligndata(TMP4, TMP6, REF_2);

  1173. 

  1174.         vis_ld64(constants128[0], CONST_128);

  1175.         height = (height >> 1) - 1;

  1176.         do {    /* 12 cycles */

  1177.                 vis_ld64(ref[0], TMP0);

  1178.                 vis_xor(REF_0, REF_2, TMP4);

  1179. 

  1180.                 vis_ld64_2(ref, 8, TMP2);

  1181.                 ref += stride;

  1182.                 vis_and(TMP4, MASK_fe, TMP4);

  1183. 

  1184.                 vis_or(REF_0, REF_2, TMP6);

  1185.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  1186. 

  1187.                 vis_faligndata(TMP0, TMP2, REF_0);

  1188.                 vis_ld64(ref[0], TMP0);

  1189. 

  1190.                 vis_ld64_2(ref, 8, TMP2);

  1191.                 ref += stride;

  1192.                 vis_xor(REF_0, REF_2, TMP12);

  1193. 

  1194.                 vis_and(TMP4, MASK_7f, TMP4);

  1195. 

  1196.                 vis_and(TMP12, MASK_fe, TMP12);

  1197. 

  1198.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1199.                 vis_or(REF_0, REF_2, TMP14);

  1200. 

  1201.                 vis_psub16(TMP6, TMP4, DST_0);

  1202.                 vis_st64(DST_0, dest[0]);

  1203.                 dest += stride;

  1204. 

  1205.                 vis_faligndata(TMP0, TMP2, REF_2);

  1206. 

  1207.                 vis_and(TMP12, MASK_7f, TMP12);

  1208. 

  1209.                 vis_psub16(TMP14, TMP12, DST_0);

  1210.                 vis_st64(DST_0, dest[0]);

  1211.                 dest += stride;

  1212.         } while (--height);

  1213. 

  1214.         vis_ld64(ref[0], TMP0);

  1215.         vis_xor(REF_0, REF_2, TMP4);

  1216. 

  1217.         vis_ld64_2(ref, 8, TMP2);

  1218.         vis_and(TMP4, MASK_fe, TMP4);

  1219. 

  1220.         vis_or(REF_0, REF_2, TMP6);

  1221.         vis_mul8x16(CONST_128, TMP4, TMP4);

  1222. 

  1223.         vis_faligndata(TMP0, TMP2, REF_0);

  1224. 

  1225.         vis_xor(REF_0, REF_2, TMP12);

  1226. 

  1227.         vis_and(TMP4, MASK_7f, TMP4);

  1228. 

  1229.         vis_and(TMP12, MASK_fe, TMP12);

  1230. 

  1231.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1232.         vis_or(REF_0, REF_2, TMP14);

  1233. 

  1234.         vis_psub16(TMP6, TMP4, DST_0);

  1235.         vis_st64(DST_0, dest[0]);

  1236.         dest += stride;

  1237. 

  1238.         vis_and(TMP12, MASK_7f, TMP12);

  1239. 

  1240.         vis_psub16(TMP14, TMP12, DST_0);

  1241.         vis_st64(DST_0, dest[0]);

  1242. }

  1243. 

  1244. static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * _ref,

  1245.                              const int stride, int height)

  1246. {

  1247.         uint8_t *ref = (uint8_t *) _ref;

  1248.         int stride_8 = stride + 8;

  1249.         int stride_16 = stride + 16;

  1250. 

  1251.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1252. 

  1253.         ref = vis_alignaddr(ref);

  1254. 

  1255.         vis_ld64(ref[ 0], TMP0);

  1256.         vis_fzero(ZERO);

  1257. 

  1258.         vis_ld64(ref[ 8], TMP2);

  1259. 

  1260.         vis_ld64(ref[16], TMP4);

  1261. 

  1262.         vis_ld64(constants3[0], CONST_3);

  1263.         vis_faligndata(TMP0, TMP2, REF_2);

  1264. 

  1265.         vis_ld64(constants256_512[0], CONST_256);

  1266.         vis_faligndata(TMP2, TMP4, REF_6);

  1267.         height >>= 1;

  1268. 

  1269.         do {    /* 31 cycles */

  1270.                 vis_ld64_2(ref, stride, TMP0);

  1271.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  1272.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  1273. 

  1274.                 vis_ld64_2(ref, stride_8, TMP2);

  1275.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  1276.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  1277. 

  1278.                 vis_ld64_2(ref, stride_16, TMP4);

  1279.                 ref += stride;

  1280. 

  1281.                 vis_ld64(dest[0], DST_0);

  1282.                 vis_faligndata(TMP0, TMP2, REF_0);

  1283. 

  1284.                 vis_ld64_2(dest, 8, DST_2);

  1285.                 vis_faligndata(TMP2, TMP4, REF_4);

  1286. 

  1287.                 vis_ld64_2(ref, stride, TMP6);

  1288.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  1289.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  1290. 

  1291.                 vis_ld64_2(ref, stride_8, TMP8);

  1292.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  1293. 

  1294.                 vis_ld64_2(ref, stride_16, TMP10);

  1295.                 ref += stride;

  1296. 

  1297.                 vis_ld64_2(dest, stride, REF_S0/*DST_4*/);

  1298.                 vis_faligndata(TMP6, TMP8, REF_2);

  1299.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1300. 

  1301.                 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);

  1302.                 vis_faligndata(TMP8, TMP10, REF_6);

  1303.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  1304. 

  1305.                 vis_padd16(TMP0, CONST_3, TMP0);

  1306.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  1307. 

  1308.                 vis_padd16(TMP2, CONST_3, TMP2);

  1309.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1310. 

  1311.                 vis_padd16(TMP4, CONST_3, TMP4);

  1312.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1313. 

  1314.                 vis_padd16(TMP6, CONST_3, TMP6);

  1315. 

  1316.                 vis_padd16(TMP12, TMP20, TMP12);

  1317.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  1318. 

  1319.                 vis_padd16(TMP14, TMP22, TMP14);

  1320.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  1321. 

  1322.                 vis_padd16(TMP16, TMP24, TMP16);

  1323.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  1324. 

  1325.                 vis_padd16(TMP18, TMP26, TMP18);

  1326.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  1327. 

  1328.                 vis_padd16(TMP12, TMP0, TMP12);

  1329.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  1330. 

  1331.                 vis_padd16(TMP14, TMP2, TMP14);

  1332.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  1333. 

  1334.                 vis_padd16(TMP16, TMP4, TMP16);

  1335.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  1336. 

  1337.                 vis_padd16(TMP18, TMP6, TMP18);

  1338.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  1339. 

  1340.                 vis_pack16(TMP12, DST_0);

  1341.                 vis_padd16(TMP28, TMP0, TMP12);

  1342. 

  1343.                 vis_pack16(TMP14, DST_1);

  1344.                 vis_st64(DST_0, dest[0]);

  1345.                 vis_padd16(TMP30, TMP2, TMP14);

  1346. 

  1347.                 vis_pack16(TMP16, DST_2);

  1348.                 vis_padd16(REF_S4, TMP4, TMP16);

  1349. 

  1350.                 vis_pack16(TMP18, DST_3);

  1351.                 vis_st64_2(DST_2, dest, 8);

  1352.                 dest += stride;

  1353.                 vis_padd16(REF_S6, TMP6, TMP18);

  1354. 

  1355.                 vis_padd16(TMP12, TMP20, TMP12);

  1356. 

  1357.                 vis_padd16(TMP14, TMP22, TMP14);

  1358.                 vis_pack16(TMP12, DST_0);

  1359. 

  1360.                 vis_padd16(TMP16, TMP24, TMP16);

  1361.                 vis_pack16(TMP14, DST_1);

  1362.                 vis_st64(DST_0, dest[0]);

  1363. 

  1364.                 vis_padd16(TMP18, TMP26, TMP18);

  1365.                 vis_pack16(TMP16, DST_2);

  1366. 

  1367.                 vis_pack16(TMP18, DST_3);

  1368.                 vis_st64_2(DST_2, dest, 8);

  1369.                 dest += stride;

  1370.         } while (--height);

  1371. }

  1372. 

  1373. static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * _ref,

  1374.                             const int stride, int height)

  1375. {

  1376.         uint8_t *ref = (uint8_t *) _ref;

  1377.         int stride_8 = stride + 8;

  1378. 

  1379.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1380. 

  1381.         ref = vis_alignaddr(ref);

  1382. 

  1383.         vis_ld64(ref[ 0], TMP0);

  1384.         vis_fzero(ZERO);

  1385. 

  1386.         vis_ld64(ref[ 8], TMP2);

  1387. 

  1388.         vis_ld64(constants3[0], CONST_3);

  1389.         vis_faligndata(TMP0, TMP2, REF_2);

  1390. 

  1391.         vis_ld64(constants256_512[0], CONST_256);

  1392. 

  1393.         height >>= 1;

  1394.         do {    /* 20 cycles */

  1395.                 vis_ld64_2(ref, stride, TMP0);

  1396.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  1397.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  1398. 

  1399.                 vis_ld64_2(ref, stride_8, TMP2);

  1400.                 ref += stride;

  1401. 

  1402.                 vis_ld64(dest[0], DST_0);

  1403. 

  1404.                 vis_ld64_2(dest, stride, DST_2);

  1405.                 vis_faligndata(TMP0, TMP2, REF_0);

  1406. 

  1407.                 vis_ld64_2(ref, stride, TMP4);

  1408.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  1409.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  1410. 

  1411.                 vis_ld64_2(ref, stride_8, TMP6);

  1412.                 ref += stride;

  1413.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  1414.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  1415. 

  1416.                 vis_padd16(TMP12, CONST_3, TMP12);

  1417.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1418. 

  1419.                 vis_padd16(TMP14, CONST_3, TMP14);

  1420.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1421. 

  1422.                 vis_faligndata(TMP4, TMP6, REF_2);

  1423. 

  1424.                 vis_padd16(TMP8, TMP12, TMP8);

  1425. 

  1426.                 vis_padd16(TMP10, TMP14, TMP10);

  1427.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  1428. 

  1429.                 vis_padd16(TMP8, TMP16, TMP0);

  1430.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  1431. 

  1432.                 vis_padd16(TMP10, TMP18, TMP2);

  1433.                 vis_pack16(TMP0, DST_0);

  1434. 

  1435.                 vis_pack16(TMP2, DST_1);

  1436.                 vis_st64(DST_0, dest[0]);

  1437.                 dest += stride;

  1438.                 vis_padd16(TMP12, TMP20, TMP12);

  1439. 

  1440.                 vis_padd16(TMP14, TMP22, TMP14);

  1441. 

  1442.                 vis_padd16(TMP12, TMP24, TMP0);

  1443. 

  1444.                 vis_padd16(TMP14, TMP26, TMP2);

  1445.                 vis_pack16(TMP0, DST_2);

  1446. 

  1447.                 vis_pack16(TMP2, DST_3);

  1448.                 vis_st64(DST_2, dest[0]);

  1449.                 dest += stride;

  1450.         } while (--height);

  1451. }

  1452. 

  1453. static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * _ref,

  1454.                               const int stride, int height)

  1455. {

  1456.         uint8_t *ref = (uint8_t *) _ref;

  1457.         unsigned long off = (unsigned long) ref & 0x7;

  1458.         unsigned long off_plus_1 = off + 1;

  1459.         int stride_8 = stride + 8;

  1460.         int stride_16 = stride + 16;

  1461. 

  1462.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1463. 

  1464.         ref = vis_alignaddr(ref);

  1465. 

  1466.         vis_ld64(ref[ 0], TMP0);

  1467.         vis_fzero(ZERO);

  1468. 

  1469.         vis_ld64(ref[ 8], TMP2);

  1470. 

  1471.         vis_ld64(ref[16], TMP4);

  1472. 

  1473.         vis_ld64(constants2[0], CONST_2);

  1474.         vis_faligndata(TMP0, TMP2, REF_S0);

  1475. 

  1476.         vis_ld64(constants256_512[0], CONST_256);

  1477.         vis_faligndata(TMP2, TMP4, REF_S4);

  1478. 

  1479.         if (off != 0x7) {

  1480.                 vis_alignaddr_g0((void *)off_plus_1);

  1481.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1482.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1483.         } else {

  1484.                 vis_src1(TMP2, REF_S2);

  1485.                 vis_src1(TMP4, REF_S6);

  1486.         }

  1487. 

  1488.         height >>= 1;

  1489.         do {

  1490.                 vis_ld64_2(ref, stride, TMP0);

  1491.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1492.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1493. 

  1494.                 vis_alignaddr_g0((void *)off);

  1495. 

  1496.                 vis_ld64_2(ref, stride_8, TMP2);

  1497.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1498.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1499. 

  1500.                 vis_ld64_2(ref, stride_16, TMP4);

  1501.                 ref += stride;

  1502.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1503.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1504. 

  1505.                 vis_ld64_2(ref, stride, TMP6);

  1506.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1507.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1508. 

  1509.                 vis_ld64_2(ref, stride_8, TMP8);

  1510.                 vis_faligndata(TMP0, TMP2, REF_0);

  1511. 

  1512.                 vis_ld64_2(ref, stride_16, TMP10);

  1513.                 ref += stride;

  1514.                 vis_faligndata(TMP2, TMP4, REF_4);

  1515. 

  1516.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1517. 

  1518.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1519. 

  1520.                 if (off != 0x7) {

  1521.                         vis_alignaddr_g0((void *)off_plus_1);

  1522.                         vis_faligndata(TMP0, TMP2, REF_2);

  1523.                         vis_faligndata(TMP2, TMP4, REF_6);

  1524.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1525.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1526.                 } else {

  1527.                         vis_src1(TMP2, REF_2);

  1528.                         vis_src1(TMP4, REF_6);

  1529.                         vis_src1(TMP8, REF_S2);

  1530.                         vis_src1(TMP10, REF_S6);

  1531.                 }

  1532. 

  1533.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  1534.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1535. 

  1536.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1537.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1538. 

  1539.                 vis_padd16(TMP0, CONST_2, TMP8);

  1540.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  1541. 

  1542.                 vis_padd16(TMP2, CONST_2, TMP10);

  1543.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  1544. 

  1545.                 vis_padd16(TMP8, TMP4, TMP8);

  1546.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  1547. 

  1548.                 vis_padd16(TMP10, TMP6, TMP10);

  1549.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  1550. 

  1551.                 vis_padd16(TMP12, TMP8, TMP12);

  1552. 

  1553.                 vis_padd16(TMP14, TMP10, TMP14);

  1554. 

  1555.                 vis_padd16(TMP12, TMP16, TMP12);

  1556. 

  1557.                 vis_padd16(TMP14, TMP18, TMP14);

  1558.                 vis_pack16(TMP12, DST_0);

  1559. 

  1560.                 vis_pack16(TMP14, DST_1);

  1561.                 vis_st64(DST_0, dest[0]);

  1562.                 vis_padd16(TMP0, CONST_2, TMP12);

  1563. 

  1564.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  1565.                 vis_padd16(TMP2, CONST_2, TMP14);

  1566. 

  1567.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  1568.                 vis_padd16(TMP12, TMP4, TMP12);

  1569. 

  1570.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  1571.                 vis_padd16(TMP14, TMP6, TMP14);

  1572. 

  1573.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  1574.                 vis_padd16(TMP20, TMP12, TMP20);

  1575. 

  1576.                 vis_padd16(TMP22, TMP14, TMP22);

  1577. 

  1578.                 vis_padd16(TMP20, TMP24, TMP20);

  1579. 

  1580.                 vis_padd16(TMP22, TMP26, TMP22);

  1581.                 vis_pack16(TMP20, DST_2);

  1582. 

  1583.                 vis_pack16(TMP22, DST_3);

  1584.                 vis_st64_2(DST_2, dest, 8);

  1585.                 dest += stride;

  1586.                 vis_padd16(TMP0, TMP4, TMP24);

  1587. 

  1588.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  1589.                 vis_padd16(TMP2, TMP6, TMP26);

  1590. 

  1591.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  1592.                 vis_padd16(TMP24, TMP8, TMP24);

  1593. 

  1594.                 vis_padd16(TMP26, TMP10, TMP26);

  1595.                 vis_pack16(TMP24, DST_0);

  1596. 

  1597.                 vis_pack16(TMP26, DST_1);

  1598.                 vis_st64(DST_0, dest[0]);

  1599.                 vis_pmerge(ZERO, REF_S6, TMP4);

  1600. 

  1601.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  1602. 

  1603.                 vis_padd16(TMP0, TMP4, TMP0);

  1604. 

  1605.                 vis_padd16(TMP2, TMP6, TMP2);

  1606. 

  1607.                 vis_padd16(TMP0, TMP12, TMP0);

  1608. 

  1609.                 vis_padd16(TMP2, TMP14, TMP2);

  1610.                 vis_pack16(TMP0, DST_2);

  1611. 

  1612.                 vis_pack16(TMP2, DST_3);

  1613.                 vis_st64_2(DST_2, dest, 8);

  1614.                 dest += stride;

  1615.         } while (--height);

  1616. }

  1617. 

  1618. static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * _ref,

  1619.                              const int stride, int height)

  1620. {

  1621.         uint8_t *ref = (uint8_t *) _ref;

  1622.         unsigned long off = (unsigned long) ref & 0x7;

  1623.         unsigned long off_plus_1 = off + 1;

  1624.         int stride_8 = stride + 8;

  1625. 

  1626.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1627. 

  1628.         ref = vis_alignaddr(ref);

  1629. 

  1630.         vis_ld64(ref[ 0], TMP0);

  1631.         vis_fzero(ZERO);

  1632. 

  1633.         vis_ld64(ref[ 8], TMP2);

  1634. 

  1635.         vis_ld64(constants2[0], CONST_2);

  1636. 

  1637.         vis_ld64(constants256_512[0], CONST_256);

  1638.         vis_faligndata(TMP0, TMP2, REF_S0);

  1639. 

  1640.         if (off != 0x7) {

  1641.                 vis_alignaddr_g0((void *)off_plus_1);

  1642.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1643.         } else {

  1644.                 vis_src1(TMP2, REF_S2);

  1645.         }

  1646. 

  1647.         height >>= 1;

  1648.         do {    /* 26 cycles */

  1649.                 vis_ld64_2(ref, stride, TMP0);

  1650.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  1651.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  1652. 

  1653.                 vis_alignaddr_g0((void *)off);

  1654. 

  1655.                 vis_ld64_2(ref, stride_8, TMP2);

  1656.                 ref += stride;

  1657.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  1658.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  1659. 

  1660.                 vis_ld64_2(ref, stride, TMP4);

  1661. 

  1662.                 vis_ld64_2(ref, stride_8, TMP6);

  1663.                 ref += stride;

  1664.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1665. 

  1666.                 vis_pmerge(ZERO, REF_S4, TMP18);

  1667. 

  1668.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  1669. 

  1670.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1671. 

  1672.                 if (off != 0x7) {

  1673.                         vis_alignaddr_g0((void *)off_plus_1);

  1674.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1675.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1676.                 } else {

  1677.                         vis_src1(TMP2, REF_S6);

  1678.                         vis_src1(TMP6, REF_S2);

  1679.                 }

  1680. 

  1681.                 vis_padd16(TMP18, CONST_2, TMP18);

  1682.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  1683. 

  1684.                 vis_padd16(TMP20, CONST_2, TMP20);

  1685.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  1686. 

  1687.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  1688.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  1689. 

  1690.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  1691.                 vis_padd16(TMP18, TMP22, TMP18);

  1692. 

  1693.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  1694.                 vis_padd16(TMP20, TMP24, TMP20);

  1695. 

  1696.                 vis_padd16(TMP8,  TMP18, TMP8);

  1697. 

  1698.                 vis_padd16(TMP10, TMP20, TMP10);

  1699. 

  1700.                 vis_padd16(TMP8,  TMP12, TMP8);

  1701. 

  1702.                 vis_padd16(TMP10, TMP14, TMP10);

  1703.                 vis_pack16(TMP8,  DST_0);

  1704. 

  1705.                 vis_pack16(TMP10, DST_1);

  1706.                 vis_st64(DST_0, dest[0]);

  1707.                 dest += stride;

  1708.                 vis_padd16(TMP18, TMP26, TMP18);

  1709. 

  1710.                 vis_padd16(TMP20, TMP28, TMP20);

  1711. 

  1712.                 vis_padd16(TMP18, TMP30, TMP18);

  1713. 

  1714.                 vis_padd16(TMP20, TMP32, TMP20);

  1715.                 vis_pack16(TMP18, DST_2);

  1716. 

  1717.                 vis_pack16(TMP20, DST_3);

  1718.                 vis_st64(DST_2, dest[0]);

  1719.                 dest += stride;

  1720.         } while (--height);

  1721. }

  1722. 

  1723. static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * _ref,

  1724.                               const int stride, int height)

  1725. {

  1726.         uint8_t *ref = (uint8_t *) _ref;

  1727.         unsigned long off = (unsigned long) ref & 0x7;

  1728.         unsigned long off_plus_1 = off + 1;

  1729.         int stride_8 = stride + 8;

  1730.         int stride_16 = stride + 16;

  1731. 

  1732.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1733. 

  1734.         ref = vis_alignaddr(ref);

  1735. 

  1736.         vis_ld64(ref[ 0], TMP0);

  1737.         vis_fzero(ZERO);

  1738. 

  1739.         vis_ld64(ref[ 8], TMP2);

  1740. 

  1741.         vis_ld64(ref[16], TMP4);

  1742. 

  1743.         vis_ld64(constants6[0], CONST_6);

  1744.         vis_faligndata(TMP0, TMP2, REF_S0);

  1745. 

  1746.         vis_ld64(constants256_1024[0], CONST_256);

  1747.         vis_faligndata(TMP2, TMP4, REF_S4);

  1748. 

  1749.         if (off != 0x7) {

  1750.                 vis_alignaddr_g0((void *)off_plus_1);

  1751.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1752.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1753.         } else {

  1754.                 vis_src1(TMP2, REF_S2);

  1755.                 vis_src1(TMP4, REF_S6);

  1756.         }

  1757. 

  1758.         height >>= 1;

  1759.         do {    /* 55 cycles */

  1760.                 vis_ld64_2(ref, stride, TMP0);

  1761.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1762.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1763. 

  1764.                 vis_alignaddr_g0((void *)off);

  1765. 

  1766.                 vis_ld64_2(ref, stride_8, TMP2);

  1767.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1768.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1769. 

  1770.                 vis_ld64_2(ref, stride_16, TMP4);

  1771.                 ref += stride;

  1772.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1773.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1774. 

  1775.                 vis_ld64_2(ref, stride, TMP6);

  1776.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1777.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1778. 

  1779.                 vis_ld64_2(ref, stride_8, TMP8);

  1780.                 vis_faligndata(TMP0, TMP2, REF_0);

  1781. 

  1782.                 vis_ld64_2(ref, stride_16, TMP10);

  1783.                 ref += stride;

  1784.                 vis_faligndata(TMP2, TMP4, REF_4);

  1785. 

  1786.                 vis_ld64(dest[0], DST_0);

  1787.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1788. 

  1789.                 vis_ld64_2(dest, 8, DST_2);

  1790.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1791. 

  1792.                 if (off != 0x7) {

  1793.                         vis_alignaddr_g0((void *)off_plus_1);

  1794.                         vis_faligndata(TMP0, TMP2, REF_2);

  1795.                         vis_faligndata(TMP2, TMP4, REF_6);

  1796.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1797.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1798.                 } else {

  1799.                         vis_src1(TMP2, REF_2);

  1800.                         vis_src1(TMP4, REF_6);

  1801.                         vis_src1(TMP8, REF_S2);

  1802.                         vis_src1(TMP10, REF_S6);

  1803.                 }

  1804. 

  1805.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1806.                 vis_pmerge(ZERO, REF_0, TMP0);

  1807. 

  1808.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1809.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1810. 

  1811.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1812.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1813. 

  1814.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1815.                 vis_padd16(TMP0, CONST_6, TMP0);

  1816. 

  1817.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1818.                 vis_padd16(TMP2, CONST_6, TMP2);

  1819. 

  1820.                 vis_padd16(TMP0, TMP4, TMP0);

  1821.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  1822. 

  1823.                 vis_padd16(TMP2, TMP6, TMP2);

  1824.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1825. 

  1826.                 vis_padd16(TMP12, TMP0, TMP12);

  1827.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  1828. 

  1829.                 vis_padd16(TMP14, TMP2, TMP14);

  1830.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  1831. 

  1832.                 vis_padd16(TMP12, TMP16, TMP12);

  1833.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  1834. 

  1835.                 vis_padd16(TMP14, TMP18, TMP14);

  1836.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  1837. 

  1838.                 vis_padd16(TMP12, TMP30, TMP12);

  1839. 

  1840.                 vis_padd16(TMP14, TMP32, TMP14);

  1841.                 vis_pack16(TMP12, DST_0);

  1842. 

  1843.                 vis_pack16(TMP14, DST_1);

  1844.                 vis_st64(DST_0, dest[0]);

  1845.                 vis_padd16(TMP4, CONST_6, TMP4);

  1846. 

  1847.                 vis_ld64_2(dest, stride, DST_0);

  1848.                 vis_padd16(TMP6, CONST_6, TMP6);

  1849.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1850. 

  1851.                 vis_padd16(TMP4, TMP8, TMP4);

  1852.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  1853. 

  1854.                 vis_padd16(TMP6, TMP10, TMP6);

  1855. 

  1856.                 vis_padd16(TMP20, TMP4, TMP20);

  1857. 

  1858.                 vis_padd16(TMP22, TMP6, TMP22);

  1859. 

  1860.                 vis_padd16(TMP20, TMP24, TMP20);

  1861. 

  1862.                 vis_padd16(TMP22, TMP26, TMP22);

  1863. 

  1864.                 vis_padd16(TMP20, REF_0, TMP20);

  1865.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  1866. 

  1867.                 vis_padd16(TMP22, REF_2, TMP22);

  1868.                 vis_pack16(TMP20, DST_2);

  1869. 

  1870.                 vis_pack16(TMP22, DST_3);

  1871.                 vis_st64_2(DST_2, dest, 8);

  1872.                 dest += stride;

  1873. 

  1874.                 vis_ld64_2(dest, 8, DST_2);

  1875.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1876.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  1877. 

  1878.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1879.                 vis_padd16(REF_4, TMP0, TMP8);

  1880. 

  1881.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  1882.                 vis_padd16(REF_6, TMP2, TMP10);

  1883. 

  1884.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  1885.                 vis_padd16(TMP8, TMP12, TMP8);

  1886. 

  1887.                 vis_padd16(TMP10, TMP14, TMP10);

  1888. 

  1889.                 vis_padd16(TMP8, TMP30, TMP8);

  1890. 

  1891.                 vis_padd16(TMP10, TMP32, TMP10);

  1892.                 vis_pack16(TMP8, DST_0);

  1893. 

  1894.                 vis_pack16(TMP10, DST_1);

  1895.                 vis_st64(DST_0, dest[0]);

  1896. 

  1897.                 vis_padd16(REF_0, TMP4, REF_0);

  1898. 

  1899.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  1900.                 vis_padd16(REF_2, TMP6, REF_2);

  1901. 

  1902.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  1903.                 vis_padd16(REF_0, REF_4, REF_0);

  1904. 

  1905.                 vis_padd16(REF_2, REF_6, REF_2);

  1906. 

  1907.                 vis_padd16(REF_0, TMP30, REF_0);

  1908. 

  1909.                 /* stall */

  1910. 

  1911.                 vis_padd16(REF_2, TMP32, REF_2);

  1912.                 vis_pack16(REF_0, DST_2);

  1913. 

  1914.                 vis_pack16(REF_2, DST_3);

  1915.                 vis_st64_2(DST_2, dest, 8);

  1916.                 dest += stride;

  1917.         } while (--height);

  1918. }

  1919. 

  1920. static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * _ref,

  1921.                              const int stride, int height)

  1922. {

  1923.         uint8_t *ref = (uint8_t *) _ref;

  1924.         unsigned long off = (unsigned long) ref & 0x7;

  1925.         unsigned long off_plus_1 = off + 1;

  1926.         int stride_8 = stride + 8;

  1927. 

  1928.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1929. 

  1930.         ref = vis_alignaddr(ref);

  1931. 

  1932.         vis_ld64(ref[0], TMP0);

  1933.         vis_fzero(ZERO);

  1934. 

  1935.         vis_ld64_2(ref, 8, TMP2);

  1936. 

  1937.         vis_ld64(constants6[0], CONST_6);

  1938. 

  1939.         vis_ld64(constants256_1024[0], CONST_256);

  1940.         vis_faligndata(TMP0, TMP2, REF_S0);

  1941. 

  1942.         if (off != 0x7) {

  1943.                 vis_alignaddr_g0((void *)off_plus_1);

  1944.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1945.         } else {

  1946.                 vis_src1(TMP2, REF_S2);

  1947.         }

  1948. 

  1949.         height >>= 1;

  1950.         do {    /* 31 cycles */

  1951.                 vis_ld64_2(ref, stride, TMP0);

  1952.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  1953.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  1954. 

  1955.                 vis_ld64_2(ref, stride_8, TMP2);

  1956.                 ref += stride;

  1957.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1958.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  1959. 

  1960.                 vis_alignaddr_g0((void *)off);

  1961. 

  1962.                 vis_ld64_2(ref, stride, TMP4);

  1963.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1964. 

  1965.                 vis_ld64_2(ref, stride_8, TMP6);

  1966.                 ref += stride;

  1967. 

  1968.                 vis_ld64(dest[0], DST_0);

  1969.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1970. 

  1971.                 vis_ld64_2(dest, stride, DST_2);

  1972. 

  1973.                 if (off != 0x7) {

  1974.                         vis_alignaddr_g0((void *)off_plus_1);

  1975.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1976.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1977.                 } else {

  1978.                         vis_src1(TMP2, REF_S6);

  1979.                         vis_src1(TMP6, REF_S2);

  1980.                 }

  1981. 

  1982.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1983.                 vis_pmerge(ZERO, REF_S4, TMP22);

  1984. 

  1985.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1986.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  1987. 

  1988.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  1989.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  1990. 

  1991.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  1992.                 vis_padd16(TMP22, CONST_6, TMP22);

  1993. 

  1994.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  1995.                 vis_padd16(TMP24, CONST_6, TMP24);

  1996. 

  1997.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1998.                 vis_padd16(TMP22, TMP26, TMP22);

  1999. 

  2000.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  2001.                 vis_padd16(TMP24, TMP28, TMP24);

  2002. 

  2003.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  2004.                 vis_padd16(TMP8, TMP22, TMP8);

  2005. 

  2006.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  2007.                 vis_padd16(TMP10, TMP24, TMP10);

  2008. 

  2009.                 vis_padd16(TMP8, TMP12, TMP8);

  2010. 

  2011.                 vis_padd16(TMP10, TMP14, TMP10);

  2012. 

  2013.                 vis_padd16(TMP8, TMP30, TMP8);

  2014. 

  2015.                 vis_padd16(TMP10, TMP32, TMP10);

  2016.                 vis_pack16(TMP8, DST_0);

  2017. 

  2018.                 vis_pack16(TMP10, DST_1);

  2019.                 vis_st64(DST_0, dest[0]);

  2020.                 dest += stride;

  2021. 

  2022.                 vis_padd16(REF_S4, TMP22, TMP12);

  2023. 

  2024.                 vis_padd16(REF_S6, TMP24, TMP14);

  2025. 

  2026.                 vis_padd16(TMP12, TMP26, TMP12);

  2027. 

  2028.                 vis_padd16(TMP14, TMP28, TMP14);

  2029. 

  2030.                 vis_padd16(TMP12, REF_0, TMP12);

  2031. 

  2032.                 vis_padd16(TMP14, REF_2, TMP14);

  2033.                 vis_pack16(TMP12, DST_2);

  2034. 

  2035.                 vis_pack16(TMP14, DST_3);

  2036.                 vis_st64(DST_2, dest[0]);

  2037.                 dest += stride;

  2038.         } while (--height);

  2039. }

  2040. 

  2041. /* End of rounding code */

  2042. 

  2043. /* Start of no rounding code */

  2044. /* The trick used in some of this file is the formula from the MMX

  2045.  * motion comp code, which is:

  2046.  *

  2047.  * (x+y)>>1 == (x&y)+((x^y)>>1)

  2048.  *

  2049.  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.

  2050.  * We avoid overflows by masking before we do the shift, and we

  2051.  * implement the shift by multiplying by 1/2 using mul8x16.  So in

  2052.  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask

  2053.  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and

  2054.  * the value 0x80808080 is in f8):

  2055.  *

  2056.  *      fxor            f0,   f2, f10

  2057.  *      fand            f10,  f4, f10

  2058.  *      fmul8x16        f8,  f10, f10

  2059.  *      fand            f10,  f6, f10

  2060.  *      fand            f0,   f2, f12

  2061.  *      fpadd16         f12, f10, f10

  2062.  */

  2063. 

  2064. static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * _ref,

  2065.                                       const int stride, int height)

  2066. {

  2067.         uint8_t *ref = (uint8_t *) _ref;

  2068. 

  2069.         ref = vis_alignaddr(ref);

  2070.         do {    /* 5 cycles */

  2071.                 vis_ld64(ref[0], TMP0);

  2072. 

  2073.                 vis_ld64_2(ref, 8, TMP2);

  2074. 

  2075.                 vis_ld64_2(ref, 16, TMP4);

  2076.                 ref += stride;

  2077. 

  2078.                 vis_faligndata(TMP0, TMP2, REF_0);

  2079.                 vis_st64(REF_0, dest[0]);

  2080. 

  2081.                 vis_faligndata(TMP2, TMP4, REF_2);

  2082.                 vis_st64_2(REF_2, dest, 8);

  2083.                 dest += stride;

  2084.         } while (--height);

  2085. }

  2086. 

  2087. static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * _ref,

  2088.                             const int stride, int height)

  2089. {

  2090.         uint8_t *ref = (uint8_t *) _ref;

  2091. 

  2092.         ref = vis_alignaddr(ref);

  2093.         do {    /* 4 cycles */

  2094.                 vis_ld64(ref[0], TMP0);

  2095. 

  2096.                 vis_ld64(ref[8], TMP2);

  2097.                 ref += stride;

  2098. 

  2099.                 /* stall */

  2100. 

  2101.                 vis_faligndata(TMP0, TMP2, REF_0);

  2102.                 vis_st64(REF_0, dest[0]);

  2103.                 dest += stride;

  2104.         } while (--height);

  2105. }

  2106. 

  2107. 

  2108. static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * _ref,

  2109.                              const int stride, int height)

  2110. {

  2111.         uint8_t *ref = (uint8_t *) _ref;

  2112.         int stride_8 = stride + 8;

  2113. 

  2114.         ref = vis_alignaddr(ref);

  2115. 

  2116.         vis_ld64(ref[0], TMP0);

  2117. 

  2118.         vis_ld64(ref[8], TMP2);

  2119. 

  2120.         vis_ld64(ref[16], TMP4);

  2121. 

  2122.         vis_ld64(dest[0], DST_0);

  2123. 

  2124.         vis_ld64(dest[8], DST_2);

  2125. 

  2126.         vis_ld64(constants_fe[0], MASK_fe);

  2127.         vis_faligndata(TMP0, TMP2, REF_0);

  2128. 

  2129.         vis_ld64(constants_7f[0], MASK_7f);

  2130.         vis_faligndata(TMP2, TMP4, REF_2);

  2131. 

  2132.         vis_ld64(constants128[0], CONST_128);

  2133. 

  2134.         ref += stride;

  2135.         height = (height >> 1) - 1;

  2136. 

  2137.         do {    /* 24 cycles */

  2138.                 vis_ld64(ref[0], TMP0);

  2139.                 vis_xor(DST_0, REF_0, TMP6);

  2140. 

  2141.                 vis_ld64_2(ref, 8, TMP2);

  2142.                 vis_and(TMP6, MASK_fe, TMP6);

  2143. 

  2144.                 vis_ld64_2(ref, 16, TMP4);

  2145.                 ref += stride;

  2146.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2147.                 vis_xor(DST_2, REF_2, TMP8);

  2148. 

  2149.                 vis_and(TMP8, MASK_fe, TMP8);

  2150. 

  2151.                 vis_and(DST_0, REF_0, TMP10);

  2152.                 vis_ld64_2(dest, stride, DST_0);

  2153.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2154. 

  2155.                 vis_and(DST_2, REF_2, TMP12);

  2156.                 vis_ld64_2(dest, stride_8, DST_2);

  2157. 

  2158.                 vis_ld64(ref[0], TMP14);

  2159.                 vis_and(TMP6, MASK_7f, TMP6);

  2160. 

  2161.                 vis_and(TMP8, MASK_7f, TMP8);

  2162. 

  2163.                 vis_padd16(TMP10, TMP6, TMP6);

  2164.                 vis_st64(TMP6, dest[0]);

  2165. 

  2166.                 vis_padd16(TMP12, TMP8, TMP8);

  2167.                 vis_st64_2(TMP8, dest, 8);

  2168. 

  2169.                 dest += stride;

  2170.                 vis_ld64_2(ref, 8, TMP16);

  2171.                 vis_faligndata(TMP0, TMP2, REF_0);

  2172. 

  2173.                 vis_ld64_2(ref, 16, TMP18);

  2174.                 vis_faligndata(TMP2, TMP4, REF_2);

  2175.                 ref += stride;

  2176. 

  2177.                 vis_xor(DST_0, REF_0, TMP20);

  2178. 

  2179.                 vis_and(TMP20, MASK_fe, TMP20);

  2180. 

  2181.                 vis_xor(DST_2, REF_2, TMP22);

  2182.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  2183. 

  2184.                 vis_and(TMP22, MASK_fe, TMP22);

  2185. 

  2186.                 vis_and(DST_0, REF_0, TMP24);

  2187.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  2188. 

  2189.                 vis_and(DST_2, REF_2, TMP26);

  2190. 

  2191.                 vis_ld64_2(dest, stride, DST_0);

  2192.                 vis_faligndata(TMP14, TMP16, REF_0);

  2193. 

  2194.                 vis_ld64_2(dest, stride_8, DST_2);

  2195.                 vis_faligndata(TMP16, TMP18, REF_2);

  2196. 

  2197.                 vis_and(TMP20, MASK_7f, TMP20);

  2198. 

  2199.                 vis_and(TMP22, MASK_7f, TMP22);

  2200. 

  2201.                 vis_padd16(TMP24, TMP20, TMP20);

  2202.                 vis_st64(TMP20, dest[0]);

  2203. 

  2204.                 vis_padd16(TMP26, TMP22, TMP22);

  2205.                 vis_st64_2(TMP22, dest, 8);

  2206.                 dest += stride;

  2207.         } while (--height);

  2208. 

  2209.         vis_ld64(ref[0], TMP0);

  2210.         vis_xor(DST_0, REF_0, TMP6);

  2211. 

  2212.         vis_ld64_2(ref, 8, TMP2);

  2213.         vis_and(TMP6, MASK_fe, TMP6);

  2214. 

  2215.         vis_ld64_2(ref, 16, TMP4);

  2216.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2217.         vis_xor(DST_2, REF_2, TMP8);

  2218. 

  2219.         vis_and(TMP8, MASK_fe, TMP8);

  2220. 

  2221.         vis_and(DST_0, REF_0, TMP10);

  2222.         vis_ld64_2(dest, stride, DST_0);

  2223.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2224. 

  2225.         vis_and(DST_2, REF_2, TMP12);

  2226.         vis_ld64_2(dest, stride_8, DST_2);

  2227. 

  2228.         vis_ld64(ref[0], TMP14);

  2229.         vis_and(TMP6, MASK_7f, TMP6);

  2230. 

  2231.         vis_and(TMP8, MASK_7f, TMP8);

  2232. 

  2233.         vis_padd16(TMP10, TMP6, TMP6);

  2234.         vis_st64(TMP6, dest[0]);

  2235. 

  2236.         vis_padd16(TMP12, TMP8, TMP8);

  2237.         vis_st64_2(TMP8, dest, 8);

  2238. 

  2239.         dest += stride;

  2240.         vis_faligndata(TMP0, TMP2, REF_0);

  2241. 

  2242.         vis_faligndata(TMP2, TMP4, REF_2);

  2243. 

  2244.         vis_xor(DST_0, REF_0, TMP20);

  2245. 

  2246.         vis_and(TMP20, MASK_fe, TMP20);

  2247. 

  2248.         vis_xor(DST_2, REF_2, TMP22);

  2249.         vis_mul8x16(CONST_128, TMP20, TMP20);

  2250. 

  2251.         vis_and(TMP22, MASK_fe, TMP22);

  2252. 

  2253.         vis_and(DST_0, REF_0, TMP24);

  2254.         vis_mul8x16(CONST_128, TMP22, TMP22);

  2255. 

  2256.         vis_and(DST_2, REF_2, TMP26);

  2257. 

  2258.         vis_and(TMP20, MASK_7f, TMP20);

  2259. 

  2260.         vis_and(TMP22, MASK_7f, TMP22);

  2261. 

  2262.         vis_padd16(TMP24, TMP20, TMP20);

  2263.         vis_st64(TMP20, dest[0]);

  2264. 

  2265.         vis_padd16(TMP26, TMP22, TMP22);

  2266.         vis_st64_2(TMP22, dest, 8);

  2267. }

  2268. 

  2269. static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * _ref,

  2270.                             const int stride, int height)

  2271. {

  2272.         uint8_t *ref = (uint8_t *) _ref;

  2273. 

  2274.         ref = vis_alignaddr(ref);

  2275. 

  2276.         vis_ld64(ref[0], TMP0);

  2277. 

  2278.         vis_ld64(ref[8], TMP2);

  2279. 

  2280.         vis_ld64(dest[0], DST_0);

  2281. 

  2282.         vis_ld64(constants_fe[0], MASK_fe);

  2283. 

  2284.         vis_ld64(constants_7f[0], MASK_7f);

  2285.         vis_faligndata(TMP0, TMP2, REF_0);

  2286. 

  2287.         vis_ld64(constants128[0], CONST_128);

  2288. 

  2289.         ref += stride;

  2290.         height = (height >> 1) - 1;

  2291. 

  2292.         do {    /* 12 cycles */

  2293.                 vis_ld64(ref[0], TMP0);

  2294.                 vis_xor(DST_0, REF_0, TMP4);

  2295. 

  2296.                 vis_ld64(ref[8], TMP2);

  2297.                 vis_and(TMP4, MASK_fe, TMP4);

  2298. 

  2299.                 vis_and(DST_0, REF_0, TMP6);

  2300.                 vis_ld64_2(dest, stride, DST_0);

  2301.                 ref += stride;

  2302.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2303. 

  2304.                 vis_ld64(ref[0], TMP12);

  2305.                 vis_faligndata(TMP0, TMP2, REF_0);

  2306. 

  2307.                 vis_ld64(ref[8], TMP2);

  2308.                 vis_xor(DST_0, REF_0, TMP0);

  2309.                 ref += stride;

  2310. 

  2311.                 vis_and(TMP0, MASK_fe, TMP0);

  2312. 

  2313.                 vis_and(TMP4, MASK_7f, TMP4);

  2314. 

  2315.                 vis_padd16(TMP6, TMP4, TMP4);

  2316.                 vis_st64(TMP4, dest[0]);

  2317.                 dest += stride;

  2318.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  2319. 

  2320.                 vis_and(DST_0, REF_0, TMP6);

  2321.                 vis_ld64_2(dest, stride, DST_0);

  2322. 

  2323.                 vis_faligndata(TMP12, TMP2, REF_0);

  2324. 

  2325.                 vis_and(TMP0, MASK_7f, TMP0);

  2326. 

  2327.                 vis_padd16(TMP6, TMP0, TMP4);

  2328.                 vis_st64(TMP4, dest[0]);

  2329.                 dest += stride;

  2330.         } while (--height);

  2331. 

  2332.         vis_ld64(ref[0], TMP0);

  2333.         vis_xor(DST_0, REF_0, TMP4);

  2334. 

  2335.         vis_ld64(ref[8], TMP2);

  2336.         vis_and(TMP4, MASK_fe, TMP4);

  2337. 

  2338.         vis_and(DST_0, REF_0, TMP6);

  2339.         vis_ld64_2(dest, stride, DST_0);

  2340.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2341. 

  2342.         vis_faligndata(TMP0, TMP2, REF_0);

  2343. 

  2344.         vis_xor(DST_0, REF_0, TMP0);

  2345. 

  2346.         vis_and(TMP0, MASK_fe, TMP0);

  2347. 

  2348.         vis_and(TMP4, MASK_7f, TMP4);

  2349. 

  2350.         vis_padd16(TMP6, TMP4, TMP4);

  2351.         vis_st64(TMP4, dest[0]);

  2352.         dest += stride;

  2353.         vis_mul8x16(CONST_128, TMP0, TMP0);

  2354. 

  2355.         vis_and(DST_0, REF_0, TMP6);

  2356. 

  2357.         vis_and(TMP0, MASK_7f, TMP0);

  2358. 

  2359.         vis_padd16(TMP6, TMP0, TMP4);

  2360.         vis_st64(TMP4, dest[0]);

  2361. }

  2362. 

  2363. static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * _ref,

  2364.                              const int stride, int height)

  2365. {

  2366.         uint8_t *ref = (uint8_t *) _ref;

  2367.         unsigned long off = (unsigned long) ref & 0x7;

  2368.         unsigned long off_plus_1 = off + 1;

  2369. 

  2370.         ref = vis_alignaddr(ref);

  2371. 

  2372.         vis_ld64(ref[0],    TMP0);

  2373. 

  2374.         vis_ld64_2(ref, 8,  TMP2);

  2375. 

  2376.         vis_ld64_2(ref, 16, TMP4);

  2377. 

  2378.         vis_ld64(constants_fe[0], MASK_fe);

  2379. 

  2380.         vis_ld64(constants_7f[0], MASK_7f);

  2381.         vis_faligndata(TMP0, TMP2, REF_0);

  2382. 

  2383.         vis_ld64(constants128[0], CONST_128);

  2384.         vis_faligndata(TMP2, TMP4, REF_4);

  2385. 

  2386.         if (off != 0x7) {

  2387.                 vis_alignaddr_g0((void *)off_plus_1);

  2388.                 vis_faligndata(TMP0, TMP2, REF_2);

  2389.                 vis_faligndata(TMP2, TMP4, REF_6);

  2390.         } else {

  2391.                 vis_src1(TMP2, REF_2);

  2392.                 vis_src1(TMP4, REF_6);

  2393.         }

  2394. 

  2395.         ref += stride;

  2396.         height = (height >> 1) - 1;

  2397. 

  2398.         do {    /* 34 cycles */

  2399.                 vis_ld64(ref[0],    TMP0);

  2400.                 vis_xor(REF_0, REF_2, TMP6);

  2401. 

  2402.                 vis_ld64_2(ref, 8,  TMP2);

  2403.                 vis_xor(REF_4, REF_6, TMP8);

  2404. 

  2405.                 vis_ld64_2(ref, 16, TMP4);

  2406.                 vis_and(TMP6, MASK_fe, TMP6);

  2407.                 ref += stride;

  2408. 

  2409.                 vis_ld64(ref[0],    TMP14);

  2410.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2411.                 vis_and(TMP8, MASK_fe, TMP8);

  2412. 

  2413.                 vis_ld64_2(ref, 8,  TMP16);

  2414.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2415.                 vis_and(REF_0, REF_2, TMP10);

  2416. 

  2417.                 vis_ld64_2(ref, 16, TMP18);

  2418.                 ref += stride;

  2419.                 vis_and(REF_4, REF_6, TMP12);

  2420. 

  2421.                 vis_alignaddr_g0((void *)off);

  2422. 

  2423.                 vis_faligndata(TMP0, TMP2, REF_0);

  2424. 

  2425.                 vis_faligndata(TMP2, TMP4, REF_4);

  2426. 

  2427.                 if (off != 0x7) {

  2428.                         vis_alignaddr_g0((void *)off_plus_1);

  2429.                         vis_faligndata(TMP0, TMP2, REF_2);

  2430.                         vis_faligndata(TMP2, TMP4, REF_6);

  2431.                 } else {

  2432.                         vis_src1(TMP2, REF_2);

  2433.                         vis_src1(TMP4, REF_6);

  2434.                 }

  2435. 

  2436.                 vis_and(TMP6, MASK_7f, TMP6);

  2437. 

  2438.                 vis_and(TMP8, MASK_7f, TMP8);

  2439. 

  2440.                 vis_padd16(TMP10, TMP6, TMP6);

  2441.                 vis_st64(TMP6, dest[0]);

  2442. 

  2443.                 vis_padd16(TMP12, TMP8, TMP8);

  2444.                 vis_st64_2(TMP8, dest, 8);

  2445.                 dest += stride;

  2446. 

  2447.                 vis_xor(REF_0, REF_2, TMP6);

  2448. 

  2449.                 vis_xor(REF_4, REF_6, TMP8);

  2450. 

  2451.                 vis_and(TMP6, MASK_fe, TMP6);

  2452. 

  2453.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2454.                 vis_and(TMP8, MASK_fe, TMP8);

  2455. 

  2456.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2457.                 vis_and(REF_0, REF_2, TMP10);

  2458. 

  2459.                 vis_and(REF_4, REF_6, TMP12);

  2460. 

  2461.                 vis_alignaddr_g0((void *)off);

  2462. 

  2463.                 vis_faligndata(TMP14, TMP16, REF_0);

  2464. 

  2465.                 vis_faligndata(TMP16, TMP18, REF_4);

  2466. 

  2467.                 if (off != 0x7) {

  2468.                         vis_alignaddr_g0((void *)off_plus_1);

  2469.                         vis_faligndata(TMP14, TMP16, REF_2);

  2470.                         vis_faligndata(TMP16, TMP18, REF_6);

  2471.                 } else {

  2472.                         vis_src1(TMP16, REF_2);

  2473.                         vis_src1(TMP18, REF_6);

  2474.                 }

  2475. 

  2476.                 vis_and(TMP6, MASK_7f, TMP6);

  2477. 

  2478.                 vis_and(TMP8, MASK_7f, TMP8);

  2479. 

  2480.                 vis_padd16(TMP10, TMP6, TMP6);

  2481.                 vis_st64(TMP6, dest[0]);

  2482. 

  2483.                 vis_padd16(TMP12, TMP8, TMP8);

  2484.                 vis_st64_2(TMP8, dest, 8);

  2485.                 dest += stride;

  2486.         } while (--height);

  2487. 

  2488.         vis_ld64(ref[0],    TMP0);

  2489.         vis_xor(REF_0, REF_2, TMP6);

  2490. 

  2491.         vis_ld64_2(ref, 8,  TMP2);

  2492.         vis_xor(REF_4, REF_6, TMP8);

  2493. 

  2494.         vis_ld64_2(ref, 16, TMP4);

  2495.         vis_and(TMP6, MASK_fe, TMP6);

  2496. 

  2497.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2498.         vis_and(TMP8, MASK_fe, TMP8);

  2499. 

  2500.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2501.         vis_and(REF_0, REF_2, TMP10);

  2502. 

  2503.         vis_and(REF_4, REF_6, TMP12);

  2504. 

  2505.         vis_alignaddr_g0((void *)off);

  2506. 

  2507.         vis_faligndata(TMP0, TMP2, REF_0);

  2508. 

  2509.         vis_faligndata(TMP2, TMP4, REF_4);

  2510. 

  2511.         if (off != 0x7) {

  2512.                 vis_alignaddr_g0((void *)off_plus_1);

  2513.                 vis_faligndata(TMP0, TMP2, REF_2);

  2514.                 vis_faligndata(TMP2, TMP4, REF_6);

  2515.         } else {

  2516.                 vis_src1(TMP2, REF_2);

  2517.                 vis_src1(TMP4, REF_6);

  2518.         }

  2519. 

  2520.         vis_and(TMP6, MASK_7f, TMP6);

  2521. 

  2522.         vis_and(TMP8, MASK_7f, TMP8);

  2523. 

  2524.         vis_padd16(TMP10, TMP6, TMP6);

  2525.         vis_st64(TMP6, dest[0]);

  2526. 

  2527.         vis_padd16(TMP12, TMP8, TMP8);

  2528.         vis_st64_2(TMP8, dest, 8);

  2529.         dest += stride;

  2530. 

  2531.         vis_xor(REF_0, REF_2, TMP6);

  2532. 

  2533.         vis_xor(REF_4, REF_6, TMP8);

  2534. 

  2535.         vis_and(TMP6, MASK_fe, TMP6);

  2536. 

  2537.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2538.         vis_and(TMP8, MASK_fe, TMP8);

  2539. 

  2540.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2541.         vis_and(REF_0, REF_2, TMP10);

  2542. 

  2543.         vis_and(REF_4, REF_6, TMP12);

  2544. 

  2545.         vis_and(TMP6, MASK_7f, TMP6);

  2546. 

  2547.         vis_and(TMP8, MASK_7f, TMP8);

  2548. 

  2549.         vis_padd16(TMP10, TMP6, TMP6);

  2550.         vis_st64(TMP6, dest[0]);

  2551. 

  2552.         vis_padd16(TMP12, TMP8, TMP8);

  2553.         vis_st64_2(TMP8, dest, 8);

  2554. }

  2555. 

  2556. static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * _ref,

  2557.                             const int stride, int height)

  2558. {

  2559.         uint8_t *ref = (uint8_t *) _ref;

  2560.         unsigned long off = (unsigned long) ref & 0x7;

  2561.         unsigned long off_plus_1 = off + 1;

  2562. 

  2563.         ref = vis_alignaddr(ref);

  2564. 

  2565.         vis_ld64(ref[0], TMP0);

  2566. 

  2567.         vis_ld64(ref[8], TMP2);

  2568. 

  2569.         vis_ld64(constants_fe[0], MASK_fe);

  2570. 

  2571.         vis_ld64(constants_7f[0], MASK_7f);

  2572. 

  2573.         vis_ld64(constants128[0], CONST_128);

  2574.         vis_faligndata(TMP0, TMP2, REF_0);

  2575. 

  2576.         if (off != 0x7) {

  2577.                 vis_alignaddr_g0((void *)off_plus_1);

  2578.                 vis_faligndata(TMP0, TMP2, REF_2);

  2579.         } else {

  2580.                 vis_src1(TMP2, REF_2);

  2581.         }

  2582. 

  2583.         ref += stride;

  2584.         height = (height >> 1) - 1;

  2585. 

  2586.         do {    /* 20 cycles */

  2587.                 vis_ld64(ref[0], TMP0);

  2588.                 vis_xor(REF_0, REF_2, TMP4);

  2589. 

  2590.                 vis_ld64_2(ref, 8, TMP2);

  2591.                 vis_and(TMP4, MASK_fe, TMP4);

  2592.                 ref += stride;

  2593. 

  2594.                 vis_ld64(ref[0], TMP8);

  2595.                 vis_and(REF_0, REF_2, TMP6);

  2596.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2597. 

  2598.                 vis_alignaddr_g0((void *)off);

  2599. 

  2600.                 vis_ld64_2(ref, 8, TMP10);

  2601.                 ref += stride;

  2602.                 vis_faligndata(TMP0, TMP2, REF_0);

  2603. 

  2604.                 if (off != 0x7) {

  2605.                         vis_alignaddr_g0((void *)off_plus_1);

  2606.                         vis_faligndata(TMP0, TMP2, REF_2);

  2607.                 } else {

  2608.                         vis_src1(TMP2, REF_2);

  2609.                 }

  2610. 

  2611.                 vis_and(TMP4, MASK_7f, TMP4);

  2612. 

  2613.                 vis_padd16(TMP6, TMP4, DST_0);

  2614.                 vis_st64(DST_0, dest[0]);

  2615.                 dest += stride;

  2616. 

  2617.                 vis_xor(REF_0, REF_2, TMP12);

  2618. 

  2619.                 vis_and(TMP12, MASK_fe, TMP12);

  2620. 

  2621.                 vis_and(REF_0, REF_2, TMP14);

  2622.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2623. 

  2624.                 vis_alignaddr_g0((void *)off);

  2625.                 vis_faligndata(TMP8, TMP10, REF_0);

  2626.                 if (off != 0x7) {

  2627.                         vis_alignaddr_g0((void *)off_plus_1);

  2628.                         vis_faligndata(TMP8, TMP10, REF_2);

  2629.                 } else {

  2630.                         vis_src1(TMP10, REF_2);

  2631.                 }

  2632. 

  2633.                 vis_and(TMP12, MASK_7f, TMP12);

  2634. 

  2635.                 vis_padd16(TMP14, TMP12, DST_0);

  2636.                 vis_st64(DST_0, dest[0]);

  2637.                 dest += stride;

  2638.         } while (--height);

  2639. 

  2640.         vis_ld64(ref[0], TMP0);

  2641.         vis_xor(REF_0, REF_2, TMP4);

  2642. 

  2643.         vis_ld64_2(ref, 8, TMP2);

  2644.         vis_and(TMP4, MASK_fe, TMP4);

  2645. 

  2646.         vis_and(REF_0, REF_2, TMP6);

  2647.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2648. 

  2649.         vis_alignaddr_g0((void *)off);

  2650. 

  2651.         vis_faligndata(TMP0, TMP2, REF_0);

  2652. 

  2653.         if (off != 0x7) {

  2654.                 vis_alignaddr_g0((void *)off_plus_1);

  2655.                 vis_faligndata(TMP0, TMP2, REF_2);

  2656.         } else {

  2657.                 vis_src1(TMP2, REF_2);

  2658.         }

  2659. 

  2660.         vis_and(TMP4, MASK_7f, TMP4);

  2661. 

  2662.         vis_padd16(TMP6, TMP4, DST_0);

  2663.         vis_st64(DST_0, dest[0]);

  2664.         dest += stride;

  2665. 

  2666.         vis_xor(REF_0, REF_2, TMP12);

  2667. 

  2668.         vis_and(TMP12, MASK_fe, TMP12);

  2669. 

  2670.         vis_and(REF_0, REF_2, TMP14);

  2671.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2672. 

  2673.         vis_and(TMP12, MASK_7f, TMP12);

  2674. 

  2675.         vis_padd16(TMP14, TMP12, DST_0);

  2676.         vis_st64(DST_0, dest[0]);

  2677.         dest += stride;

  2678. }

  2679. 

  2680. static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * _ref,

  2681.                              const int stride, int height)

  2682. {

  2683.         uint8_t *ref = (uint8_t *) _ref;

  2684.         unsigned long off = (unsigned long) ref & 0x7;

  2685.         unsigned long off_plus_1 = off + 1;

  2686. 

  2687.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2688. 

  2689.         vis_ld64(constants3[0], CONST_3);

  2690.         vis_fzero(ZERO);

  2691.         vis_ld64(constants256_512[0], CONST_256);

  2692. 

  2693.         ref = vis_alignaddr(ref);

  2694.         do {    /* 26 cycles */

  2695.                 vis_ld64(ref[0], TMP0);

  2696. 

  2697.                 vis_ld64(ref[8], TMP2);

  2698. 

  2699.                 vis_alignaddr_g0((void *)off);

  2700. 

  2701.                 vis_ld64(ref[16], TMP4);

  2702. 

  2703.                 vis_ld64(dest[0], DST_0);

  2704.                 vis_faligndata(TMP0, TMP2, REF_0);

  2705. 

  2706.                 vis_ld64(dest[8], DST_2);

  2707.                 vis_faligndata(TMP2, TMP4, REF_4);

  2708. 

  2709.                 if (off != 0x7) {

  2710.                         vis_alignaddr_g0((void *)off_plus_1);

  2711.                         vis_faligndata(TMP0, TMP2, REF_2);

  2712.                         vis_faligndata(TMP2, TMP4, REF_6);

  2713.                 } else {

  2714.                         vis_src1(TMP2, REF_2);

  2715.                         vis_src1(TMP4, REF_6);

  2716.                 }

  2717. 

  2718.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  2719. 

  2720.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2721.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2722. 

  2723.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  2724. 

  2725.                 vis_padd16(TMP0, TMP4, TMP0);

  2726. 

  2727.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  2728.                 vis_padd16(TMP2, TMP6, TMP2);

  2729. 

  2730.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  2731. 

  2732.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  2733. 

  2734.                 vis_padd16(TMP0, TMP4, TMP0);

  2735.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2736. 

  2737.                 vis_padd16(TMP2, TMP6, TMP2);

  2738.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  2739. 

  2740.                 vis_padd16(TMP0, CONST_3, TMP8);

  2741.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  2742. 

  2743.                 vis_padd16(TMP2, CONST_3, TMP10);

  2744.                 vis_pack16(TMP8, DST_0);

  2745. 

  2746.                 vis_pack16(TMP10, DST_1);

  2747.                 vis_padd16(TMP16, TMP12, TMP0);

  2748. 

  2749.                 vis_st64(DST_0, dest[0]);

  2750.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  2751.                 vis_padd16(TMP18, TMP14, TMP2);

  2752. 

  2753.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  2754.                 vis_padd16(TMP0, CONST_3, TMP0);

  2755. 

  2756.                 vis_padd16(TMP2, CONST_3, TMP2);

  2757. 

  2758.                 vis_padd16(TMP0, TMP4, TMP0);

  2759. 

  2760.                 vis_padd16(TMP2, TMP6, TMP2);

  2761.                 vis_pack16(TMP0, DST_2);

  2762. 

  2763.                 vis_pack16(TMP2, DST_3);

  2764.                 vis_st64(DST_2, dest[8]);

  2765. 

  2766.                 ref += stride;

  2767.                 dest += stride;

  2768.         } while (--height);

  2769. }

  2770. 

  2771. static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * _ref,

  2772.                             const int stride, int height)

  2773. {

  2774.         uint8_t *ref = (uint8_t *) _ref;

  2775.         unsigned long off = (unsigned long) ref & 0x7;

  2776.         unsigned long off_plus_1 = off + 1;

  2777.         int stride_times_2 = stride << 1;

  2778. 

  2779.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2780. 

  2781.         vis_ld64(constants3[0], CONST_3);

  2782.         vis_fzero(ZERO);

  2783.         vis_ld64(constants256_512[0], CONST_256);

  2784. 

  2785.         ref = vis_alignaddr(ref);

  2786.         height >>= 2;

  2787.         do {    /* 47 cycles */

  2788.                 vis_ld64(ref[0],   TMP0);

  2789. 

  2790.                 vis_ld64_2(ref, 8, TMP2);

  2791.                 ref += stride;

  2792. 

  2793.                 vis_alignaddr_g0((void *)off);

  2794. 

  2795.                 vis_ld64(ref[0],   TMP4);

  2796.                 vis_faligndata(TMP0, TMP2, REF_0);

  2797. 

  2798.                 vis_ld64_2(ref, 8, TMP6);

  2799.                 ref += stride;

  2800. 

  2801.                 vis_ld64(ref[0],   TMP8);

  2802. 

  2803.                 vis_ld64_2(ref, 8, TMP10);

  2804.                 ref += stride;

  2805.                 vis_faligndata(TMP4, TMP6, REF_4);

  2806. 

  2807.                 vis_ld64(ref[0],   TMP12);

  2808. 

  2809.                 vis_ld64_2(ref, 8, TMP14);

  2810.                 ref += stride;

  2811.                 vis_faligndata(TMP8, TMP10, REF_S0);

  2812. 

  2813.                 vis_faligndata(TMP12, TMP14, REF_S4);

  2814. 

  2815.                 if (off != 0x7) {

  2816.                         vis_alignaddr_g0((void *)off_plus_1);

  2817. 

  2818.                         vis_ld64(dest[0], DST_0);

  2819.                         vis_faligndata(TMP0, TMP2, REF_2);

  2820. 

  2821.                         vis_ld64_2(dest, stride, DST_2);

  2822.                         vis_faligndata(TMP4, TMP6, REF_6);

  2823. 

  2824.                         vis_faligndata(TMP8, TMP10, REF_S2);

  2825. 

  2826.                         vis_faligndata(TMP12, TMP14, REF_S6);

  2827.                 } else {

  2828.                         vis_ld64(dest[0], DST_0);

  2829.                         vis_src1(TMP2, REF_2);

  2830. 

  2831.                         vis_ld64_2(dest, stride, DST_2);

  2832.                         vis_src1(TMP6, REF_6);

  2833. 

  2834.                         vis_src1(TMP10, REF_S2);

  2835. 

  2836.                         vis_src1(TMP14, REF_S6);

  2837.                 }

  2838. 

  2839.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  2840.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2841. 

  2842.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2843.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  2844. 

  2845.                 vis_padd16(TMP0, CONST_3, TMP0);

  2846.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  2847. 

  2848.                 vis_padd16(TMP2, CONST_3, TMP2);

  2849.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  2850. 

  2851.                 vis_padd16(TMP0, TMP4, TMP0);

  2852.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  2853. 

  2854.                 vis_padd16(TMP2, TMP6, TMP2);

  2855.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  2856. 

  2857.                 vis_padd16(TMP0, TMP16, TMP0);

  2858.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  2859. 

  2860.                 vis_padd16(TMP2, TMP18, TMP2);

  2861.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2862. 

  2863.                 vis_padd16(TMP8, CONST_3, TMP8);

  2864.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  2865. 

  2866.                 vis_padd16(TMP8, TMP12, TMP8);

  2867.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  2868. 

  2869.                 vis_padd16(TMP10, TMP14, TMP10);

  2870.                 vis_pack16(TMP0, DST_0);

  2871. 

  2872.                 vis_pack16(TMP2, DST_1);

  2873.                 vis_st64(DST_0, dest[0]);

  2874.                 dest += stride;

  2875.                 vis_padd16(TMP10, CONST_3, TMP10);

  2876. 

  2877.                 vis_ld64_2(dest, stride, DST_0);

  2878.                 vis_padd16(TMP8, TMP16, TMP8);

  2879. 

  2880.                 vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);

  2881.                 vis_padd16(TMP10, TMP18, TMP10);

  2882.                 vis_pack16(TMP8, DST_2);

  2883. 

  2884.                 vis_pack16(TMP10, DST_3);

  2885.                 vis_st64(DST_2, dest[0]);

  2886.                 dest += stride;

  2887. 

  2888.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  2889.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  2890. 

  2891.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  2892.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  2893. 

  2894.                 vis_padd16(TMP0, CONST_3, TMP0);

  2895.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  2896. 

  2897.                 vis_padd16(TMP2, CONST_3, TMP2);

  2898.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  2899. 

  2900.                 vis_padd16(TMP0, TMP24, TMP0);

  2901.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  2902. 

  2903.                 vis_padd16(TMP2, TMP6, TMP2);

  2904.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  2905. 

  2906.                 vis_padd16(TMP8, CONST_3, TMP8);

  2907.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  2908. 

  2909.                 vis_padd16(TMP10, CONST_3, TMP10);

  2910.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  2911. 

  2912.                 vis_padd16(TMP8, TMP12, TMP8);

  2913.                 vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);

  2914. 

  2915.                 vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);

  2916.                 vis_padd16(TMP0, TMP16, TMP0);

  2917. 

  2918.                 vis_padd16(TMP2, TMP18, TMP2);

  2919.                 vis_pack16(TMP0, DST_0);

  2920. 

  2921.                 vis_padd16(TMP10, TMP14, TMP10);

  2922.                 vis_pack16(TMP2, DST_1);

  2923.                 vis_st64(DST_0, dest[0]);

  2924.                 dest += stride;

  2925. 

  2926.                 vis_padd16(TMP8, TMP20, TMP8);

  2927. 

  2928.                 vis_padd16(TMP10, TMP22, TMP10);

  2929.                 vis_pack16(TMP8, DST_2);

  2930. 

  2931.                 vis_pack16(TMP10, DST_3);

  2932.                 vis_st64(DST_2, dest[0]);

  2933.                 dest += stride;

  2934.         } while (--height);

  2935. }

  2936. 

  2937. static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * _ref,

  2938.                              const int stride, int height)

  2939. {

  2940.         uint8_t *ref = (uint8_t *) _ref;

  2941. 

  2942.         ref = vis_alignaddr(ref);

  2943.         vis_ld64(ref[0], TMP0);

  2944. 

  2945.         vis_ld64_2(ref, 8, TMP2);

  2946. 

  2947.         vis_ld64_2(ref, 16, TMP4);

  2948.         ref += stride;

  2949. 

  2950.         vis_ld64(ref[0], TMP6);

  2951.         vis_faligndata(TMP0, TMP2, REF_0);

  2952. 

  2953.         vis_ld64_2(ref, 8, TMP8);

  2954.         vis_faligndata(TMP2, TMP4, REF_4);

  2955. 

  2956.         vis_ld64_2(ref, 16, TMP10);

  2957.         ref += stride;

  2958. 

  2959.         vis_ld64(constants_fe[0], MASK_fe);

  2960.         vis_faligndata(TMP6, TMP8, REF_2);

  2961. 

  2962.         vis_ld64(constants_7f[0], MASK_7f);

  2963.         vis_faligndata(TMP8, TMP10, REF_6);

  2964. 

  2965.         vis_ld64(constants128[0], CONST_128);

  2966.         height = (height >> 1) - 1;

  2967.         do {    /* 24 cycles */

  2968.                 vis_ld64(ref[0], TMP0);

  2969.                 vis_xor(REF_0, REF_2, TMP12);

  2970. 

  2971.                 vis_ld64_2(ref, 8, TMP2);

  2972.                 vis_xor(REF_4, REF_6, TMP16);

  2973. 

  2974.                 vis_ld64_2(ref, 16, TMP4);

  2975.                 ref += stride;

  2976.                 vis_and(REF_0, REF_2, TMP14);

  2977. 

  2978.                 vis_ld64(ref[0], TMP6);

  2979.                 vis_and(REF_4, REF_6, TMP18);

  2980. 

  2981.                 vis_ld64_2(ref, 8, TMP8);

  2982.                 vis_faligndata(TMP0, TMP2, REF_0);

  2983. 

  2984.                 vis_ld64_2(ref, 16, TMP10);

  2985.                 ref += stride;

  2986.                 vis_faligndata(TMP2, TMP4, REF_4);

  2987. 

  2988.                 vis_and(TMP12, MASK_fe, TMP12);

  2989. 

  2990.                 vis_and(TMP16, MASK_fe, TMP16);

  2991.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2992. 

  2993.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  2994.                 vis_xor(REF_0, REF_2, TMP0);

  2995. 

  2996.                 vis_xor(REF_4, REF_6, TMP2);

  2997. 

  2998.                 vis_and(REF_0, REF_2, TMP20);

  2999. 

  3000.                 vis_and(TMP12, MASK_7f, TMP12);

  3001. 

  3002.                 vis_and(TMP16, MASK_7f, TMP16);

  3003. 

  3004.                 vis_padd16(TMP14, TMP12, TMP12);

  3005.                 vis_st64(TMP12, dest[0]);

  3006. 

  3007.                 vis_padd16(TMP18, TMP16, TMP16);

  3008.                 vis_st64_2(TMP16, dest, 8);

  3009.                 dest += stride;

  3010. 

  3011.                 vis_and(REF_4, REF_6, TMP18);

  3012. 

  3013.                 vis_and(TMP0, MASK_fe, TMP0);

  3014. 

  3015.                 vis_and(TMP2, MASK_fe, TMP2);

  3016.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  3017. 

  3018.                 vis_faligndata(TMP6, TMP8, REF_2);

  3019.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  3020. 

  3021.                 vis_faligndata(TMP8, TMP10, REF_6);

  3022. 

  3023.                 vis_and(TMP0, MASK_7f, TMP0);

  3024. 

  3025.                 vis_and(TMP2, MASK_7f, TMP2);

  3026. 

  3027.                 vis_padd16(TMP20, TMP0, TMP0);

  3028.                 vis_st64(TMP0, dest[0]);

  3029. 

  3030.                 vis_padd16(TMP18, TMP2, TMP2);

  3031.                 vis_st64_2(TMP2, dest, 8);

  3032.                 dest += stride;

  3033.         } while (--height);

  3034. 

  3035.         vis_ld64(ref[0], TMP0);

  3036.         vis_xor(REF_0, REF_2, TMP12);

  3037. 

  3038.         vis_ld64_2(ref, 8, TMP2);

  3039.         vis_xor(REF_4, REF_6, TMP16);

  3040. 

  3041.         vis_ld64_2(ref, 16, TMP4);

  3042.         vis_and(REF_0, REF_2, TMP14);

  3043. 

  3044.         vis_and(REF_4, REF_6, TMP18);

  3045. 

  3046.         vis_faligndata(TMP0, TMP2, REF_0);

  3047. 

  3048.         vis_faligndata(TMP2, TMP4, REF_4);

  3049. 

  3050.         vis_and(TMP12, MASK_fe, TMP12);

  3051. 

  3052.         vis_and(TMP16, MASK_fe, TMP16);

  3053.         vis_mul8x16(CONST_128, TMP12, TMP12);

  3054. 

  3055.         vis_mul8x16(CONST_128, TMP16, TMP16);

  3056.         vis_xor(REF_0, REF_2, TMP0);

  3057. 

  3058.         vis_xor(REF_4, REF_6, TMP2);

  3059. 

  3060.         vis_and(REF_0, REF_2, TMP20);

  3061. 

  3062.         vis_and(TMP12, MASK_7f, TMP12);

  3063. 

  3064.         vis_and(TMP16, MASK_7f, TMP16);

  3065. 

  3066.         vis_padd16(TMP14, TMP12, TMP12);

  3067.         vis_st64(TMP12, dest[0]);

  3068. 

  3069.         vis_padd16(TMP18, TMP16, TMP16);

  3070.         vis_st64_2(TMP16, dest, 8);

  3071.         dest += stride;

  3072. 

  3073.         vis_and(REF_4, REF_6, TMP18);

  3074. 

  3075.         vis_and(TMP0, MASK_fe, TMP0);

  3076. 

  3077.         vis_and(TMP2, MASK_fe, TMP2);

  3078.         vis_mul8x16(CONST_128, TMP0, TMP0);

  3079. 

  3080.         vis_mul8x16(CONST_128, TMP2, TMP2);

  3081. 

  3082.         vis_and(TMP0, MASK_7f, TMP0);

  3083. 

  3084.         vis_and(TMP2, MASK_7f, TMP2);

  3085. 

  3086.         vis_padd16(TMP20, TMP0, TMP0);

  3087.         vis_st64(TMP0, dest[0]);

  3088. 

  3089.         vis_padd16(TMP18, TMP2, TMP2);

  3090.         vis_st64_2(TMP2, dest, 8);

  3091. }

  3092. 

  3093. static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * _ref,

  3094.                             const int stride, int height)

  3095. {

  3096.         uint8_t *ref = (uint8_t *) _ref;

  3097. 

  3098.         ref = vis_alignaddr(ref);

  3099.         vis_ld64(ref[0], TMP0);

  3100. 

  3101.         vis_ld64_2(ref, 8, TMP2);

  3102.         ref += stride;

  3103. 

  3104.         vis_ld64(ref[0], TMP4);

  3105. 

  3106.         vis_ld64_2(ref, 8, TMP6);

  3107.         ref += stride;

  3108. 

  3109.         vis_ld64(constants_fe[0], MASK_fe);

  3110.         vis_faligndata(TMP0, TMP2, REF_0);

  3111. 

  3112.         vis_ld64(constants_7f[0], MASK_7f);

  3113.         vis_faligndata(TMP4, TMP6, REF_2);

  3114. 

  3115.         vis_ld64(constants128[0], CONST_128);

  3116.         height = (height >> 1) - 1;

  3117.         do {    /* 12 cycles */

  3118.                 vis_ld64(ref[0], TMP0);

  3119.                 vis_xor(REF_0, REF_2, TMP4);

  3120. 

  3121.                 vis_ld64_2(ref, 8, TMP2);

  3122.                 ref += stride;

  3123.                 vis_and(TMP4, MASK_fe, TMP4);

  3124. 

  3125.                 vis_and(REF_0, REF_2, TMP6);

  3126.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  3127. 

  3128.                 vis_faligndata(TMP0, TMP2, REF_0);

  3129.                 vis_ld64(ref[0], TMP0);

  3130. 

  3131.                 vis_ld64_2(ref, 8, TMP2);

  3132.                 ref += stride;

  3133.                 vis_xor(REF_0, REF_2, TMP12);

  3134. 

  3135.                 vis_and(TMP4, MASK_7f, TMP4);

  3136. 

  3137.                 vis_and(TMP12, MASK_fe, TMP12);

  3138. 

  3139.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  3140.                 vis_and(REF_0, REF_2, TMP14);

  3141. 

  3142.                 vis_padd16(TMP6, TMP4, DST_0);

  3143.                 vis_st64(DST_0, dest[0]);

  3144.                 dest += stride;

  3145. 

  3146.                 vis_faligndata(TMP0, TMP2, REF_2);

  3147. 

  3148.                 vis_and(TMP12, MASK_7f, TMP12);

  3149. 

  3150.                 vis_padd16(TMP14, TMP12, DST_0);

  3151.                 vis_st64(DST_0, dest[0]);

  3152.                 dest += stride;

  3153.         } while (--height);

  3154. 

  3155.         vis_ld64(ref[0], TMP0);

  3156.         vis_xor(REF_0, REF_2, TMP4);

  3157. 

  3158.         vis_ld64_2(ref, 8, TMP2);

  3159.         vis_and(TMP4, MASK_fe, TMP4);

  3160. 

  3161.         vis_and(REF_0, REF_2, TMP6);

  3162.         vis_mul8x16(CONST_128, TMP4, TMP4);

  3163. 

  3164.         vis_faligndata(TMP0, TMP2, REF_0);

  3165. 

  3166.         vis_xor(REF_0, REF_2, TMP12);

  3167. 

  3168.         vis_and(TMP4, MASK_7f, TMP4);

  3169. 

  3170.         vis_and(TMP12, MASK_fe, TMP12);

  3171. 

  3172.         vis_mul8x16(CONST_128, TMP12, TMP12);

  3173.         vis_and(REF_0, REF_2, TMP14);

  3174. 

  3175.         vis_padd16(TMP6, TMP4, DST_0);

  3176.         vis_st64(DST_0, dest[0]);

  3177.         dest += stride;

  3178. 

  3179.         vis_and(TMP12, MASK_7f, TMP12);

  3180. 

  3181.         vis_padd16(TMP14, TMP12, DST_0);

  3182.         vis_st64(DST_0, dest[0]);

  3183. }

  3184. 

  3185. static void MC_avg_no_round_y_16_vis (uint8_t * dest, const uint8_t * _ref,

  3186.                              const int stride, int height)

  3187. {

  3188.         uint8_t *ref = (uint8_t *) _ref;

  3189.         int stride_8 = stride + 8;

  3190.         int stride_16 = stride + 16;

  3191. 

  3192.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3193. 

  3194.         ref = vis_alignaddr(ref);

  3195. 

  3196.         vis_ld64(ref[ 0], TMP0);

  3197.         vis_fzero(ZERO);

  3198. 

  3199.         vis_ld64(ref[ 8], TMP2);

  3200. 

  3201.         vis_ld64(ref[16], TMP4);

  3202. 

  3203.         vis_ld64(constants3[0], CONST_3);

  3204.         vis_faligndata(TMP0, TMP2, REF_2);

  3205. 

  3206.         vis_ld64(constants256_512[0], CONST_256);

  3207.         vis_faligndata(TMP2, TMP4, REF_6);

  3208.         height >>= 1;

  3209. 

  3210.         do {    /* 31 cycles */

  3211.                 vis_ld64_2(ref, stride, TMP0);

  3212.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  3213.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  3214. 

  3215.                 vis_ld64_2(ref, stride_8, TMP2);

  3216.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  3217.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  3218. 

  3219.                 vis_ld64_2(ref, stride_16, TMP4);

  3220.                 ref += stride;

  3221. 

  3222.                 vis_ld64(dest[0], DST_0);

  3223.                 vis_faligndata(TMP0, TMP2, REF_0);

  3224. 

  3225.                 vis_ld64_2(dest, 8, DST_2);

  3226.                 vis_faligndata(TMP2, TMP4, REF_4);

  3227. 

  3228.                 vis_ld64_2(ref, stride, TMP6);

  3229.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  3230.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  3231. 

  3232.                 vis_ld64_2(ref, stride_8, TMP8);

  3233.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  3234. 

  3235.                 vis_ld64_2(ref, stride_16, TMP10);

  3236.                 ref += stride;

  3237. 

  3238.                 vis_ld64_2(dest, stride, REF_S0/*DST_4*/);

  3239.                 vis_faligndata(TMP6, TMP8, REF_2);

  3240.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3241. 

  3242.                 vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);

  3243.                 vis_faligndata(TMP8, TMP10, REF_6);

  3244.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  3245. 

  3246.                 vis_padd16(TMP0, CONST_3, TMP0);

  3247.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  3248. 

  3249.                 vis_padd16(TMP2, CONST_3, TMP2);

  3250.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  3251. 

  3252.                 vis_padd16(TMP4, CONST_3, TMP4);

  3253.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  3254. 

  3255.                 vis_padd16(TMP6, CONST_3, TMP6);

  3256. 

  3257.                 vis_padd16(TMP12, TMP20, TMP12);

  3258.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  3259. 

  3260.                 vis_padd16(TMP14, TMP22, TMP14);

  3261.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  3262. 

  3263.                 vis_padd16(TMP16, TMP24, TMP16);

  3264.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  3265. 

  3266.                 vis_padd16(TMP18, TMP26, TMP18);

  3267.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  3268. 

  3269.                 vis_padd16(TMP12, TMP0, TMP12);

  3270.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  3271. 

  3272.                 vis_padd16(TMP14, TMP2, TMP14);

  3273.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  3274. 

  3275.                 vis_padd16(TMP16, TMP4, TMP16);

  3276.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  3277. 

  3278.                 vis_padd16(TMP18, TMP6, TMP18);

  3279.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  3280. 

  3281.                 vis_pack16(TMP12, DST_0);

  3282.                 vis_padd16(TMP28, TMP0, TMP12);

  3283. 

  3284.                 vis_pack16(TMP14, DST_1);

  3285.                 vis_st64(DST_0, dest[0]);

  3286.                 vis_padd16(TMP30, TMP2, TMP14);

  3287. 

  3288.                 vis_pack16(TMP16, DST_2);

  3289.                 vis_padd16(REF_S4, TMP4, TMP16);

  3290. 

  3291.                 vis_pack16(TMP18, DST_3);

  3292.                 vis_st64_2(DST_2, dest, 8);

  3293.                 dest += stride;

  3294.                 vis_padd16(REF_S6, TMP6, TMP18);

  3295. 

  3296.                 vis_padd16(TMP12, TMP20, TMP12);

  3297. 

  3298.                 vis_padd16(TMP14, TMP22, TMP14);

  3299.                 vis_pack16(TMP12, DST_0);

  3300. 

  3301.                 vis_padd16(TMP16, TMP24, TMP16);

  3302.                 vis_pack16(TMP14, DST_1);

  3303.                 vis_st64(DST_0, dest[0]);

  3304. 

  3305.                 vis_padd16(TMP18, TMP26, TMP18);

  3306.                 vis_pack16(TMP16, DST_2);

  3307. 

  3308.                 vis_pack16(TMP18, DST_3);

  3309.                 vis_st64_2(DST_2, dest, 8);

  3310.                 dest += stride;

  3311.         } while (--height);

  3312. }

  3313. 

  3314. static void MC_avg_no_round_y_8_vis (uint8_t * dest, const uint8_t * _ref,

  3315.                             const int stride, int height)

  3316. {

  3317.         uint8_t *ref = (uint8_t *) _ref;

  3318.         int stride_8 = stride + 8;

  3319. 

  3320.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3321. 

  3322.         ref = vis_alignaddr(ref);

  3323. 

  3324.         vis_ld64(ref[ 0], TMP0);

  3325.         vis_fzero(ZERO);

  3326. 

  3327.         vis_ld64(ref[ 8], TMP2);

  3328. 

  3329.         vis_ld64(constants3[0], CONST_3);

  3330.         vis_faligndata(TMP0, TMP2, REF_2);

  3331. 

  3332.         vis_ld64(constants256_512[0], CONST_256);

  3333. 

  3334.         height >>= 1;

  3335.         do {    /* 20 cycles */

  3336.                 vis_ld64_2(ref, stride, TMP0);

  3337.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  3338.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  3339. 

  3340.                 vis_ld64_2(ref, stride_8, TMP2);

  3341.                 ref += stride;

  3342. 

  3343.                 vis_ld64(dest[0], DST_0);

  3344. 

  3345.                 vis_ld64_2(dest, stride, DST_2);

  3346.                 vis_faligndata(TMP0, TMP2, REF_0);

  3347. 

  3348.                 vis_ld64_2(ref, stride, TMP4);

  3349.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  3350.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  3351. 

  3352.                 vis_ld64_2(ref, stride_8, TMP6);

  3353.                 ref += stride;

  3354.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  3355.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  3356. 

  3357.                 vis_padd16(TMP12, CONST_3, TMP12);

  3358.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  3359. 

  3360.                 vis_padd16(TMP14, CONST_3, TMP14);

  3361.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  3362. 

  3363.                 vis_faligndata(TMP4, TMP6, REF_2);

  3364. 

  3365.                 vis_padd16(TMP8, TMP12, TMP8);

  3366. 

  3367.                 vis_padd16(TMP10, TMP14, TMP10);

  3368.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  3369. 

  3370.                 vis_padd16(TMP8, TMP16, TMP0);

  3371.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  3372. 

  3373.                 vis_padd16(TMP10, TMP18, TMP2);

  3374.                 vis_pack16(TMP0, DST_0);

  3375. 

  3376.                 vis_pack16(TMP2, DST_1);

  3377.                 vis_st64(DST_0, dest[0]);

  3378.                 dest += stride;

  3379.                 vis_padd16(TMP12, TMP20, TMP12);

  3380. 

  3381.                 vis_padd16(TMP14, TMP22, TMP14);

  3382. 

  3383.                 vis_padd16(TMP12, TMP24, TMP0);

  3384. 

  3385.                 vis_padd16(TMP14, TMP26, TMP2);

  3386.                 vis_pack16(TMP0, DST_2);

  3387. 

  3388.                 vis_pack16(TMP2, DST_3);

  3389.                 vis_st64(DST_2, dest[0]);

  3390.                 dest += stride;

  3391.         } while (--height);

  3392. }

  3393. 

  3394. static void MC_put_no_round_xy_16_vis (uint8_t * dest, const uint8_t * _ref,

  3395.                                        const int stride, int height)

  3396. {

  3397.         uint8_t *ref = (uint8_t *) _ref;

  3398.         unsigned long off = (unsigned long) ref & 0x7;

  3399.         unsigned long off_plus_1 = off + 1;

  3400.         int stride_8 = stride + 8;

  3401.         int stride_16 = stride + 16;

  3402. 

  3403.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3404. 

  3405.         ref = vis_alignaddr(ref);

  3406. 

  3407.         vis_ld64(ref[ 0], TMP0);

  3408.         vis_fzero(ZERO);

  3409. 

  3410.         vis_ld64(ref[ 8], TMP2);

  3411. 

  3412.         vis_ld64(ref[16], TMP4);

  3413. 

  3414.         vis_ld64(constants1[0], CONST_1);

  3415.         vis_faligndata(TMP0, TMP2, REF_S0);

  3416. 

  3417.         vis_ld64(constants256_512[0], CONST_256);

  3418.         vis_faligndata(TMP2, TMP4, REF_S4);

  3419. 

  3420.         if (off != 0x7) {

  3421.                 vis_alignaddr_g0((void *)off_plus_1);

  3422.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3423.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3424.         } else {

  3425.                 vis_src1(TMP2, REF_S2);

  3426.                 vis_src1(TMP4, REF_S6);

  3427.         }

  3428. 

  3429.         height >>= 1;

  3430.         do {

  3431.                 vis_ld64_2(ref, stride, TMP0);

  3432.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3433.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3434. 

  3435.                 vis_alignaddr_g0((void *)off);

  3436. 

  3437.                 vis_ld64_2(ref, stride_8, TMP2);

  3438.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3439.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3440. 

  3441.                 vis_ld64_2(ref, stride_16, TMP4);

  3442.                 ref += stride;

  3443.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3444.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3445. 

  3446.                 vis_ld64_2(ref, stride, TMP6);

  3447.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3448.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3449. 

  3450.                 vis_ld64_2(ref, stride_8, TMP8);

  3451.                 vis_faligndata(TMP0, TMP2, REF_0);

  3452. 

  3453.                 vis_ld64_2(ref, stride_16, TMP10);

  3454.                 ref += stride;

  3455.                 vis_faligndata(TMP2, TMP4, REF_4);

  3456. 

  3457.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3458. 

  3459.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3460. 

  3461.                 if (off != 0x7) {

  3462.                         vis_alignaddr_g0((void *)off_plus_1);

  3463.                         vis_faligndata(TMP0, TMP2, REF_2);

  3464.                         vis_faligndata(TMP2, TMP4, REF_6);

  3465.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3466.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3467.                 } else {

  3468.                         vis_src1(TMP2, REF_2);

  3469.                         vis_src1(TMP4, REF_6);

  3470.                         vis_src1(TMP8, REF_S2);

  3471.                         vis_src1(TMP10, REF_S6);

  3472.                 }

  3473. 

  3474.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  3475.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3476. 

  3477.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3478.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3479. 

  3480.                 vis_padd16(TMP0, CONST_2, TMP8);

  3481.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  3482. 

  3483.                 vis_padd16(TMP2, CONST_1, TMP10);

  3484.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  3485. 

  3486.                 vis_padd16(TMP8, TMP4, TMP8);

  3487.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  3488. 

  3489.                 vis_padd16(TMP10, TMP6, TMP10);

  3490.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  3491. 

  3492.                 vis_padd16(TMP12, TMP8, TMP12);

  3493. 

  3494.                 vis_padd16(TMP14, TMP10, TMP14);

  3495. 

  3496.                 vis_padd16(TMP12, TMP16, TMP12);

  3497. 

  3498.                 vis_padd16(TMP14, TMP18, TMP14);

  3499.                 vis_pack16(TMP12, DST_0);

  3500. 

  3501.                 vis_pack16(TMP14, DST_1);

  3502.                 vis_st64(DST_0, dest[0]);

  3503.                 vis_padd16(TMP0, CONST_1, TMP12);

  3504. 

  3505.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  3506.                 vis_padd16(TMP2, CONST_1, TMP14);

  3507. 

  3508.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  3509.                 vis_padd16(TMP12, TMP4, TMP12);

  3510. 

  3511.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  3512.                 vis_padd16(TMP14, TMP6, TMP14);

  3513. 

  3514.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  3515.                 vis_padd16(TMP20, TMP12, TMP20);

  3516. 

  3517.                 vis_padd16(TMP22, TMP14, TMP22);

  3518. 

  3519.                 vis_padd16(TMP20, TMP24, TMP20);

  3520. 

  3521.                 vis_padd16(TMP22, TMP26, TMP22);

  3522.                 vis_pack16(TMP20, DST_2);

  3523. 

  3524.                 vis_pack16(TMP22, DST_3);

  3525.                 vis_st64_2(DST_2, dest, 8);

  3526.                 dest += stride;

  3527.                 vis_padd16(TMP0, TMP4, TMP24);

  3528. 

  3529.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  3530.                 vis_padd16(TMP2, TMP6, TMP26);

  3531. 

  3532.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  3533.                 vis_padd16(TMP24, TMP8, TMP24);

  3534. 

  3535.                 vis_padd16(TMP26, TMP10, TMP26);

  3536.                 vis_pack16(TMP24, DST_0);

  3537. 

  3538.                 vis_pack16(TMP26, DST_1);

  3539.                 vis_st64(DST_0, dest[0]);

  3540.                 vis_pmerge(ZERO, REF_S6, TMP4);

  3541. 

  3542.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  3543. 

  3544.                 vis_padd16(TMP0, TMP4, TMP0);

  3545. 

  3546.                 vis_padd16(TMP2, TMP6, TMP2);

  3547. 

  3548.                 vis_padd16(TMP0, TMP12, TMP0);

  3549. 

  3550.                 vis_padd16(TMP2, TMP14, TMP2);

  3551.                 vis_pack16(TMP0, DST_2);

  3552. 

  3553.                 vis_pack16(TMP2, DST_3);

  3554.                 vis_st64_2(DST_2, dest, 8);

  3555.                 dest += stride;

  3556.         } while (--height);

  3557. }

  3558. 

  3559. static void MC_put_no_round_xy_8_vis (uint8_t * dest, const uint8_t * _ref,

  3560.                                       const int stride, int height)

  3561. {

  3562.         uint8_t *ref = (uint8_t *) _ref;

  3563.         unsigned long off = (unsigned long) ref & 0x7;

  3564.         unsigned long off_plus_1 = off + 1;

  3565.         int stride_8 = stride + 8;

  3566. 

  3567.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3568. 

  3569.         ref = vis_alignaddr(ref);

  3570. 

  3571.         vis_ld64(ref[ 0], TMP0);

  3572.         vis_fzero(ZERO);

  3573. 

  3574.         vis_ld64(ref[ 8], TMP2);

  3575. 

  3576.         vis_ld64(constants1[0], CONST_1);

  3577. 

  3578.         vis_ld64(constants256_512[0], CONST_256);

  3579.         vis_faligndata(TMP0, TMP2, REF_S0);

  3580. 

  3581.         if (off != 0x7) {

  3582.                 vis_alignaddr_g0((void *)off_plus_1);

  3583.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3584.         } else {

  3585.                 vis_src1(TMP2, REF_S2);

  3586.         }

  3587. 

  3588.         height >>= 1;

  3589.         do {    /* 26 cycles */

  3590.                 vis_ld64_2(ref, stride, TMP0);

  3591.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  3592.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  3593. 

  3594.                 vis_alignaddr_g0((void *)off);

  3595. 

  3596.                 vis_ld64_2(ref, stride_8, TMP2);

  3597.                 ref += stride;

  3598.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  3599.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  3600. 

  3601.                 vis_ld64_2(ref, stride, TMP4);

  3602. 

  3603.                 vis_ld64_2(ref, stride_8, TMP6);

  3604.                 ref += stride;

  3605.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3606. 

  3607.                 vis_pmerge(ZERO, REF_S4, TMP18);

  3608. 

  3609.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  3610. 

  3611.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3612. 

  3613.                 if (off != 0x7) {

  3614.                         vis_alignaddr_g0((void *)off_plus_1);

  3615.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3616.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3617.                 } else {

  3618.                         vis_src1(TMP2, REF_S6);

  3619.                         vis_src1(TMP6, REF_S2);

  3620.                 }

  3621. 

  3622.                 vis_padd16(TMP18, CONST_1, TMP18);

  3623.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  3624. 

  3625.                 vis_padd16(TMP20, CONST_1, TMP20);

  3626.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  3627. 

  3628.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  3629.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  3630. 

  3631.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  3632.                 vis_padd16(TMP18, TMP22, TMP18);

  3633. 

  3634.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  3635.                 vis_padd16(TMP20, TMP24, TMP20);

  3636. 

  3637.                 vis_padd16(TMP8,  TMP18, TMP8);

  3638. 

  3639.                 vis_padd16(TMP10, TMP20, TMP10);

  3640. 

  3641.                 vis_padd16(TMP8,  TMP12, TMP8);

  3642. 

  3643.                 vis_padd16(TMP10, TMP14, TMP10);

  3644.                 vis_pack16(TMP8,  DST_0);

  3645. 

  3646.                 vis_pack16(TMP10, DST_1);

  3647.                 vis_st64(DST_0, dest[0]);

  3648.                 dest += stride;

  3649.                 vis_padd16(TMP18, TMP26, TMP18);

  3650. 

  3651.                 vis_padd16(TMP20, TMP28, TMP20);

  3652. 

  3653.                 vis_padd16(TMP18, TMP30, TMP18);

  3654. 

  3655.                 vis_padd16(TMP20, TMP32, TMP20);

  3656.                 vis_pack16(TMP18, DST_2);

  3657. 

  3658.                 vis_pack16(TMP20, DST_3);

  3659.                 vis_st64(DST_2, dest[0]);

  3660.                 dest += stride;

  3661.         } while (--height);

  3662. }

  3663. 

  3664. static void MC_avg_no_round_xy_16_vis (uint8_t * dest, const uint8_t * _ref,

  3665.                                        const int stride, int height)

  3666. {

  3667.         uint8_t *ref = (uint8_t *) _ref;

  3668.         unsigned long off = (unsigned long) ref & 0x7;

  3669.         unsigned long off_plus_1 = off + 1;

  3670.         int stride_8 = stride + 8;

  3671.         int stride_16 = stride + 16;

  3672. 

  3673.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3674. 

  3675.         ref = vis_alignaddr(ref);

  3676. 

  3677.         vis_ld64(ref[ 0], TMP0);

  3678.         vis_fzero(ZERO);

  3679. 

  3680.         vis_ld64(ref[ 8], TMP2);

  3681. 

  3682.         vis_ld64(ref[16], TMP4);

  3683. 

  3684.         vis_ld64(constants6[0], CONST_6);

  3685.         vis_faligndata(TMP0, TMP2, REF_S0);

  3686. 

  3687.         vis_ld64(constants256_1024[0], CONST_256);

  3688.         vis_faligndata(TMP2, TMP4, REF_S4);

  3689. 

  3690.         if (off != 0x7) {

  3691.                 vis_alignaddr_g0((void *)off_plus_1);

  3692.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3693.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3694.         } else {

  3695.                 vis_src1(TMP2, REF_S2);

  3696.                 vis_src1(TMP4, REF_S6);

  3697.         }

  3698. 

  3699.         height >>= 1;

  3700.         do {    /* 55 cycles */

  3701.                 vis_ld64_2(ref, stride, TMP0);

  3702.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3703.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3704. 

  3705.                 vis_alignaddr_g0((void *)off);

  3706. 

  3707.                 vis_ld64_2(ref, stride_8, TMP2);

  3708.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3709.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3710. 

  3711.                 vis_ld64_2(ref, stride_16, TMP4);

  3712.                 ref += stride;

  3713.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3714.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3715. 

  3716.                 vis_ld64_2(ref, stride, TMP6);

  3717.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3718.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3719. 

  3720.                 vis_ld64_2(ref, stride_8, TMP8);

  3721.                 vis_faligndata(TMP0, TMP2, REF_0);

  3722. 

  3723.                 vis_ld64_2(ref, stride_16, TMP10);

  3724.                 ref += stride;

  3725.                 vis_faligndata(TMP2, TMP4, REF_4);

  3726. 

  3727.                 vis_ld64(dest[0], DST_0);

  3728.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3729. 

  3730.                 vis_ld64_2(dest, 8, DST_2);

  3731.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3732. 

  3733.                 if (off != 0x7) {

  3734.                         vis_alignaddr_g0((void *)off_plus_1);

  3735.                         vis_faligndata(TMP0, TMP2, REF_2);

  3736.                         vis_faligndata(TMP2, TMP4, REF_6);

  3737.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3738.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3739.                 } else {

  3740.                         vis_src1(TMP2, REF_2);

  3741.                         vis_src1(TMP4, REF_6);

  3742.                         vis_src1(TMP8, REF_S2);

  3743.                         vis_src1(TMP10, REF_S6);

  3744.                 }

  3745. 

  3746.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3747.                 vis_pmerge(ZERO, REF_0, TMP0);

  3748. 

  3749.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3750.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3751. 

  3752.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3753.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3754. 

  3755.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3756.                 vis_padd16(TMP0, CONST_6, TMP0);

  3757. 

  3758.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3759.                 vis_padd16(TMP2, CONST_6, TMP2);

  3760. 

  3761.                 vis_padd16(TMP0, TMP4, TMP0);

  3762.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  3763. 

  3764.                 vis_padd16(TMP2, TMP6, TMP2);

  3765.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3766. 

  3767.                 vis_padd16(TMP12, TMP0, TMP12);

  3768.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  3769. 

  3770.                 vis_padd16(TMP14, TMP2, TMP14);

  3771.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  3772. 

  3773.                 vis_padd16(TMP12, TMP16, TMP12);

  3774.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  3775. 

  3776.                 vis_padd16(TMP14, TMP18, TMP14);

  3777.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  3778. 

  3779.                 vis_padd16(TMP12, TMP30, TMP12);

  3780. 

  3781.                 vis_padd16(TMP14, TMP32, TMP14);

  3782.                 vis_pack16(TMP12, DST_0);

  3783. 

  3784.                 vis_pack16(TMP14, DST_1);

  3785.                 vis_st64(DST_0, dest[0]);

  3786.                 vis_padd16(TMP4, CONST_6, TMP4);

  3787. 

  3788.                 vis_ld64_2(dest, stride, DST_0);

  3789.                 vis_padd16(TMP6, CONST_6, TMP6);

  3790.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3791. 

  3792.                 vis_padd16(TMP4, TMP8, TMP4);

  3793.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  3794. 

  3795.                 vis_padd16(TMP6, TMP10, TMP6);

  3796. 

  3797.                 vis_padd16(TMP20, TMP4, TMP20);

  3798. 

  3799.                 vis_padd16(TMP22, TMP6, TMP22);

  3800. 

  3801.                 vis_padd16(TMP20, TMP24, TMP20);

  3802. 

  3803.                 vis_padd16(TMP22, TMP26, TMP22);

  3804. 

  3805.                 vis_padd16(TMP20, REF_0, TMP20);

  3806.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  3807. 

  3808.                 vis_padd16(TMP22, REF_2, TMP22);

  3809.                 vis_pack16(TMP20, DST_2);

  3810. 

  3811.                 vis_pack16(TMP22, DST_3);

  3812.                 vis_st64_2(DST_2, dest, 8);

  3813.                 dest += stride;

  3814. 

  3815.                 vis_ld64_2(dest, 8, DST_2);

  3816.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3817.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  3818. 

  3819.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3820.                 vis_padd16(REF_4, TMP0, TMP8);

  3821. 

  3822.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  3823.                 vis_padd16(REF_6, TMP2, TMP10);

  3824. 

  3825.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  3826.                 vis_padd16(TMP8, TMP12, TMP8);

  3827. 

  3828.                 vis_padd16(TMP10, TMP14, TMP10);

  3829. 

  3830.                 vis_padd16(TMP8, TMP30, TMP8);

  3831. 

  3832.                 vis_padd16(TMP10, TMP32, TMP10);

  3833.                 vis_pack16(TMP8, DST_0);

  3834. 

  3835.                 vis_pack16(TMP10, DST_1);

  3836.                 vis_st64(DST_0, dest[0]);

  3837. 

  3838.                 vis_padd16(REF_0, TMP4, REF_0);

  3839. 

  3840.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  3841.                 vis_padd16(REF_2, TMP6, REF_2);

  3842. 

  3843.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  3844.                 vis_padd16(REF_0, REF_4, REF_0);

  3845. 

  3846.                 vis_padd16(REF_2, REF_6, REF_2);

  3847. 

  3848.                 vis_padd16(REF_0, TMP30, REF_0);

  3849. 

  3850.                 /* stall */

  3851. 

  3852.                 vis_padd16(REF_2, TMP32, REF_2);

  3853.                 vis_pack16(REF_0, DST_2);

  3854. 

  3855.                 vis_pack16(REF_2, DST_3);

  3856.                 vis_st64_2(DST_2, dest, 8);

  3857.                 dest += stride;

  3858.         } while (--height);

  3859. }

  3860. 

  3861. static void MC_avg_no_round_xy_8_vis (uint8_t * dest, const uint8_t * _ref,

  3862.                                       const int stride, int height)

  3863. {

  3864.         uint8_t *ref = (uint8_t *) _ref;

  3865.         unsigned long off = (unsigned long) ref & 0x7;

  3866.         unsigned long off_plus_1 = off + 1;

  3867.         int stride_8 = stride + 8;

  3868. 

  3869.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3870. 

  3871.         ref = vis_alignaddr(ref);

  3872. 

  3873.         vis_ld64(ref[0], TMP0);

  3874.         vis_fzero(ZERO);

  3875. 

  3876.         vis_ld64_2(ref, 8, TMP2);

  3877. 

  3878.         vis_ld64(constants6[0], CONST_6);

  3879. 

  3880.         vis_ld64(constants256_1024[0], CONST_256);

  3881.         vis_faligndata(TMP0, TMP2, REF_S0);

  3882. 

  3883.         if (off != 0x7) {

  3884.                 vis_alignaddr_g0((void *)off_plus_1);

  3885.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3886.         } else {

  3887.                 vis_src1(TMP2, REF_S2);

  3888.         }

  3889. 

  3890.         height >>= 1;

  3891.         do {    /* 31 cycles */

  3892.                 vis_ld64_2(ref, stride, TMP0);

  3893.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  3894.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  3895. 

  3896.                 vis_ld64_2(ref, stride_8, TMP2);

  3897.                 ref += stride;

  3898.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3899.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  3900. 

  3901.                 vis_alignaddr_g0((void *)off);

  3902. 

  3903.                 vis_ld64_2(ref, stride, TMP4);

  3904.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3905. 

  3906.                 vis_ld64_2(ref, stride_8, TMP6);

  3907.                 ref += stride;

  3908. 

  3909.                 vis_ld64(dest[0], DST_0);

  3910.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3911. 

  3912.                 vis_ld64_2(dest, stride, DST_2);

  3913. 

  3914.                 if (off != 0x7) {

  3915.                         vis_alignaddr_g0((void *)off_plus_1);

  3916.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3917.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3918.                 } else {

  3919.                         vis_src1(TMP2, REF_S6);

  3920.                         vis_src1(TMP6, REF_S2);

  3921.                 }

  3922. 

  3923.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3924.                 vis_pmerge(ZERO, REF_S4, TMP22);

  3925. 

  3926.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3927.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  3928. 

  3929.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  3930.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  3931. 

  3932.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  3933.                 vis_padd16(TMP22, CONST_6, TMP22);

  3934. 

  3935.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  3936.                 vis_padd16(TMP24, CONST_6, TMP24);

  3937. 

  3938.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3939.                 vis_padd16(TMP22, TMP26, TMP22);

  3940. 

  3941.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3942.                 vis_padd16(TMP24, TMP28, TMP24);

  3943. 

  3944.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  3945.                 vis_padd16(TMP8, TMP22, TMP8);

  3946. 

  3947.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  3948.                 vis_padd16(TMP10, TMP24, TMP10);

  3949. 

  3950.                 vis_padd16(TMP8, TMP12, TMP8);

  3951. 

  3952.                 vis_padd16(TMP10, TMP14, TMP10);

  3953. 

  3954.                 vis_padd16(TMP8, TMP30, TMP8);

  3955. 

  3956.                 vis_padd16(TMP10, TMP32, TMP10);

  3957.                 vis_pack16(TMP8, DST_0);

  3958. 

  3959.                 vis_pack16(TMP10, DST_1);

  3960.                 vis_st64(DST_0, dest[0]);

  3961.                 dest += stride;

  3962. 

  3963.                 vis_padd16(REF_S4, TMP22, TMP12);

  3964. 

  3965.                 vis_padd16(REF_S6, TMP24, TMP14);

  3966. 

  3967.                 vis_padd16(TMP12, TMP26, TMP12);

  3968. 

  3969.                 vis_padd16(TMP14, TMP28, TMP14);

  3970. 

  3971.                 vis_padd16(TMP12, REF_0, TMP12);

  3972. 

  3973.                 vis_padd16(TMP14, REF_2, TMP14);

  3974.                 vis_pack16(TMP12, DST_2);

  3975. 

  3976.                 vis_pack16(TMP14, DST_3);

  3977.                 vis_st64(DST_2, dest[0]);

  3978.                 dest += stride;

  3979.         } while (--height);

  3980. }

  3981. 

  3982. /* End of no rounding code */

  3983. 

  3984. #define ACCEL_SPARC_VIS 1

  3985. #define ACCEL_SPARC_VIS2 2

  3986. 

  3987. static int vis_level(void)

  3988. {

  3989.     int accel = 0;

  3990.     accel |= ACCEL_SPARC_VIS;

  3991.     accel |= ACCEL_SPARC_VIS2;

  3992.     return accel;

  3993. }

  3994. 

  3995. /* libavcodec initialization code */

  3996. void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx)

  3997. {

  3998.   /* VIS-specific optimizations */

  3999.   int accel = vis_level ();

  4000. 

  4001.   if (accel & ACCEL_SPARC_VIS) {

  4002.       if(avctx->idct_algo==FF_IDCT_SIMPLEVIS){

  4003.           c->idct_put = ff_simple_idct_put_vis;

  4004.           c->idct_add = ff_simple_idct_add_vis;

  4005.           c->idct     = ff_simple_idct_vis;

  4006.           c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;

  4007.       }

  4008. 

  4009.       c->put_pixels_tab[0][0] = MC_put_o_16_vis;

  4010.       c->put_pixels_tab[0][1] = MC_put_x_16_vis;

  4011.       c->put_pixels_tab[0][2] = MC_put_y_16_vis;

  4012.       c->put_pixels_tab[0][3] = MC_put_xy_16_vis;

  4013. 

  4014.       c->put_pixels_tab[1][0] = MC_put_o_8_vis;

  4015.       c->put_pixels_tab[1][1] = MC_put_x_8_vis;

  4016.       c->put_pixels_tab[1][2] = MC_put_y_8_vis;

  4017.       c->put_pixels_tab[1][3] = MC_put_xy_8_vis;

  4018. 

  4019.       c->avg_pixels_tab[0][0] = MC_avg_o_16_vis;

  4020.       c->avg_pixels_tab[0][1] = MC_avg_x_16_vis;

  4021.       c->avg_pixels_tab[0][2] = MC_avg_y_16_vis;

  4022.       c->avg_pixels_tab[0][3] = MC_avg_xy_16_vis;

  4023. 

  4024.       c->avg_pixels_tab[1][0] = MC_avg_o_8_vis;

  4025.       c->avg_pixels_tab[1][1] = MC_avg_x_8_vis;

  4026.       c->avg_pixels_tab[1][2] = MC_avg_y_8_vis;

  4027.       c->avg_pixels_tab[1][3] = MC_avg_xy_8_vis;

  4028. 

  4029.       c->put_no_rnd_pixels_tab[0][0] = MC_put_no_round_o_16_vis;

  4030.       c->put_no_rnd_pixels_tab[0][1] = MC_put_no_round_x_16_vis;

  4031.       c->put_no_rnd_pixels_tab[0][2] = MC_put_no_round_y_16_vis;

  4032.       c->put_no_rnd_pixels_tab[0][3] = MC_put_no_round_xy_16_vis;

  4033. 

  4034.       c->put_no_rnd_pixels_tab[1][0] = MC_put_no_round_o_8_vis;

  4035.       c->put_no_rnd_pixels_tab[1][1] = MC_put_no_round_x_8_vis;

  4036.       c->put_no_rnd_pixels_tab[1][2] = MC_put_no_round_y_8_vis;

  4037.       c->put_no_rnd_pixels_tab[1][3] = MC_put_no_round_xy_8_vis;

  4038. 

  4039.       c->avg_no_rnd_pixels_tab[0][0] = MC_avg_no_round_o_16_vis;

  4040.       c->avg_no_rnd_pixels_tab[0][1] = MC_avg_no_round_x_16_vis;

  4041.       c->avg_no_rnd_pixels_tab[0][2] = MC_avg_no_round_y_16_vis;

  4042.       c->avg_no_rnd_pixels_tab[0][3] = MC_avg_no_round_xy_16_vis;

  4043. 

  4044.       c->avg_no_rnd_pixels_tab[1][0] = MC_avg_no_round_o_8_vis;

  4045.       c->avg_no_rnd_pixels_tab[1][1] = MC_avg_no_round_x_8_vis;

  4046.       c->avg_no_rnd_pixels_tab[1][2] = MC_avg_no_round_y_8_vis;

  4047.       c->avg_no_rnd_pixels_tab[1][3] = MC_avg_no_round_xy_8_vis;

  4048.   }

  4049. }