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

4054 lines
119KB
Raw Blame History 

  1. /*

  2.  * dsputil_vis.c

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

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

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

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

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

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

  11.  *

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

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

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

  15.  * Lesser General Public License for more details.

  16.  *

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

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

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

  20.  */

  21. 

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

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

  24.  */

  25. 

  26. #include "config.h"

  27. 

  28. #include <inttypes.h>

  29. 

  30. #include "libavcodec/dsputil.h"

  31. 

  32. #include "vis.h"

  33. 

  34. void ff_simple_idct_put_vis(uint8_t *dest, int line_size, DCTELEM *data);

  35. void ff_simple_idct_add_vis(uint8_t *dest, int line_size, DCTELEM *data);

  36. void ff_simple_idct_vis(DCTELEM *data);

  37. 

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

  39.  * motion comp code, which is:

  40.  *

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

  42.  *

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

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

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

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

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

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

  49.  *

  50.  *      fxor            f0,   f2, f10

  51.  *      fand            f10,  f4, f10

  52.  *      fmul8x16        f8,  f10, f10

  53.  *      fand            f10,  f6, f10

  54.  *      for             f0,   f2, f12

  55.  *      fpsub16         f12, f10, f10

  56.  */

  57. 

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

  59. 

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

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

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

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

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

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

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

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

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

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

  70.         {256, 512, 256, 512};

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

  72.         {256, 1024, 256, 1024};

  73. 

  74. #define REF_0           0

  75. #define REF_0_1         1

  76. #define REF_2           2

  77. #define REF_2_1         3

  78. #define REF_4           4

  79. #define REF_4_1         5

  80. #define REF_6           6

  81. #define REF_6_1         7

  82. #define REF_S0          8

  83. #define REF_S0_1        9

  84. #define REF_S2          10

  85. #define REF_S2_1        11

  86. #define REF_S4          12

  87. #define REF_S4_1        13

  88. #define REF_S6          14

  89. #define REF_S6_1        15

  90. #define DST_0           16

  91. #define DST_1           17

  92. #define DST_2           18

  93. #define DST_3           19

  94. #define CONST_1         20

  95. #define CONST_2         20

  96. #define CONST_3         20

  97. #define CONST_6         20

  98. #define MASK_fe         20

  99. #define CONST_128       22

  100. #define CONST_256       22

  101. #define CONST_512       22

  102. #define CONST_1024      22

  103. #define TMP0            24

  104. #define TMP1            25

  105. #define TMP2            26

  106. #define TMP3            27

  107. #define TMP4            28

  108. #define TMP5            29

  109. #define ZERO            30

  110. #define MASK_7f         30

  111. 

  112. #define TMP6            32

  113. #define TMP8            34

  114. #define TMP10           36

  115. #define TMP12           38

  116. #define TMP14           40

  117. #define TMP16           42

  118. #define TMP18           44

  119. #define TMP20           46

  120. #define TMP22           48

  121. #define TMP24           50

  122. #define TMP26           52

  123. #define TMP28           54

  124. #define TMP30           56

  125. #define TMP32           58

  126. 

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

  128.                              const int stride, int height)

  129. {

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

  131. 

  132.         ref = vis_alignaddr(ref);

  133.         do {    /* 5 cycles */

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

  135. 

  136.                 vis_ld64_2(ref, 8, TMP2);

  137. 

  138.                 vis_ld64_2(ref, 16, TMP4);

  139.                 ref += stride;

  140. 

  141.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  143. 

  144.                 vis_faligndata(TMP2, TMP4, REF_2);

  145.                 vis_st64_2(REF_2, dest, 8);

  146.                 dest += stride;

  147.         } while (--height);

  148. }

  149. 

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

  151.                             const int stride, int height)

  152. {

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

  154. 

  155.         ref = vis_alignaddr(ref);

  156.         do {    /* 4 cycles */

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

  158. 

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

  160.                 ref += stride;

  161. 

  162.                 /* stall */

  163. 

  164.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  166.                 dest += stride;

  167.         } while (--height);

  168. }

  169. 

  170. 

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

  172.                              const int stride, int height)

  173. {

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

  175.         int stride_8 = stride + 8;

  176. 

  177.         ref = vis_alignaddr(ref);

  178. 

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

  180. 

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

  182. 

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

  184. 

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

  186. 

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

  188. 

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

  190.         vis_faligndata(TMP0, TMP2, REF_0);

  191. 

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

  193.         vis_faligndata(TMP2, TMP4, REF_2);

  194. 

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

  196. 

  197.         ref += stride;

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

  199. 

  200.         do {    /* 24 cycles */

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

  202.                 vis_xor(DST_0, REF_0, TMP6);

  203. 

  204.                 vis_ld64_2(ref, 8, TMP2);

  205.                 vis_and(TMP6, MASK_fe, TMP6);

  206. 

  207.                 vis_ld64_2(ref, 16, TMP4);

  208.                 ref += stride;

  209.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  210.                 vis_xor(DST_2, REF_2, TMP8);

  211. 

  212.                 vis_and(TMP8, MASK_fe, TMP8);

  213. 

  214.                 vis_or(DST_0, REF_0, TMP10);

  215.                 vis_ld64_2(dest, stride, DST_0);

  216.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  217. 

  218.                 vis_or(DST_2, REF_2, TMP12);

  219.                 vis_ld64_2(dest, stride_8, DST_2);

  220. 

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

  222.                 vis_and(TMP6, MASK_7f, TMP6);

  223. 

  224.                 vis_and(TMP8, MASK_7f, TMP8);

  225. 

  226.                 vis_psub16(TMP10, TMP6, TMP6);

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

  228. 

  229.                 vis_psub16(TMP12, TMP8, TMP8);

  230.                 vis_st64_2(TMP8, dest, 8);

  231. 

  232.                 dest += stride;

  233.                 vis_ld64_2(ref, 8, TMP16);

  234.                 vis_faligndata(TMP0, TMP2, REF_0);

  235. 

  236.                 vis_ld64_2(ref, 16, TMP18);

  237.                 vis_faligndata(TMP2, TMP4, REF_2);

  238.                 ref += stride;

  239. 

  240.                 vis_xor(DST_0, REF_0, TMP20);

  241. 

  242.                 vis_and(TMP20, MASK_fe, TMP20);

  243. 

  244.                 vis_xor(DST_2, REF_2, TMP22);

  245.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  246. 

  247.                 vis_and(TMP22, MASK_fe, TMP22);

  248. 

  249.                 vis_or(DST_0, REF_0, TMP24);

  250.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  251. 

  252.                 vis_or(DST_2, REF_2, TMP26);

  253. 

  254.                 vis_ld64_2(dest, stride, DST_0);

  255.                 vis_faligndata(TMP14, TMP16, REF_0);

  256. 

  257.                 vis_ld64_2(dest, stride_8, DST_2);

  258.                 vis_faligndata(TMP16, TMP18, REF_2);

  259. 

  260.                 vis_and(TMP20, MASK_7f, TMP20);

  261. 

  262.                 vis_and(TMP22, MASK_7f, TMP22);

  263. 

  264.                 vis_psub16(TMP24, TMP20, TMP20);

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

  266. 

  267.                 vis_psub16(TMP26, TMP22, TMP22);

  268.                 vis_st64_2(TMP22, dest, 8);

  269.                 dest += stride;

  270.         } while (--height);

  271. 

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

  273.         vis_xor(DST_0, REF_0, TMP6);

  274. 

  275.         vis_ld64_2(ref, 8, TMP2);

  276.         vis_and(TMP6, MASK_fe, TMP6);

  277. 

  278.         vis_ld64_2(ref, 16, TMP4);

  279.         vis_mul8x16(CONST_128, TMP6, TMP6);

  280.         vis_xor(DST_2, REF_2, TMP8);

  281. 

  282.         vis_and(TMP8, MASK_fe, TMP8);

  283. 

  284.         vis_or(DST_0, REF_0, TMP10);

  285.         vis_ld64_2(dest, stride, DST_0);

  286.         vis_mul8x16(CONST_128, TMP8, TMP8);

  287. 

  288.         vis_or(DST_2, REF_2, TMP12);

  289.         vis_ld64_2(dest, stride_8, DST_2);

  290. 

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

  292.         vis_and(TMP6, MASK_7f, TMP6);

  293. 

  294.         vis_and(TMP8, MASK_7f, TMP8);

  295. 

  296.         vis_psub16(TMP10, TMP6, TMP6);

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

  298. 

  299.         vis_psub16(TMP12, TMP8, TMP8);

  300.         vis_st64_2(TMP8, dest, 8);

  301. 

  302.         dest += stride;

  303.         vis_faligndata(TMP0, TMP2, REF_0);

  304. 

  305.         vis_faligndata(TMP2, TMP4, REF_2);

  306. 

  307.         vis_xor(DST_0, REF_0, TMP20);

  308. 

  309.         vis_and(TMP20, MASK_fe, TMP20);

  310. 

  311.         vis_xor(DST_2, REF_2, TMP22);

  312.         vis_mul8x16(CONST_128, TMP20, TMP20);

  313. 

  314.         vis_and(TMP22, MASK_fe, TMP22);

  315. 

  316.         vis_or(DST_0, REF_0, TMP24);

  317.         vis_mul8x16(CONST_128, TMP22, TMP22);

  318. 

  319.         vis_or(DST_2, REF_2, TMP26);

  320. 

  321.         vis_and(TMP20, MASK_7f, TMP20);

  322. 

  323.         vis_and(TMP22, MASK_7f, TMP22);

  324. 

  325.         vis_psub16(TMP24, TMP20, TMP20);

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

  327. 

  328.         vis_psub16(TMP26, TMP22, TMP22);

  329.         vis_st64_2(TMP22, dest, 8);

  330. }

  331. 

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

  333.                             const int stride, int height)

  334. {

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

  336. 

  337.         ref = vis_alignaddr(ref);

  338. 

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

  340. 

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

  342. 

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

  344. 

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

  346. 

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

  348.         vis_faligndata(TMP0, TMP2, REF_0);

  349. 

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

  351. 

  352.         ref += stride;

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

  354. 

  355.         do {    /* 12 cycles */

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

  357.                 vis_xor(DST_0, REF_0, TMP4);

  358. 

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

  360.                 vis_and(TMP4, MASK_fe, TMP4);

  361. 

  362.                 vis_or(DST_0, REF_0, TMP6);

  363.                 vis_ld64_2(dest, stride, DST_0);

  364.                 ref += stride;

  365.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  366. 

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

  368.                 vis_faligndata(TMP0, TMP2, REF_0);

  369. 

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

  371.                 vis_xor(DST_0, REF_0, TMP0);

  372.                 ref += stride;

  373. 

  374.                 vis_and(TMP0, MASK_fe, TMP0);

  375. 

  376.                 vis_and(TMP4, MASK_7f, TMP4);

  377. 

  378.                 vis_psub16(TMP6, TMP4, TMP4);

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

  380.                 dest += stride;

  381.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  382. 

  383.                 vis_or(DST_0, REF_0, TMP6);

  384.                 vis_ld64_2(dest, stride, DST_0);

  385. 

  386.                 vis_faligndata(TMP12, TMP2, REF_0);

  387. 

  388.                 vis_and(TMP0, MASK_7f, TMP0);

  389. 

  390.                 vis_psub16(TMP6, TMP0, TMP4);

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

  392.                 dest += stride;

  393.         } while (--height);

  394. 

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

  396.         vis_xor(DST_0, REF_0, TMP4);

  397. 

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

  399.         vis_and(TMP4, MASK_fe, TMP4);

  400. 

  401.         vis_or(DST_0, REF_0, TMP6);

  402.         vis_ld64_2(dest, stride, DST_0);

  403.         vis_mul8x16(CONST_128, TMP4, TMP4);

  404. 

  405.         vis_faligndata(TMP0, TMP2, REF_0);

  406. 

  407.         vis_xor(DST_0, REF_0, TMP0);

  408. 

  409.         vis_and(TMP0, MASK_fe, TMP0);

  410. 

  411.         vis_and(TMP4, MASK_7f, TMP4);

  412. 

  413.         vis_psub16(TMP6, TMP4, TMP4);

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

  415.         dest += stride;

  416.         vis_mul8x16(CONST_128, TMP0, TMP0);

  417. 

  418.         vis_or(DST_0, REF_0, TMP6);

  419. 

  420.         vis_and(TMP0, MASK_7f, TMP0);

  421. 

  422.         vis_psub16(TMP6, TMP0, TMP4);

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

  424. }

  425. 

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

  427.                              const int stride, int height)

  428. {

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

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

  431.         unsigned long off_plus_1 = off + 1;

  432. 

  433.         ref = vis_alignaddr(ref);

  434. 

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

  436. 

  437.         vis_ld64_2(ref, 8,  TMP2);

  438. 

  439.         vis_ld64_2(ref, 16, TMP4);

  440. 

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

  442. 

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

  444.         vis_faligndata(TMP0, TMP2, REF_0);

  445. 

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

  447.         vis_faligndata(TMP2, TMP4, REF_4);

  448. 

  449.         if (off != 0x7) {

  450.                 vis_alignaddr_g0((void *)off_plus_1);

  451.                 vis_faligndata(TMP0, TMP2, REF_2);

  452.                 vis_faligndata(TMP2, TMP4, REF_6);

  453.         } else {

  454.                 vis_src1(TMP2, REF_2);

  455.                 vis_src1(TMP4, REF_6);

  456.         }

  457. 

  458.         ref += stride;

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

  460. 

  461.         do {    /* 34 cycles */

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

  463.                 vis_xor(REF_0, REF_2, TMP6);

  464. 

  465.                 vis_ld64_2(ref, 8,  TMP2);

  466.                 vis_xor(REF_4, REF_6, TMP8);

  467. 

  468.                 vis_ld64_2(ref, 16, TMP4);

  469.                 vis_and(TMP6, MASK_fe, TMP6);

  470.                 ref += stride;

  471. 

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

  473.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  474.                 vis_and(TMP8, MASK_fe, TMP8);

  475. 

  476.                 vis_ld64_2(ref, 8,  TMP16);

  477.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  478.                 vis_or(REF_0, REF_2, TMP10);

  479. 

  480.                 vis_ld64_2(ref, 16, TMP18);

  481.                 ref += stride;

  482.                 vis_or(REF_4, REF_6, TMP12);

  483. 

  484.                 vis_alignaddr_g0((void *)off);

  485. 

  486.                 vis_faligndata(TMP0, TMP2, REF_0);

  487. 

  488.                 vis_faligndata(TMP2, TMP4, REF_4);

  489. 

  490.                 if (off != 0x7) {

  491.                         vis_alignaddr_g0((void *)off_plus_1);

  492.                         vis_faligndata(TMP0, TMP2, REF_2);

  493.                         vis_faligndata(TMP2, TMP4, REF_6);

  494.                 } else {

  495.                         vis_src1(TMP2, REF_2);

  496.                         vis_src1(TMP4, REF_6);

  497.                 }

  498. 

  499.                 vis_and(TMP6, MASK_7f, TMP6);

  500. 

  501.                 vis_and(TMP8, MASK_7f, TMP8);

  502. 

  503.                 vis_psub16(TMP10, TMP6, TMP6);

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

  505. 

  506.                 vis_psub16(TMP12, TMP8, TMP8);

  507.                 vis_st64_2(TMP8, dest, 8);

  508.                 dest += stride;

  509. 

  510.                 vis_xor(REF_0, REF_2, TMP6);

  511. 

  512.                 vis_xor(REF_4, REF_6, TMP8);

  513. 

  514.                 vis_and(TMP6, MASK_fe, TMP6);

  515. 

  516.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  517.                 vis_and(TMP8, MASK_fe, TMP8);

  518. 

  519.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  520.                 vis_or(REF_0, REF_2, TMP10);

  521. 

  522.                 vis_or(REF_4, REF_6, TMP12);

  523. 

  524.                 vis_alignaddr_g0((void *)off);

  525. 

  526.                 vis_faligndata(TMP14, TMP16, REF_0);

  527. 

  528.                 vis_faligndata(TMP16, TMP18, REF_4);

  529. 

  530.                 if (off != 0x7) {

  531.                         vis_alignaddr_g0((void *)off_plus_1);

  532.                         vis_faligndata(TMP14, TMP16, REF_2);

  533.                         vis_faligndata(TMP16, TMP18, REF_6);

  534.                 } else {

  535.                         vis_src1(TMP16, REF_2);

  536.                         vis_src1(TMP18, REF_6);

  537.                 }

  538. 

  539.                 vis_and(TMP6, MASK_7f, TMP6);

  540. 

  541.                 vis_and(TMP8, MASK_7f, TMP8);

  542. 

  543.                 vis_psub16(TMP10, TMP6, TMP6);

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

  545. 

  546.                 vis_psub16(TMP12, TMP8, TMP8);

  547.                 vis_st64_2(TMP8, dest, 8);

  548.                 dest += stride;

  549.         } while (--height);

  550. 

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

  552.         vis_xor(REF_0, REF_2, TMP6);

  553. 

  554.         vis_ld64_2(ref, 8,  TMP2);

  555.         vis_xor(REF_4, REF_6, TMP8);

  556. 

  557.         vis_ld64_2(ref, 16, TMP4);

  558.         vis_and(TMP6, MASK_fe, TMP6);

  559. 

  560.         vis_mul8x16(CONST_128, TMP6, TMP6);

  561.         vis_and(TMP8, MASK_fe, TMP8);

  562. 

  563.         vis_mul8x16(CONST_128, TMP8, TMP8);

  564.         vis_or(REF_0, REF_2, TMP10);

  565. 

  566.         vis_or(REF_4, REF_6, TMP12);

  567. 

  568.         vis_alignaddr_g0((void *)off);

  569. 

  570.         vis_faligndata(TMP0, TMP2, REF_0);

  571. 

  572.         vis_faligndata(TMP2, TMP4, REF_4);

  573. 

  574.         if (off != 0x7) {

  575.                 vis_alignaddr_g0((void *)off_plus_1);

  576.                 vis_faligndata(TMP0, TMP2, REF_2);

  577.                 vis_faligndata(TMP2, TMP4, REF_6);

  578.         } else {

  579.                 vis_src1(TMP2, REF_2);

  580.                 vis_src1(TMP4, REF_6);

  581.         }

  582. 

  583.         vis_and(TMP6, MASK_7f, TMP6);

  584. 

  585.         vis_and(TMP8, MASK_7f, TMP8);

  586. 

  587.         vis_psub16(TMP10, TMP6, TMP6);

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

  589. 

  590.         vis_psub16(TMP12, TMP8, TMP8);

  591.         vis_st64_2(TMP8, dest, 8);

  592.         dest += stride;

  593. 

  594.         vis_xor(REF_0, REF_2, TMP6);

  595. 

  596.         vis_xor(REF_4, REF_6, TMP8);

  597. 

  598.         vis_and(TMP6, MASK_fe, TMP6);

  599. 

  600.         vis_mul8x16(CONST_128, TMP6, TMP6);

  601.         vis_and(TMP8, MASK_fe, TMP8);

  602. 

  603.         vis_mul8x16(CONST_128, TMP8, TMP8);

  604.         vis_or(REF_0, REF_2, TMP10);

  605. 

  606.         vis_or(REF_4, REF_6, TMP12);

  607. 

  608.         vis_and(TMP6, MASK_7f, TMP6);

  609. 

  610.         vis_and(TMP8, MASK_7f, TMP8);

  611. 

  612.         vis_psub16(TMP10, TMP6, TMP6);

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

  614. 

  615.         vis_psub16(TMP12, TMP8, TMP8);

  616.         vis_st64_2(TMP8, dest, 8);

  617. }

  618. 

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

  620.                             const int stride, int height)

  621. {

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

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

  624.         unsigned long off_plus_1 = off + 1;

  625. 

  626.         ref = vis_alignaddr(ref);

  627. 

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

  629. 

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

  631. 

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

  633. 

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

  635. 

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

  637.         vis_faligndata(TMP0, TMP2, REF_0);

  638. 

  639.         if (off != 0x7) {

  640.                 vis_alignaddr_g0((void *)off_plus_1);

  641.                 vis_faligndata(TMP0, TMP2, REF_2);

  642.         } else {

  643.                 vis_src1(TMP2, REF_2);

  644.         }

  645. 

  646.         ref += stride;

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

  648. 

  649.         do {    /* 20 cycles */

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

  651.                 vis_xor(REF_0, REF_2, TMP4);

  652. 

  653.                 vis_ld64_2(ref, 8, TMP2);

  654.                 vis_and(TMP4, MASK_fe, TMP4);

  655.                 ref += stride;

  656. 

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

  658.                 vis_or(REF_0, REF_2, TMP6);

  659.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  660. 

  661.                 vis_alignaddr_g0((void *)off);

  662. 

  663.                 vis_ld64_2(ref, 8, TMP10);

  664.                 ref += stride;

  665.                 vis_faligndata(TMP0, TMP2, REF_0);

  666. 

  667.                 if (off != 0x7) {

  668.                         vis_alignaddr_g0((void *)off_plus_1);

  669.                         vis_faligndata(TMP0, TMP2, REF_2);

  670.                 } else {

  671.                         vis_src1(TMP2, REF_2);

  672.                 }

  673. 

  674.                 vis_and(TMP4, MASK_7f, TMP4);

  675. 

  676.                 vis_psub16(TMP6, TMP4, DST_0);

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

  678.                 dest += stride;

  679. 

  680.                 vis_xor(REF_0, REF_2, TMP12);

  681. 

  682.                 vis_and(TMP12, MASK_fe, TMP12);

  683. 

  684.                 vis_or(REF_0, REF_2, TMP14);

  685.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  686. 

  687.                 vis_alignaddr_g0((void *)off);

  688.                 vis_faligndata(TMP8, TMP10, REF_0);

  689.                 if (off != 0x7) {

  690.                         vis_alignaddr_g0((void *)off_plus_1);

  691.                         vis_faligndata(TMP8, TMP10, REF_2);

  692.                 } else {

  693.                         vis_src1(TMP10, REF_2);

  694.                 }

  695. 

  696.                 vis_and(TMP12, MASK_7f, TMP12);

  697. 

  698.                 vis_psub16(TMP14, TMP12, DST_0);

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

  700.                 dest += stride;

  701.         } while (--height);

  702. 

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

  704.         vis_xor(REF_0, REF_2, TMP4);

  705. 

  706.         vis_ld64_2(ref, 8, TMP2);

  707.         vis_and(TMP4, MASK_fe, TMP4);

  708. 

  709.         vis_or(REF_0, REF_2, TMP6);

  710.         vis_mul8x16(CONST_128, TMP4, TMP4);

  711. 

  712.         vis_alignaddr_g0((void *)off);

  713. 

  714.         vis_faligndata(TMP0, TMP2, REF_0);

  715. 

  716.         if (off != 0x7) {

  717.                 vis_alignaddr_g0((void *)off_plus_1);

  718.                 vis_faligndata(TMP0, TMP2, REF_2);

  719.         } else {

  720.                 vis_src1(TMP2, REF_2);

  721.         }

  722. 

  723.         vis_and(TMP4, MASK_7f, TMP4);

  724. 

  725.         vis_psub16(TMP6, TMP4, DST_0);

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

  727.         dest += stride;

  728. 

  729.         vis_xor(REF_0, REF_2, TMP12);

  730. 

  731.         vis_and(TMP12, MASK_fe, TMP12);

  732. 

  733.         vis_or(REF_0, REF_2, TMP14);

  734.         vis_mul8x16(CONST_128, TMP12, TMP12);

  735. 

  736.         vis_and(TMP12, MASK_7f, TMP12);

  737. 

  738.         vis_psub16(TMP14, TMP12, DST_0);

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

  740.         dest += stride;

  741. }

  742. 

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

  744.                              const int stride, int height)

  745. {

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

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

  748.         unsigned long off_plus_1 = off + 1;

  749. 

  750.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  751. 

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

  753.         vis_fzero(ZERO);

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

  755. 

  756.         ref = vis_alignaddr(ref);

  757.         do {    /* 26 cycles */

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

  759. 

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

  761. 

  762.                 vis_alignaddr_g0((void *)off);

  763. 

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

  765. 

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

  767.                 vis_faligndata(TMP0, TMP2, REF_0);

  768. 

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

  770.                 vis_faligndata(TMP2, TMP4, REF_4);

  771. 

  772.                 if (off != 0x7) {

  773.                         vis_alignaddr_g0((void *)off_plus_1);

  774.                         vis_faligndata(TMP0, TMP2, REF_2);

  775.                         vis_faligndata(TMP2, TMP4, REF_6);

  776.                 } else {

  777.                         vis_src1(TMP2, REF_2);

  778.                         vis_src1(TMP4, REF_6);

  779.                 }

  780. 

  781.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  782. 

  783.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  784.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  785. 

  786.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  787. 

  788.                 vis_padd16(TMP0, TMP4, TMP0);

  789. 

  790.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  791.                 vis_padd16(TMP2, TMP6, TMP2);

  792. 

  793.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  794. 

  795.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  796. 

  797.                 vis_padd16(TMP0, TMP4, TMP0);

  798.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  799. 

  800.                 vis_padd16(TMP2, TMP6, TMP2);

  801.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  802. 

  803.                 vis_padd16(TMP0, CONST_3, TMP8);

  804.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  805. 

  806.                 vis_padd16(TMP2, CONST_3, TMP10);

  807.                 vis_pack16(TMP8, DST_0);

  808. 

  809.                 vis_pack16(TMP10, DST_1);

  810.                 vis_padd16(TMP16, TMP12, TMP0);

  811. 

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

  813.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  814.                 vis_padd16(TMP18, TMP14, TMP2);

  815. 

  816.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  817.                 vis_padd16(TMP0, CONST_3, TMP0);

  818. 

  819.                 vis_padd16(TMP2, CONST_3, TMP2);

  820. 

  821.                 vis_padd16(TMP0, TMP4, TMP0);

  822. 

  823.                 vis_padd16(TMP2, TMP6, TMP2);

  824.                 vis_pack16(TMP0, DST_2);

  825. 

  826.                 vis_pack16(TMP2, DST_3);

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

  828. 

  829.                 ref += stride;

  830.                 dest += stride;

  831.         } while (--height);

  832. }

  833. 

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

  835.                             const int stride, int height)

  836. {

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

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

  839.         unsigned long off_plus_1 = off + 1;

  840.         int stride_times_2 = stride << 1;

  841. 

  842.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  843. 

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

  845.         vis_fzero(ZERO);

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

  847. 

  848.         ref = vis_alignaddr(ref);

  849.         height >>= 2;

  850.         do {    /* 47 cycles */

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

  852. 

  853.                 vis_ld64_2(ref, 8, TMP2);

  854.                 ref += stride;

  855. 

  856.                 vis_alignaddr_g0((void *)off);

  857. 

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

  859.                 vis_faligndata(TMP0, TMP2, REF_0);

  860. 

  861.                 vis_ld64_2(ref, 8, TMP6);

  862.                 ref += stride;

  863. 

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

  865. 

  866.                 vis_ld64_2(ref, 8, TMP10);

  867.                 ref += stride;

  868.                 vis_faligndata(TMP4, TMP6, REF_4);

  869. 

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

  871. 

  872.                 vis_ld64_2(ref, 8, TMP14);

  873.                 ref += stride;

  874.                 vis_faligndata(TMP8, TMP10, REF_S0);

  875. 

  876.                 vis_faligndata(TMP12, TMP14, REF_S4);

  877. 

  878.                 if (off != 0x7) {

  879.                         vis_alignaddr_g0((void *)off_plus_1);

  880. 

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

  882.                         vis_faligndata(TMP0, TMP2, REF_2);

  883. 

  884.                         vis_ld64_2(dest, stride, DST_2);

  885.                         vis_faligndata(TMP4, TMP6, REF_6);

  886. 

  887.                         vis_faligndata(TMP8, TMP10, REF_S2);

  888. 

  889.                         vis_faligndata(TMP12, TMP14, REF_S6);

  890.                 } else {

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

  892.                         vis_src1(TMP2, REF_2);

  893. 

  894.                         vis_ld64_2(dest, stride, DST_2);

  895.                         vis_src1(TMP6, REF_6);

  896. 

  897.                         vis_src1(TMP10, REF_S2);

  898. 

  899.                         vis_src1(TMP14, REF_S6);

  900.                 }

  901. 

  902.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  903.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  904. 

  905.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  906.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  907. 

  908.                 vis_padd16(TMP0, CONST_3, TMP0);

  909.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  910. 

  911.                 vis_padd16(TMP2, CONST_3, TMP2);

  912.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  913. 

  914.                 vis_padd16(TMP0, TMP4, TMP0);

  915.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  916. 

  917.                 vis_padd16(TMP2, TMP6, TMP2);

  918.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  919. 

  920.                 vis_padd16(TMP0, TMP16, TMP0);

  921.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  922. 

  923.                 vis_padd16(TMP2, TMP18, TMP2);

  924.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  925. 

  926.                 vis_padd16(TMP8, CONST_3, TMP8);

  927.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  928. 

  929.                 vis_padd16(TMP8, TMP12, TMP8);

  930.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  931. 

  932.                 vis_padd16(TMP10, TMP14, TMP10);

  933.                 vis_pack16(TMP0, DST_0);

  934. 

  935.                 vis_pack16(TMP2, DST_1);

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

  937.                 dest += stride;

  938.                 vis_padd16(TMP10, CONST_3, TMP10);

  939. 

  940.                 vis_ld64_2(dest, stride, DST_0);

  941.                 vis_padd16(TMP8, TMP16, TMP8);

  942. 

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

  944.                 vis_padd16(TMP10, TMP18, TMP10);

  945.                 vis_pack16(TMP8, DST_2);

  946. 

  947.                 vis_pack16(TMP10, DST_3);

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

  949.                 dest += stride;

  950. 

  951.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  952.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  953. 

  954.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  955.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  956. 

  957.                 vis_padd16(TMP0, CONST_3, TMP0);

  958.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  959. 

  960.                 vis_padd16(TMP2, CONST_3, TMP2);

  961.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  962. 

  963.                 vis_padd16(TMP0, TMP24, TMP0);

  964.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  965. 

  966.                 vis_padd16(TMP2, TMP6, TMP2);

  967.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  968. 

  969.                 vis_padd16(TMP8, CONST_3, TMP8);

  970.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  971. 

  972.                 vis_padd16(TMP10, CONST_3, TMP10);

  973.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  974. 

  975.                 vis_padd16(TMP8, TMP12, TMP8);

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

  977. 

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

  979.                 vis_padd16(TMP0, TMP16, TMP0);

  980. 

  981.                 vis_padd16(TMP2, TMP18, TMP2);

  982.                 vis_pack16(TMP0, DST_0);

  983. 

  984.                 vis_padd16(TMP10, TMP14, TMP10);

  985.                 vis_pack16(TMP2, DST_1);

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

  987.                 dest += stride;

  988. 

  989.                 vis_padd16(TMP8, TMP20, TMP8);

  990. 

  991.                 vis_padd16(TMP10, TMP22, TMP10);

  992.                 vis_pack16(TMP8, DST_2);

  993. 

  994.                 vis_pack16(TMP10, DST_3);

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

  996.                 dest += stride;

  997.         } while (--height);

  998. }

  999. 

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

  1001.                              const int stride, int height)

  1002. {

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

  1004. 

  1005.         ref = vis_alignaddr(ref);

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

  1007. 

  1008.         vis_ld64_2(ref, 8, TMP2);

  1009. 

  1010.         vis_ld64_2(ref, 16, TMP4);

  1011.         ref += stride;

  1012. 

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

  1014.         vis_faligndata(TMP0, TMP2, REF_0);

  1015. 

  1016.         vis_ld64_2(ref, 8, TMP8);

  1017.         vis_faligndata(TMP2, TMP4, REF_4);

  1018. 

  1019.         vis_ld64_2(ref, 16, TMP10);

  1020.         ref += stride;

  1021. 

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

  1023.         vis_faligndata(TMP6, TMP8, REF_2);

  1024. 

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

  1026.         vis_faligndata(TMP8, TMP10, REF_6);

  1027. 

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

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

  1030.         do {    /* 24 cycles */

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

  1032.                 vis_xor(REF_0, REF_2, TMP12);

  1033. 

  1034.                 vis_ld64_2(ref, 8, TMP2);

  1035.                 vis_xor(REF_4, REF_6, TMP16);

  1036. 

  1037.                 vis_ld64_2(ref, 16, TMP4);

  1038.                 ref += stride;

  1039.                 vis_or(REF_0, REF_2, TMP14);

  1040. 

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

  1042.                 vis_or(REF_4, REF_6, TMP18);

  1043. 

  1044.                 vis_ld64_2(ref, 8, TMP8);

  1045.                 vis_faligndata(TMP0, TMP2, REF_0);

  1046. 

  1047.                 vis_ld64_2(ref, 16, TMP10);

  1048.                 ref += stride;

  1049.                 vis_faligndata(TMP2, TMP4, REF_4);

  1050. 

  1051.                 vis_and(TMP12, MASK_fe, TMP12);

  1052. 

  1053.                 vis_and(TMP16, MASK_fe, TMP16);

  1054.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1055. 

  1056.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  1057.                 vis_xor(REF_0, REF_2, TMP0);

  1058. 

  1059.                 vis_xor(REF_4, REF_6, TMP2);

  1060. 

  1061.                 vis_or(REF_0, REF_2, TMP20);

  1062. 

  1063.                 vis_and(TMP12, MASK_7f, TMP12);

  1064. 

  1065.                 vis_and(TMP16, MASK_7f, TMP16);

  1066. 

  1067.                 vis_psub16(TMP14, TMP12, TMP12);

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

  1069. 

  1070.                 vis_psub16(TMP18, TMP16, TMP16);

  1071.                 vis_st64_2(TMP16, dest, 8);

  1072.                 dest += stride;

  1073. 

  1074.                 vis_or(REF_4, REF_6, TMP18);

  1075. 

  1076.                 vis_and(TMP0, MASK_fe, TMP0);

  1077. 

  1078.                 vis_and(TMP2, MASK_fe, TMP2);

  1079.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  1080. 

  1081.                 vis_faligndata(TMP6, TMP8, REF_2);

  1082.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  1083. 

  1084.                 vis_faligndata(TMP8, TMP10, REF_6);

  1085. 

  1086.                 vis_and(TMP0, MASK_7f, TMP0);

  1087. 

  1088.                 vis_and(TMP2, MASK_7f, TMP2);

  1089. 

  1090.                 vis_psub16(TMP20, TMP0, TMP0);

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

  1092. 

  1093.                 vis_psub16(TMP18, TMP2, TMP2);

  1094.                 vis_st64_2(TMP2, dest, 8);

  1095.                 dest += stride;

  1096.         } while (--height);

  1097. 

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

  1099.         vis_xor(REF_0, REF_2, TMP12);

  1100. 

  1101.         vis_ld64_2(ref, 8, TMP2);

  1102.         vis_xor(REF_4, REF_6, TMP16);

  1103. 

  1104.         vis_ld64_2(ref, 16, TMP4);

  1105.         vis_or(REF_0, REF_2, TMP14);

  1106. 

  1107.         vis_or(REF_4, REF_6, TMP18);

  1108. 

  1109.         vis_faligndata(TMP0, TMP2, REF_0);

  1110. 

  1111.         vis_faligndata(TMP2, TMP4, REF_4);

  1112. 

  1113.         vis_and(TMP12, MASK_fe, TMP12);

  1114. 

  1115.         vis_and(TMP16, MASK_fe, TMP16);

  1116.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1117. 

  1118.         vis_mul8x16(CONST_128, TMP16, TMP16);

  1119.         vis_xor(REF_0, REF_2, TMP0);

  1120. 

  1121.         vis_xor(REF_4, REF_6, TMP2);

  1122. 

  1123.         vis_or(REF_0, REF_2, TMP20);

  1124. 

  1125.         vis_and(TMP12, MASK_7f, TMP12);

  1126. 

  1127.         vis_and(TMP16, MASK_7f, TMP16);

  1128. 

  1129.         vis_psub16(TMP14, TMP12, TMP12);

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

  1131. 

  1132.         vis_psub16(TMP18, TMP16, TMP16);

  1133.         vis_st64_2(TMP16, dest, 8);

  1134.         dest += stride;

  1135. 

  1136.         vis_or(REF_4, REF_6, TMP18);

  1137. 

  1138.         vis_and(TMP0, MASK_fe, TMP0);

  1139. 

  1140.         vis_and(TMP2, MASK_fe, TMP2);

  1141.         vis_mul8x16(CONST_128, TMP0, TMP0);

  1142. 

  1143.         vis_mul8x16(CONST_128, TMP2, TMP2);

  1144. 

  1145.         vis_and(TMP0, MASK_7f, TMP0);

  1146. 

  1147.         vis_and(TMP2, MASK_7f, TMP2);

  1148. 

  1149.         vis_psub16(TMP20, TMP0, TMP0);

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

  1151. 

  1152.         vis_psub16(TMP18, TMP2, TMP2);

  1153.         vis_st64_2(TMP2, dest, 8);

  1154. }

  1155. 

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

  1157.                             const int stride, int height)

  1158. {

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

  1160. 

  1161.         ref = vis_alignaddr(ref);

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

  1163. 

  1164.         vis_ld64_2(ref, 8, TMP2);

  1165.         ref += stride;

  1166. 

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

  1168. 

  1169.         vis_ld64_2(ref, 8, TMP6);

  1170.         ref += stride;

  1171. 

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

  1173.         vis_faligndata(TMP0, TMP2, REF_0);

  1174. 

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

  1176.         vis_faligndata(TMP4, TMP6, REF_2);

  1177. 

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

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

  1180.         do {    /* 12 cycles */

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

  1182.                 vis_xor(REF_0, REF_2, TMP4);

  1183. 

  1184.                 vis_ld64_2(ref, 8, TMP2);

  1185.                 ref += stride;

  1186.                 vis_and(TMP4, MASK_fe, TMP4);

  1187. 

  1188.                 vis_or(REF_0, REF_2, TMP6);

  1189.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  1190. 

  1191.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  1193. 

  1194.                 vis_ld64_2(ref, 8, TMP2);

  1195.                 ref += stride;

  1196.                 vis_xor(REF_0, REF_2, TMP12);

  1197. 

  1198.                 vis_and(TMP4, MASK_7f, TMP4);

  1199. 

  1200.                 vis_and(TMP12, MASK_fe, TMP12);

  1201. 

  1202.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1203.                 vis_or(REF_0, REF_2, TMP14);

  1204. 

  1205.                 vis_psub16(TMP6, TMP4, DST_0);

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

  1207.                 dest += stride;

  1208. 

  1209.                 vis_faligndata(TMP0, TMP2, REF_2);

  1210. 

  1211.                 vis_and(TMP12, MASK_7f, TMP12);

  1212. 

  1213.                 vis_psub16(TMP14, TMP12, DST_0);

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

  1215.                 dest += stride;

  1216.         } while (--height);

  1217. 

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

  1219.         vis_xor(REF_0, REF_2, TMP4);

  1220. 

  1221.         vis_ld64_2(ref, 8, TMP2);

  1222.         vis_and(TMP4, MASK_fe, TMP4);

  1223. 

  1224.         vis_or(REF_0, REF_2, TMP6);

  1225.         vis_mul8x16(CONST_128, TMP4, TMP4);

  1226. 

  1227.         vis_faligndata(TMP0, TMP2, REF_0);

  1228. 

  1229.         vis_xor(REF_0, REF_2, TMP12);

  1230. 

  1231.         vis_and(TMP4, MASK_7f, TMP4);

  1232. 

  1233.         vis_and(TMP12, MASK_fe, TMP12);

  1234. 

  1235.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1236.         vis_or(REF_0, REF_2, TMP14);

  1237. 

  1238.         vis_psub16(TMP6, TMP4, DST_0);

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

  1240.         dest += stride;

  1241. 

  1242.         vis_and(TMP12, MASK_7f, TMP12);

  1243. 

  1244.         vis_psub16(TMP14, TMP12, DST_0);

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

  1246. }

  1247. 

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

  1249.                              const int stride, int height)

  1250. {

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

  1252.         int stride_8 = stride + 8;

  1253.         int stride_16 = stride + 16;

  1254. 

  1255.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1256. 

  1257.         ref = vis_alignaddr(ref);

  1258. 

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

  1260.         vis_fzero(ZERO);

  1261. 

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

  1263. 

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

  1265. 

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

  1267.         vis_faligndata(TMP0, TMP2, REF_2);

  1268. 

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

  1270.         vis_faligndata(TMP2, TMP4, REF_6);

  1271.         height >>= 1;

  1272. 

  1273.         do {    /* 31 cycles */

  1274.                 vis_ld64_2(ref, stride, TMP0);

  1275.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  1276.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  1277. 

  1278.                 vis_ld64_2(ref, stride_8, TMP2);

  1279.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  1280.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  1281. 

  1282.                 vis_ld64_2(ref, stride_16, TMP4);

  1283.                 ref += stride;

  1284. 

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

  1286.                 vis_faligndata(TMP0, TMP2, REF_0);

  1287. 

  1288.                 vis_ld64_2(dest, 8, DST_2);

  1289.                 vis_faligndata(TMP2, TMP4, REF_4);

  1290. 

  1291.                 vis_ld64_2(ref, stride, TMP6);

  1292.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  1293.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  1294. 

  1295.                 vis_ld64_2(ref, stride_8, TMP8);

  1296.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  1297. 

  1298.                 vis_ld64_2(ref, stride_16, TMP10);

  1299.                 ref += stride;

  1300. 

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

  1302.                 vis_faligndata(TMP6, TMP8, REF_2);

  1303.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1304. 

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

  1306.                 vis_faligndata(TMP8, TMP10, REF_6);

  1307.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  1308. 

  1309.                 vis_padd16(TMP0, CONST_3, TMP0);

  1310.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  1311. 

  1312.                 vis_padd16(TMP2, CONST_3, TMP2);

  1313.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1314. 

  1315.                 vis_padd16(TMP4, CONST_3, TMP4);

  1316.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1317. 

  1318.                 vis_padd16(TMP6, CONST_3, TMP6);

  1319. 

  1320.                 vis_padd16(TMP12, TMP20, TMP12);

  1321.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  1322. 

  1323.                 vis_padd16(TMP14, TMP22, TMP14);

  1324.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  1325. 

  1326.                 vis_padd16(TMP16, TMP24, TMP16);

  1327.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  1328. 

  1329.                 vis_padd16(TMP18, TMP26, TMP18);

  1330.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  1331. 

  1332.                 vis_padd16(TMP12, TMP0, TMP12);

  1333.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  1334. 

  1335.                 vis_padd16(TMP14, TMP2, TMP14);

  1336.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  1337. 

  1338.                 vis_padd16(TMP16, TMP4, TMP16);

  1339.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  1340. 

  1341.                 vis_padd16(TMP18, TMP6, TMP18);

  1342.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  1343. 

  1344.                 vis_pack16(TMP12, DST_0);

  1345.                 vis_padd16(TMP28, TMP0, TMP12);

  1346. 

  1347.                 vis_pack16(TMP14, DST_1);

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

  1349.                 vis_padd16(TMP30, TMP2, TMP14);

  1350. 

  1351.                 vis_pack16(TMP16, DST_2);

  1352.                 vis_padd16(REF_S4, TMP4, TMP16);

  1353. 

  1354.                 vis_pack16(TMP18, DST_3);

  1355.                 vis_st64_2(DST_2, dest, 8);

  1356.                 dest += stride;

  1357.                 vis_padd16(REF_S6, TMP6, TMP18);

  1358. 

  1359.                 vis_padd16(TMP12, TMP20, TMP12);

  1360. 

  1361.                 vis_padd16(TMP14, TMP22, TMP14);

  1362.                 vis_pack16(TMP12, DST_0);

  1363. 

  1364.                 vis_padd16(TMP16, TMP24, TMP16);

  1365.                 vis_pack16(TMP14, DST_1);

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

  1367. 

  1368.                 vis_padd16(TMP18, TMP26, TMP18);

  1369.                 vis_pack16(TMP16, DST_2);

  1370. 

  1371.                 vis_pack16(TMP18, DST_3);

  1372.                 vis_st64_2(DST_2, dest, 8);

  1373.                 dest += stride;

  1374.         } while (--height);

  1375. }

  1376. 

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

  1378.                             const int stride, int height)

  1379. {

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

  1381.         int stride_8 = stride + 8;

  1382. 

  1383.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1384. 

  1385.         ref = vis_alignaddr(ref);

  1386. 

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

  1388.         vis_fzero(ZERO);

  1389. 

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

  1391. 

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

  1393.         vis_faligndata(TMP0, TMP2, REF_2);

  1394. 

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

  1396. 

  1397.         height >>= 1;

  1398.         do {    /* 20 cycles */

  1399.                 vis_ld64_2(ref, stride, TMP0);

  1400.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  1401.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  1402. 

  1403.                 vis_ld64_2(ref, stride_8, TMP2);

  1404.                 ref += stride;

  1405. 

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

  1407. 

  1408.                 vis_ld64_2(dest, stride, DST_2);

  1409.                 vis_faligndata(TMP0, TMP2, REF_0);

  1410. 

  1411.                 vis_ld64_2(ref, stride, TMP4);

  1412.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  1413.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  1414. 

  1415.                 vis_ld64_2(ref, stride_8, TMP6);

  1416.                 ref += stride;

  1417.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  1418.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  1419. 

  1420.                 vis_padd16(TMP12, CONST_3, TMP12);

  1421.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1422. 

  1423.                 vis_padd16(TMP14, CONST_3, TMP14);

  1424.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1425. 

  1426.                 vis_faligndata(TMP4, TMP6, REF_2);

  1427. 

  1428.                 vis_padd16(TMP8, TMP12, TMP8);

  1429. 

  1430.                 vis_padd16(TMP10, TMP14, TMP10);

  1431.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  1432. 

  1433.                 vis_padd16(TMP8, TMP16, TMP0);

  1434.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  1435. 

  1436.                 vis_padd16(TMP10, TMP18, TMP2);

  1437.                 vis_pack16(TMP0, DST_0);

  1438. 

  1439.                 vis_pack16(TMP2, DST_1);

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

  1441.                 dest += stride;

  1442.                 vis_padd16(TMP12, TMP20, TMP12);

  1443. 

  1444.                 vis_padd16(TMP14, TMP22, TMP14);

  1445. 

  1446.                 vis_padd16(TMP12, TMP24, TMP0);

  1447. 

  1448.                 vis_padd16(TMP14, TMP26, TMP2);

  1449.                 vis_pack16(TMP0, DST_2);

  1450. 

  1451.                 vis_pack16(TMP2, DST_3);

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

  1453.                 dest += stride;

  1454.         } while (--height);

  1455. }

  1456. 

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

  1458.                               const int stride, int height)

  1459. {

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

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

  1462.         unsigned long off_plus_1 = off + 1;

  1463.         int stride_8 = stride + 8;

  1464.         int stride_16 = stride + 16;

  1465. 

  1466.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1467. 

  1468.         ref = vis_alignaddr(ref);

  1469. 

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

  1471.         vis_fzero(ZERO);

  1472. 

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

  1474. 

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

  1476. 

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

  1478.         vis_faligndata(TMP0, TMP2, REF_S0);

  1479. 

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

  1481.         vis_faligndata(TMP2, TMP4, REF_S4);

  1482. 

  1483.         if (off != 0x7) {

  1484.                 vis_alignaddr_g0((void *)off_plus_1);

  1485.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1486.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1487.         } else {

  1488.                 vis_src1(TMP2, REF_S2);

  1489.                 vis_src1(TMP4, REF_S6);

  1490.         }

  1491. 

  1492.         height >>= 1;

  1493.         do {

  1494.                 vis_ld64_2(ref, stride, TMP0);

  1495.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1496.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1497. 

  1498.                 vis_alignaddr_g0((void *)off);

  1499. 

  1500.                 vis_ld64_2(ref, stride_8, TMP2);

  1501.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1502.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1503. 

  1504.                 vis_ld64_2(ref, stride_16, TMP4);

  1505.                 ref += stride;

  1506.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1507.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1508. 

  1509.                 vis_ld64_2(ref, stride, TMP6);

  1510.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1511.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1512. 

  1513.                 vis_ld64_2(ref, stride_8, TMP8);

  1514.                 vis_faligndata(TMP0, TMP2, REF_0);

  1515. 

  1516.                 vis_ld64_2(ref, stride_16, TMP10);

  1517.                 ref += stride;

  1518.                 vis_faligndata(TMP2, TMP4, REF_4);

  1519. 

  1520.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1521. 

  1522.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1523. 

  1524.                 if (off != 0x7) {

  1525.                         vis_alignaddr_g0((void *)off_plus_1);

  1526.                         vis_faligndata(TMP0, TMP2, REF_2);

  1527.                         vis_faligndata(TMP2, TMP4, REF_6);

  1528.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1529.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1530.                 } else {

  1531.                         vis_src1(TMP2, REF_2);

  1532.                         vis_src1(TMP4, REF_6);

  1533.                         vis_src1(TMP8, REF_S2);

  1534.                         vis_src1(TMP10, REF_S6);

  1535.                 }

  1536. 

  1537.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  1538.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1539. 

  1540.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1541.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1542. 

  1543.                 vis_padd16(TMP0, CONST_2, TMP8);

  1544.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  1545. 

  1546.                 vis_padd16(TMP2, CONST_2, TMP10);

  1547.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  1548. 

  1549.                 vis_padd16(TMP8, TMP4, TMP8);

  1550.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  1551. 

  1552.                 vis_padd16(TMP10, TMP6, TMP10);

  1553.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  1554. 

  1555.                 vis_padd16(TMP12, TMP8, TMP12);

  1556. 

  1557.                 vis_padd16(TMP14, TMP10, TMP14);

  1558. 

  1559.                 vis_padd16(TMP12, TMP16, TMP12);

  1560. 

  1561.                 vis_padd16(TMP14, TMP18, TMP14);

  1562.                 vis_pack16(TMP12, DST_0);

  1563. 

  1564.                 vis_pack16(TMP14, DST_1);

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

  1566.                 vis_padd16(TMP0, CONST_2, TMP12);

  1567. 

  1568.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  1569.                 vis_padd16(TMP2, CONST_2, TMP14);

  1570. 

  1571.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  1572.                 vis_padd16(TMP12, TMP4, TMP12);

  1573. 

  1574.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  1575.                 vis_padd16(TMP14, TMP6, TMP14);

  1576. 

  1577.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  1578.                 vis_padd16(TMP20, TMP12, TMP20);

  1579. 

  1580.                 vis_padd16(TMP22, TMP14, TMP22);

  1581. 

  1582.                 vis_padd16(TMP20, TMP24, TMP20);

  1583. 

  1584.                 vis_padd16(TMP22, TMP26, TMP22);

  1585.                 vis_pack16(TMP20, DST_2);

  1586. 

  1587.                 vis_pack16(TMP22, DST_3);

  1588.                 vis_st64_2(DST_2, dest, 8);

  1589.                 dest += stride;

  1590.                 vis_padd16(TMP0, TMP4, TMP24);

  1591. 

  1592.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  1593.                 vis_padd16(TMP2, TMP6, TMP26);

  1594. 

  1595.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  1596.                 vis_padd16(TMP24, TMP8, TMP24);

  1597. 

  1598.                 vis_padd16(TMP26, TMP10, TMP26);

  1599.                 vis_pack16(TMP24, DST_0);

  1600. 

  1601.                 vis_pack16(TMP26, DST_1);

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

  1603.                 vis_pmerge(ZERO, REF_S6, TMP4);

  1604. 

  1605.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  1606. 

  1607.                 vis_padd16(TMP0, TMP4, TMP0);

  1608. 

  1609.                 vis_padd16(TMP2, TMP6, TMP2);

  1610. 

  1611.                 vis_padd16(TMP0, TMP12, TMP0);

  1612. 

  1613.                 vis_padd16(TMP2, TMP14, TMP2);

  1614.                 vis_pack16(TMP0, DST_2);

  1615. 

  1616.                 vis_pack16(TMP2, DST_3);

  1617.                 vis_st64_2(DST_2, dest, 8);

  1618.                 dest += stride;

  1619.         } while (--height);

  1620. }

  1621. 

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

  1623.                              const int stride, int height)

  1624. {

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

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

  1627.         unsigned long off_plus_1 = off + 1;

  1628.         int stride_8 = stride + 8;

  1629. 

  1630.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1631. 

  1632.         ref = vis_alignaddr(ref);

  1633. 

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

  1635.         vis_fzero(ZERO);

  1636. 

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

  1638. 

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

  1640. 

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

  1642.         vis_faligndata(TMP0, TMP2, REF_S0);

  1643. 

  1644.         if (off != 0x7) {

  1645.                 vis_alignaddr_g0((void *)off_plus_1);

  1646.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1647.         } else {

  1648.                 vis_src1(TMP2, REF_S2);

  1649.         }

  1650. 

  1651.         height >>= 1;

  1652.         do {    /* 26 cycles */

  1653.                 vis_ld64_2(ref, stride, TMP0);

  1654.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  1655.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  1656. 

  1657.                 vis_alignaddr_g0((void *)off);

  1658. 

  1659.                 vis_ld64_2(ref, stride_8, TMP2);

  1660.                 ref += stride;

  1661.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  1662.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  1663. 

  1664.                 vis_ld64_2(ref, stride, TMP4);

  1665. 

  1666.                 vis_ld64_2(ref, stride_8, TMP6);

  1667.                 ref += stride;

  1668.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1669. 

  1670.                 vis_pmerge(ZERO, REF_S4, TMP18);

  1671. 

  1672.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  1673. 

  1674.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1675. 

  1676.                 if (off != 0x7) {

  1677.                         vis_alignaddr_g0((void *)off_plus_1);

  1678.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1679.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1680.                 } else {

  1681.                         vis_src1(TMP2, REF_S6);

  1682.                         vis_src1(TMP6, REF_S2);

  1683.                 }

  1684. 

  1685.                 vis_padd16(TMP18, CONST_2, TMP18);

  1686.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  1687. 

  1688.                 vis_padd16(TMP20, CONST_2, TMP20);

  1689.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  1690. 

  1691.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  1692.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  1693. 

  1694.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  1695.                 vis_padd16(TMP18, TMP22, TMP18);

  1696. 

  1697.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  1698.                 vis_padd16(TMP20, TMP24, TMP20);

  1699. 

  1700.                 vis_padd16(TMP8,  TMP18, TMP8);

  1701. 

  1702.                 vis_padd16(TMP10, TMP20, TMP10);

  1703. 

  1704.                 vis_padd16(TMP8,  TMP12, TMP8);

  1705. 

  1706.                 vis_padd16(TMP10, TMP14, TMP10);

  1707.                 vis_pack16(TMP8,  DST_0);

  1708. 

  1709.                 vis_pack16(TMP10, DST_1);

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

  1711.                 dest += stride;

  1712.                 vis_padd16(TMP18, TMP26, TMP18);

  1713. 

  1714.                 vis_padd16(TMP20, TMP28, TMP20);

  1715. 

  1716.                 vis_padd16(TMP18, TMP30, TMP18);

  1717. 

  1718.                 vis_padd16(TMP20, TMP32, TMP20);

  1719.                 vis_pack16(TMP18, DST_2);

  1720. 

  1721.                 vis_pack16(TMP20, DST_3);

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

  1723.                 dest += stride;

  1724.         } while (--height);

  1725. }

  1726. 

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

  1728.                               const int stride, int height)

  1729. {

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

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

  1732.         unsigned long off_plus_1 = off + 1;

  1733.         int stride_8 = stride + 8;

  1734.         int stride_16 = stride + 16;

  1735. 

  1736.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1737. 

  1738.         ref = vis_alignaddr(ref);

  1739. 

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

  1741.         vis_fzero(ZERO);

  1742. 

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

  1744. 

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

  1746. 

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

  1748.         vis_faligndata(TMP0, TMP2, REF_S0);

  1749. 

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

  1751.         vis_faligndata(TMP2, TMP4, REF_S4);

  1752. 

  1753.         if (off != 0x7) {

  1754.                 vis_alignaddr_g0((void *)off_plus_1);

  1755.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1756.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1757.         } else {

  1758.                 vis_src1(TMP2, REF_S2);

  1759.                 vis_src1(TMP4, REF_S6);

  1760.         }

  1761. 

  1762.         height >>= 1;

  1763.         do {    /* 55 cycles */

  1764.                 vis_ld64_2(ref, stride, TMP0);

  1765.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1766.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1767. 

  1768.                 vis_alignaddr_g0((void *)off);

  1769. 

  1770.                 vis_ld64_2(ref, stride_8, TMP2);

  1771.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1772.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1773. 

  1774.                 vis_ld64_2(ref, stride_16, TMP4);

  1775.                 ref += stride;

  1776.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1777.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1778. 

  1779.                 vis_ld64_2(ref, stride, TMP6);

  1780.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1781.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1782. 

  1783.                 vis_ld64_2(ref, stride_8, TMP8);

  1784.                 vis_faligndata(TMP0, TMP2, REF_0);

  1785. 

  1786.                 vis_ld64_2(ref, stride_16, TMP10);

  1787.                 ref += stride;

  1788.                 vis_faligndata(TMP2, TMP4, REF_4);

  1789. 

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

  1791.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1792. 

  1793.                 vis_ld64_2(dest, 8, DST_2);

  1794.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1795. 

  1796.                 if (off != 0x7) {

  1797.                         vis_alignaddr_g0((void *)off_plus_1);

  1798.                         vis_faligndata(TMP0, TMP2, REF_2);

  1799.                         vis_faligndata(TMP2, TMP4, REF_6);

  1800.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1801.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1802.                 } else {

  1803.                         vis_src1(TMP2, REF_2);

  1804.                         vis_src1(TMP4, REF_6);

  1805.                         vis_src1(TMP8, REF_S2);

  1806.                         vis_src1(TMP10, REF_S6);

  1807.                 }

  1808. 

  1809.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1810.                 vis_pmerge(ZERO, REF_0, TMP0);

  1811. 

  1812.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1813.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1814. 

  1815.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1816.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1817. 

  1818.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1819.                 vis_padd16(TMP0, CONST_6, TMP0);

  1820. 

  1821.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1822.                 vis_padd16(TMP2, CONST_6, TMP2);

  1823. 

  1824.                 vis_padd16(TMP0, TMP4, TMP0);

  1825.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  1826. 

  1827.                 vis_padd16(TMP2, TMP6, TMP2);

  1828.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1829. 

  1830.                 vis_padd16(TMP12, TMP0, TMP12);

  1831.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  1832. 

  1833.                 vis_padd16(TMP14, TMP2, TMP14);

  1834.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  1835. 

  1836.                 vis_padd16(TMP12, TMP16, TMP12);

  1837.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  1838. 

  1839.                 vis_padd16(TMP14, TMP18, TMP14);

  1840.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  1841. 

  1842.                 vis_padd16(TMP12, TMP30, TMP12);

  1843. 

  1844.                 vis_padd16(TMP14, TMP32, TMP14);

  1845.                 vis_pack16(TMP12, DST_0);

  1846. 

  1847.                 vis_pack16(TMP14, DST_1);

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

  1849.                 vis_padd16(TMP4, CONST_6, TMP4);

  1850. 

  1851.                 vis_ld64_2(dest, stride, DST_0);

  1852.                 vis_padd16(TMP6, CONST_6, TMP6);

  1853.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1854. 

  1855.                 vis_padd16(TMP4, TMP8, TMP4);

  1856.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  1857. 

  1858.                 vis_padd16(TMP6, TMP10, TMP6);

  1859. 

  1860.                 vis_padd16(TMP20, TMP4, TMP20);

  1861. 

  1862.                 vis_padd16(TMP22, TMP6, TMP22);

  1863. 

  1864.                 vis_padd16(TMP20, TMP24, TMP20);

  1865. 

  1866.                 vis_padd16(TMP22, TMP26, TMP22);

  1867. 

  1868.                 vis_padd16(TMP20, REF_0, TMP20);

  1869.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  1870. 

  1871.                 vis_padd16(TMP22, REF_2, TMP22);

  1872.                 vis_pack16(TMP20, DST_2);

  1873. 

  1874.                 vis_pack16(TMP22, DST_3);

  1875.                 vis_st64_2(DST_2, dest, 8);

  1876.                 dest += stride;

  1877. 

  1878.                 vis_ld64_2(dest, 8, DST_2);

  1879.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1880.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  1881. 

  1882.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1883.                 vis_padd16(REF_4, TMP0, TMP8);

  1884. 

  1885.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  1886.                 vis_padd16(REF_6, TMP2, TMP10);

  1887. 

  1888.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  1889.                 vis_padd16(TMP8, TMP12, TMP8);

  1890. 

  1891.                 vis_padd16(TMP10, TMP14, TMP10);

  1892. 

  1893.                 vis_padd16(TMP8, TMP30, TMP8);

  1894. 

  1895.                 vis_padd16(TMP10, TMP32, TMP10);

  1896.                 vis_pack16(TMP8, DST_0);

  1897. 

  1898.                 vis_pack16(TMP10, DST_1);

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

  1900. 

  1901.                 vis_padd16(REF_0, TMP4, REF_0);

  1902. 

  1903.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  1904.                 vis_padd16(REF_2, TMP6, REF_2);

  1905. 

  1906.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  1907.                 vis_padd16(REF_0, REF_4, REF_0);

  1908. 

  1909.                 vis_padd16(REF_2, REF_6, REF_2);

  1910. 

  1911.                 vis_padd16(REF_0, TMP30, REF_0);

  1912. 

  1913.                 /* stall */

  1914. 

  1915.                 vis_padd16(REF_2, TMP32, REF_2);

  1916.                 vis_pack16(REF_0, DST_2);

  1917. 

  1918.                 vis_pack16(REF_2, DST_3);

  1919.                 vis_st64_2(DST_2, dest, 8);

  1920.                 dest += stride;

  1921.         } while (--height);

  1922. }

  1923. 

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

  1925.                              const int stride, int height)

  1926. {

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

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

  1929.         unsigned long off_plus_1 = off + 1;

  1930.         int stride_8 = stride + 8;

  1931. 

  1932.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1933. 

  1934.         ref = vis_alignaddr(ref);

  1935. 

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

  1937.         vis_fzero(ZERO);

  1938. 

  1939.         vis_ld64_2(ref, 8, TMP2);

  1940. 

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

  1942. 

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

  1944.         vis_faligndata(TMP0, TMP2, REF_S0);

  1945. 

  1946.         if (off != 0x7) {

  1947.                 vis_alignaddr_g0((void *)off_plus_1);

  1948.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1949.         } else {

  1950.                 vis_src1(TMP2, REF_S2);

  1951.         }

  1952. 

  1953.         height >>= 1;

  1954.         do {    /* 31 cycles */

  1955.                 vis_ld64_2(ref, stride, TMP0);

  1956.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  1957.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  1958. 

  1959.                 vis_ld64_2(ref, stride_8, TMP2);

  1960.                 ref += stride;

  1961.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1962.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  1963. 

  1964.                 vis_alignaddr_g0((void *)off);

  1965. 

  1966.                 vis_ld64_2(ref, stride, TMP4);

  1967.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1968. 

  1969.                 vis_ld64_2(ref, stride_8, TMP6);

  1970.                 ref += stride;

  1971. 

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

  1973.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1974. 

  1975.                 vis_ld64_2(dest, stride, DST_2);

  1976. 

  1977.                 if (off != 0x7) {

  1978.                         vis_alignaddr_g0((void *)off_plus_1);

  1979.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1980.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1981.                 } else {

  1982.                         vis_src1(TMP2, REF_S6);

  1983.                         vis_src1(TMP6, REF_S2);

  1984.                 }

  1985. 

  1986.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1987.                 vis_pmerge(ZERO, REF_S4, TMP22);

  1988. 

  1989.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1990.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  1991. 

  1992.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  1993.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  1994. 

  1995.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  1996.                 vis_padd16(TMP22, CONST_6, TMP22);

  1997. 

  1998.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  1999.                 vis_padd16(TMP24, CONST_6, TMP24);

  2000. 

  2001.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  2002.                 vis_padd16(TMP22, TMP26, TMP22);

  2003. 

  2004.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  2005.                 vis_padd16(TMP24, TMP28, TMP24);

  2006. 

  2007.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  2008.                 vis_padd16(TMP8, TMP22, TMP8);

  2009. 

  2010.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  2011.                 vis_padd16(TMP10, TMP24, TMP10);

  2012. 

  2013.                 vis_padd16(TMP8, TMP12, TMP8);

  2014. 

  2015.                 vis_padd16(TMP10, TMP14, TMP10);

  2016. 

  2017.                 vis_padd16(TMP8, TMP30, TMP8);

  2018. 

  2019.                 vis_padd16(TMP10, TMP32, TMP10);

  2020.                 vis_pack16(TMP8, DST_0);

  2021. 

  2022.                 vis_pack16(TMP10, DST_1);

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

  2024.                 dest += stride;

  2025. 

  2026.                 vis_padd16(REF_S4, TMP22, TMP12);

  2027. 

  2028.                 vis_padd16(REF_S6, TMP24, TMP14);

  2029. 

  2030.                 vis_padd16(TMP12, TMP26, TMP12);

  2031. 

  2032.                 vis_padd16(TMP14, TMP28, TMP14);

  2033. 

  2034.                 vis_padd16(TMP12, REF_0, TMP12);

  2035. 

  2036.                 vis_padd16(TMP14, REF_2, TMP14);

  2037.                 vis_pack16(TMP12, DST_2);

  2038. 

  2039.                 vis_pack16(TMP14, DST_3);

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

  2041.                 dest += stride;

  2042.         } while (--height);

  2043. }

  2044. 

  2045. /* End of rounding code */

  2046. 

  2047. /* Start of no rounding code */

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

  2049.  * motion comp code, which is:

  2050.  *

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

  2052.  *

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

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

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

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

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

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

  2059.  *

  2060.  *      fxor            f0,   f2, f10

  2061.  *      fand            f10,  f4, f10

  2062.  *      fmul8x16        f8,  f10, f10

  2063.  *      fand            f10,  f6, f10

  2064.  *      fand            f0,   f2, f12

  2065.  *      fpadd16         f12, f10, f10

  2066.  */

  2067. 

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

  2069.                                       const int stride, int height)

  2070. {

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

  2072. 

  2073.         ref = vis_alignaddr(ref);

  2074.         do {    /* 5 cycles */

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

  2076. 

  2077.                 vis_ld64_2(ref, 8, TMP2);

  2078. 

  2079.                 vis_ld64_2(ref, 16, TMP4);

  2080.                 ref += stride;

  2081. 

  2082.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2084. 

  2085.                 vis_faligndata(TMP2, TMP4, REF_2);

  2086.                 vis_st64_2(REF_2, dest, 8);

  2087.                 dest += stride;

  2088.         } while (--height);

  2089. }

  2090. 

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

  2092.                             const int stride, int height)

  2093. {

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

  2095. 

  2096.         ref = vis_alignaddr(ref);

  2097.         do {    /* 4 cycles */

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

  2099. 

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

  2101.                 ref += stride;

  2102. 

  2103.                 /* stall */

  2104. 

  2105.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2107.                 dest += stride;

  2108.         } while (--height);

  2109. }

  2110. 

  2111. 

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

  2113.                              const int stride, int height)

  2114. {

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

  2116.         int stride_8 = stride + 8;

  2117. 

  2118.         ref = vis_alignaddr(ref);

  2119. 

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

  2121. 

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

  2123. 

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

  2125. 

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

  2127. 

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

  2129. 

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

  2131.         vis_faligndata(TMP0, TMP2, REF_0);

  2132. 

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

  2134.         vis_faligndata(TMP2, TMP4, REF_2);

  2135. 

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

  2137. 

  2138.         ref += stride;

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

  2140. 

  2141.         do {    /* 24 cycles */

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

  2143.                 vis_xor(DST_0, REF_0, TMP6);

  2144. 

  2145.                 vis_ld64_2(ref, 8, TMP2);

  2146.                 vis_and(TMP6, MASK_fe, TMP6);

  2147. 

  2148.                 vis_ld64_2(ref, 16, TMP4);

  2149.                 ref += stride;

  2150.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2151.                 vis_xor(DST_2, REF_2, TMP8);

  2152. 

  2153.                 vis_and(TMP8, MASK_fe, TMP8);

  2154. 

  2155.                 vis_and(DST_0, REF_0, TMP10);

  2156.                 vis_ld64_2(dest, stride, DST_0);

  2157.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2158. 

  2159.                 vis_and(DST_2, REF_2, TMP12);

  2160.                 vis_ld64_2(dest, stride_8, DST_2);

  2161. 

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

  2163.                 vis_and(TMP6, MASK_7f, TMP6);

  2164. 

  2165.                 vis_and(TMP8, MASK_7f, TMP8);

  2166. 

  2167.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2169. 

  2170.                 vis_padd16(TMP12, TMP8, TMP8);

  2171.                 vis_st64_2(TMP8, dest, 8);

  2172. 

  2173.                 dest += stride;

  2174.                 vis_ld64_2(ref, 8, TMP16);

  2175.                 vis_faligndata(TMP0, TMP2, REF_0);

  2176. 

  2177.                 vis_ld64_2(ref, 16, TMP18);

  2178.                 vis_faligndata(TMP2, TMP4, REF_2);

  2179.                 ref += stride;

  2180. 

  2181.                 vis_xor(DST_0, REF_0, TMP20);

  2182. 

  2183.                 vis_and(TMP20, MASK_fe, TMP20);

  2184. 

  2185.                 vis_xor(DST_2, REF_2, TMP22);

  2186.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  2187. 

  2188.                 vis_and(TMP22, MASK_fe, TMP22);

  2189. 

  2190.                 vis_and(DST_0, REF_0, TMP24);

  2191.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  2192. 

  2193.                 vis_and(DST_2, REF_2, TMP26);

  2194. 

  2195.                 vis_ld64_2(dest, stride, DST_0);

  2196.                 vis_faligndata(TMP14, TMP16, REF_0);

  2197. 

  2198.                 vis_ld64_2(dest, stride_8, DST_2);

  2199.                 vis_faligndata(TMP16, TMP18, REF_2);

  2200. 

  2201.                 vis_and(TMP20, MASK_7f, TMP20);

  2202. 

  2203.                 vis_and(TMP22, MASK_7f, TMP22);

  2204. 

  2205.                 vis_padd16(TMP24, TMP20, TMP20);

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

  2207. 

  2208.                 vis_padd16(TMP26, TMP22, TMP22);

  2209.                 vis_st64_2(TMP22, dest, 8);

  2210.                 dest += stride;

  2211.         } while (--height);

  2212. 

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

  2214.         vis_xor(DST_0, REF_0, TMP6);

  2215. 

  2216.         vis_ld64_2(ref, 8, TMP2);

  2217.         vis_and(TMP6, MASK_fe, TMP6);

  2218. 

  2219.         vis_ld64_2(ref, 16, TMP4);

  2220.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2221.         vis_xor(DST_2, REF_2, TMP8);

  2222. 

  2223.         vis_and(TMP8, MASK_fe, TMP8);

  2224. 

  2225.         vis_and(DST_0, REF_0, TMP10);

  2226.         vis_ld64_2(dest, stride, DST_0);

  2227.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2228. 

  2229.         vis_and(DST_2, REF_2, TMP12);

  2230.         vis_ld64_2(dest, stride_8, DST_2);

  2231. 

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

  2233.         vis_and(TMP6, MASK_7f, TMP6);

  2234. 

  2235.         vis_and(TMP8, MASK_7f, TMP8);

  2236. 

  2237.         vis_padd16(TMP10, TMP6, TMP6);

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

  2239. 

  2240.         vis_padd16(TMP12, TMP8, TMP8);

  2241.         vis_st64_2(TMP8, dest, 8);

  2242. 

  2243.         dest += stride;

  2244.         vis_faligndata(TMP0, TMP2, REF_0);

  2245. 

  2246.         vis_faligndata(TMP2, TMP4, REF_2);

  2247. 

  2248.         vis_xor(DST_0, REF_0, TMP20);

  2249. 

  2250.         vis_and(TMP20, MASK_fe, TMP20);

  2251. 

  2252.         vis_xor(DST_2, REF_2, TMP22);

  2253.         vis_mul8x16(CONST_128, TMP20, TMP20);

  2254. 

  2255.         vis_and(TMP22, MASK_fe, TMP22);

  2256. 

  2257.         vis_and(DST_0, REF_0, TMP24);

  2258.         vis_mul8x16(CONST_128, TMP22, TMP22);

  2259. 

  2260.         vis_and(DST_2, REF_2, TMP26);

  2261. 

  2262.         vis_and(TMP20, MASK_7f, TMP20);

  2263. 

  2264.         vis_and(TMP22, MASK_7f, TMP22);

  2265. 

  2266.         vis_padd16(TMP24, TMP20, TMP20);

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

  2268. 

  2269.         vis_padd16(TMP26, TMP22, TMP22);

  2270.         vis_st64_2(TMP22, dest, 8);

  2271. }

  2272. 

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

  2274.                             const int stride, int height)

  2275. {

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

  2277. 

  2278.         ref = vis_alignaddr(ref);

  2279. 

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

  2281. 

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

  2283. 

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

  2285. 

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

  2287. 

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

  2289.         vis_faligndata(TMP0, TMP2, REF_0);

  2290. 

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

  2292. 

  2293.         ref += stride;

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

  2295. 

  2296.         do {    /* 12 cycles */

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

  2298.                 vis_xor(DST_0, REF_0, TMP4);

  2299. 

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

  2301.                 vis_and(TMP4, MASK_fe, TMP4);

  2302. 

  2303.                 vis_and(DST_0, REF_0, TMP6);

  2304.                 vis_ld64_2(dest, stride, DST_0);

  2305.                 ref += stride;

  2306.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2307. 

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

  2309.                 vis_faligndata(TMP0, TMP2, REF_0);

  2310. 

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

  2312.                 vis_xor(DST_0, REF_0, TMP0);

  2313.                 ref += stride;

  2314. 

  2315.                 vis_and(TMP0, MASK_fe, TMP0);

  2316. 

  2317.                 vis_and(TMP4, MASK_7f, TMP4);

  2318. 

  2319.                 vis_padd16(TMP6, TMP4, TMP4);

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

  2321.                 dest += stride;

  2322.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  2323. 

  2324.                 vis_and(DST_0, REF_0, TMP6);

  2325.                 vis_ld64_2(dest, stride, DST_0);

  2326. 

  2327.                 vis_faligndata(TMP12, TMP2, REF_0);

  2328. 

  2329.                 vis_and(TMP0, MASK_7f, TMP0);

  2330. 

  2331.                 vis_padd16(TMP6, TMP0, TMP4);

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

  2333.                 dest += stride;

  2334.         } while (--height);

  2335. 

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

  2337.         vis_xor(DST_0, REF_0, TMP4);

  2338. 

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

  2340.         vis_and(TMP4, MASK_fe, TMP4);

  2341. 

  2342.         vis_and(DST_0, REF_0, TMP6);

  2343.         vis_ld64_2(dest, stride, DST_0);

  2344.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2345. 

  2346.         vis_faligndata(TMP0, TMP2, REF_0);

  2347. 

  2348.         vis_xor(DST_0, REF_0, TMP0);

  2349. 

  2350.         vis_and(TMP0, MASK_fe, TMP0);

  2351. 

  2352.         vis_and(TMP4, MASK_7f, TMP4);

  2353. 

  2354.         vis_padd16(TMP6, TMP4, TMP4);

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

  2356.         dest += stride;

  2357.         vis_mul8x16(CONST_128, TMP0, TMP0);

  2358. 

  2359.         vis_and(DST_0, REF_0, TMP6);

  2360. 

  2361.         vis_and(TMP0, MASK_7f, TMP0);

  2362. 

  2363.         vis_padd16(TMP6, TMP0, TMP4);

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

  2365. }

  2366. 

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

  2368.                              const int stride, int height)

  2369. {

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

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

  2372.         unsigned long off_plus_1 = off + 1;

  2373. 

  2374.         ref = vis_alignaddr(ref);

  2375. 

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

  2377. 

  2378.         vis_ld64_2(ref, 8,  TMP2);

  2379. 

  2380.         vis_ld64_2(ref, 16, TMP4);

  2381. 

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

  2383. 

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

  2385.         vis_faligndata(TMP0, TMP2, REF_0);

  2386. 

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

  2388.         vis_faligndata(TMP2, TMP4, REF_4);

  2389. 

  2390.         if (off != 0x7) {

  2391.                 vis_alignaddr_g0((void *)off_plus_1);

  2392.                 vis_faligndata(TMP0, TMP2, REF_2);

  2393.                 vis_faligndata(TMP2, TMP4, REF_6);

  2394.         } else {

  2395.                 vis_src1(TMP2, REF_2);

  2396.                 vis_src1(TMP4, REF_6);

  2397.         }

  2398. 

  2399.         ref += stride;

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

  2401. 

  2402.         do {    /* 34 cycles */

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

  2404.                 vis_xor(REF_0, REF_2, TMP6);

  2405. 

  2406.                 vis_ld64_2(ref, 8,  TMP2);

  2407.                 vis_xor(REF_4, REF_6, TMP8);

  2408. 

  2409.                 vis_ld64_2(ref, 16, TMP4);

  2410.                 vis_and(TMP6, MASK_fe, TMP6);

  2411.                 ref += stride;

  2412. 

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

  2414.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2415.                 vis_and(TMP8, MASK_fe, TMP8);

  2416. 

  2417.                 vis_ld64_2(ref, 8,  TMP16);

  2418.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2419.                 vis_and(REF_0, REF_2, TMP10);

  2420. 

  2421.                 vis_ld64_2(ref, 16, TMP18);

  2422.                 ref += stride;

  2423.                 vis_and(REF_4, REF_6, TMP12);

  2424. 

  2425.                 vis_alignaddr_g0((void *)off);

  2426. 

  2427.                 vis_faligndata(TMP0, TMP2, REF_0);

  2428. 

  2429.                 vis_faligndata(TMP2, TMP4, REF_4);

  2430. 

  2431.                 if (off != 0x7) {

  2432.                         vis_alignaddr_g0((void *)off_plus_1);

  2433.                         vis_faligndata(TMP0, TMP2, REF_2);

  2434.                         vis_faligndata(TMP2, TMP4, REF_6);

  2435.                 } else {

  2436.                         vis_src1(TMP2, REF_2);

  2437.                         vis_src1(TMP4, REF_6);

  2438.                 }

  2439. 

  2440.                 vis_and(TMP6, MASK_7f, TMP6);

  2441. 

  2442.                 vis_and(TMP8, MASK_7f, TMP8);

  2443. 

  2444.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2446. 

  2447.                 vis_padd16(TMP12, TMP8, TMP8);

  2448.                 vis_st64_2(TMP8, dest, 8);

  2449.                 dest += stride;

  2450. 

  2451.                 vis_xor(REF_0, REF_2, TMP6);

  2452. 

  2453.                 vis_xor(REF_4, REF_6, TMP8);

  2454. 

  2455.                 vis_and(TMP6, MASK_fe, TMP6);

  2456. 

  2457.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2458.                 vis_and(TMP8, MASK_fe, TMP8);

  2459. 

  2460.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2461.                 vis_and(REF_0, REF_2, TMP10);

  2462. 

  2463.                 vis_and(REF_4, REF_6, TMP12);

  2464. 

  2465.                 vis_alignaddr_g0((void *)off);

  2466. 

  2467.                 vis_faligndata(TMP14, TMP16, REF_0);

  2468. 

  2469.                 vis_faligndata(TMP16, TMP18, REF_4);

  2470. 

  2471.                 if (off != 0x7) {

  2472.                         vis_alignaddr_g0((void *)off_plus_1);

  2473.                         vis_faligndata(TMP14, TMP16, REF_2);

  2474.                         vis_faligndata(TMP16, TMP18, REF_6);

  2475.                 } else {

  2476.                         vis_src1(TMP16, REF_2);

  2477.                         vis_src1(TMP18, REF_6);

  2478.                 }

  2479. 

  2480.                 vis_and(TMP6, MASK_7f, TMP6);

  2481. 

  2482.                 vis_and(TMP8, MASK_7f, TMP8);

  2483. 

  2484.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2486. 

  2487.                 vis_padd16(TMP12, TMP8, TMP8);

  2488.                 vis_st64_2(TMP8, dest, 8);

  2489.                 dest += stride;

  2490.         } while (--height);

  2491. 

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

  2493.         vis_xor(REF_0, REF_2, TMP6);

  2494. 

  2495.         vis_ld64_2(ref, 8,  TMP2);

  2496.         vis_xor(REF_4, REF_6, TMP8);

  2497. 

  2498.         vis_ld64_2(ref, 16, TMP4);

  2499.         vis_and(TMP6, MASK_fe, TMP6);

  2500. 

  2501.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2502.         vis_and(TMP8, MASK_fe, TMP8);

  2503. 

  2504.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2505.         vis_and(REF_0, REF_2, TMP10);

  2506. 

  2507.         vis_and(REF_4, REF_6, TMP12);

  2508. 

  2509.         vis_alignaddr_g0((void *)off);

  2510. 

  2511.         vis_faligndata(TMP0, TMP2, REF_0);

  2512. 

  2513.         vis_faligndata(TMP2, TMP4, REF_4);

  2514. 

  2515.         if (off != 0x7) {

  2516.                 vis_alignaddr_g0((void *)off_plus_1);

  2517.                 vis_faligndata(TMP0, TMP2, REF_2);

  2518.                 vis_faligndata(TMP2, TMP4, REF_6);

  2519.         } else {

  2520.                 vis_src1(TMP2, REF_2);

  2521.                 vis_src1(TMP4, REF_6);

  2522.         }

  2523. 

  2524.         vis_and(TMP6, MASK_7f, TMP6);

  2525. 

  2526.         vis_and(TMP8, MASK_7f, TMP8);

  2527. 

  2528.         vis_padd16(TMP10, TMP6, TMP6);

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

  2530. 

  2531.         vis_padd16(TMP12, TMP8, TMP8);

  2532.         vis_st64_2(TMP8, dest, 8);

  2533.         dest += stride;

  2534. 

  2535.         vis_xor(REF_0, REF_2, TMP6);

  2536. 

  2537.         vis_xor(REF_4, REF_6, TMP8);

  2538. 

  2539.         vis_and(TMP6, MASK_fe, TMP6);

  2540. 

  2541.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2542.         vis_and(TMP8, MASK_fe, TMP8);

  2543. 

  2544.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2545.         vis_and(REF_0, REF_2, TMP10);

  2546. 

  2547.         vis_and(REF_4, REF_6, TMP12);

  2548. 

  2549.         vis_and(TMP6, MASK_7f, TMP6);

  2550. 

  2551.         vis_and(TMP8, MASK_7f, TMP8);

  2552. 

  2553.         vis_padd16(TMP10, TMP6, TMP6);

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

  2555. 

  2556.         vis_padd16(TMP12, TMP8, TMP8);

  2557.         vis_st64_2(TMP8, dest, 8);

  2558. }

  2559. 

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

  2561.                             const int stride, int height)

  2562. {

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

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

  2565.         unsigned long off_plus_1 = off + 1;

  2566. 

  2567.         ref = vis_alignaddr(ref);

  2568. 

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

  2570. 

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

  2572. 

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

  2574. 

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

  2576. 

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

  2578.         vis_faligndata(TMP0, TMP2, REF_0);

  2579. 

  2580.         if (off != 0x7) {

  2581.                 vis_alignaddr_g0((void *)off_plus_1);

  2582.                 vis_faligndata(TMP0, TMP2, REF_2);

  2583.         } else {

  2584.                 vis_src1(TMP2, REF_2);

  2585.         }

  2586. 

  2587.         ref += stride;

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

  2589. 

  2590.         do {    /* 20 cycles */

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

  2592.                 vis_xor(REF_0, REF_2, TMP4);

  2593. 

  2594.                 vis_ld64_2(ref, 8, TMP2);

  2595.                 vis_and(TMP4, MASK_fe, TMP4);

  2596.                 ref += stride;

  2597. 

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

  2599.                 vis_and(REF_0, REF_2, TMP6);

  2600.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2601. 

  2602.                 vis_alignaddr_g0((void *)off);

  2603. 

  2604.                 vis_ld64_2(ref, 8, TMP10);

  2605.                 ref += stride;

  2606.                 vis_faligndata(TMP0, TMP2, REF_0);

  2607. 

  2608.                 if (off != 0x7) {

  2609.                         vis_alignaddr_g0((void *)off_plus_1);

  2610.                         vis_faligndata(TMP0, TMP2, REF_2);

  2611.                 } else {

  2612.                         vis_src1(TMP2, REF_2);

  2613.                 }

  2614. 

  2615.                 vis_and(TMP4, MASK_7f, TMP4);

  2616. 

  2617.                 vis_padd16(TMP6, TMP4, DST_0);

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

  2619.                 dest += stride;

  2620. 

  2621.                 vis_xor(REF_0, REF_2, TMP12);

  2622. 

  2623.                 vis_and(TMP12, MASK_fe, TMP12);

  2624. 

  2625.                 vis_and(REF_0, REF_2, TMP14);

  2626.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2627. 

  2628.                 vis_alignaddr_g0((void *)off);

  2629.                 vis_faligndata(TMP8, TMP10, REF_0);

  2630.                 if (off != 0x7) {

  2631.                         vis_alignaddr_g0((void *)off_plus_1);

  2632.                         vis_faligndata(TMP8, TMP10, REF_2);

  2633.                 } else {

  2634.                         vis_src1(TMP10, REF_2);

  2635.                 }

  2636. 

  2637.                 vis_and(TMP12, MASK_7f, TMP12);

  2638. 

  2639.                 vis_padd16(TMP14, TMP12, DST_0);

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

  2641.                 dest += stride;

  2642.         } while (--height);

  2643. 

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

  2645.         vis_xor(REF_0, REF_2, TMP4);

  2646. 

  2647.         vis_ld64_2(ref, 8, TMP2);

  2648.         vis_and(TMP4, MASK_fe, TMP4);

  2649. 

  2650.         vis_and(REF_0, REF_2, TMP6);

  2651.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2652. 

  2653.         vis_alignaddr_g0((void *)off);

  2654. 

  2655.         vis_faligndata(TMP0, TMP2, REF_0);

  2656. 

  2657.         if (off != 0x7) {

  2658.                 vis_alignaddr_g0((void *)off_plus_1);

  2659.                 vis_faligndata(TMP0, TMP2, REF_2);

  2660.         } else {

  2661.                 vis_src1(TMP2, REF_2);

  2662.         }

  2663. 

  2664.         vis_and(TMP4, MASK_7f, TMP4);

  2665. 

  2666.         vis_padd16(TMP6, TMP4, DST_0);

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

  2668.         dest += stride;

  2669. 

  2670.         vis_xor(REF_0, REF_2, TMP12);

  2671. 

  2672.         vis_and(TMP12, MASK_fe, TMP12);

  2673. 

  2674.         vis_and(REF_0, REF_2, TMP14);

  2675.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2676. 

  2677.         vis_and(TMP12, MASK_7f, TMP12);

  2678. 

  2679.         vis_padd16(TMP14, TMP12, DST_0);

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

  2681.         dest += stride;

  2682. }

  2683. 

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

  2685.                              const int stride, int height)

  2686. {

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

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

  2689.         unsigned long off_plus_1 = off + 1;

  2690. 

  2691.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2692. 

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

  2694.         vis_fzero(ZERO);

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

  2696. 

  2697.         ref = vis_alignaddr(ref);

  2698.         do {    /* 26 cycles */

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

  2700. 

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

  2702. 

  2703.                 vis_alignaddr_g0((void *)off);

  2704. 

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

  2706. 

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

  2708.                 vis_faligndata(TMP0, TMP2, REF_0);

  2709. 

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

  2711.                 vis_faligndata(TMP2, TMP4, REF_4);

  2712. 

  2713.                 if (off != 0x7) {

  2714.                         vis_alignaddr_g0((void *)off_plus_1);

  2715.                         vis_faligndata(TMP0, TMP2, REF_2);

  2716.                         vis_faligndata(TMP2, TMP4, REF_6);

  2717.                 } else {

  2718.                         vis_src1(TMP2, REF_2);

  2719.                         vis_src1(TMP4, REF_6);

  2720.                 }

  2721. 

  2722.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  2723. 

  2724.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2725.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2726. 

  2727.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  2728. 

  2729.                 vis_padd16(TMP0, TMP4, TMP0);

  2730. 

  2731.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  2732.                 vis_padd16(TMP2, TMP6, TMP2);

  2733. 

  2734.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  2735. 

  2736.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  2737. 

  2738.                 vis_padd16(TMP0, TMP4, TMP0);

  2739.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2740. 

  2741.                 vis_padd16(TMP2, TMP6, TMP2);

  2742.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  2743. 

  2744.                 vis_padd16(TMP0, CONST_3, TMP8);

  2745.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  2746. 

  2747.                 vis_padd16(TMP2, CONST_3, TMP10);

  2748.                 vis_pack16(TMP8, DST_0);

  2749. 

  2750.                 vis_pack16(TMP10, DST_1);

  2751.                 vis_padd16(TMP16, TMP12, TMP0);

  2752. 

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

  2754.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  2755.                 vis_padd16(TMP18, TMP14, TMP2);

  2756. 

  2757.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  2758.                 vis_padd16(TMP0, CONST_3, TMP0);

  2759. 

  2760.                 vis_padd16(TMP2, CONST_3, TMP2);

  2761. 

  2762.                 vis_padd16(TMP0, TMP4, TMP0);

  2763. 

  2764.                 vis_padd16(TMP2, TMP6, TMP2);

  2765.                 vis_pack16(TMP0, DST_2);

  2766. 

  2767.                 vis_pack16(TMP2, DST_3);

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

  2769. 

  2770.                 ref += stride;

  2771.                 dest += stride;

  2772.         } while (--height);

  2773. }

  2774. 

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

  2776.                             const int stride, int height)

  2777. {

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

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

  2780.         unsigned long off_plus_1 = off + 1;

  2781.         int stride_times_2 = stride << 1;

  2782. 

  2783.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2784. 

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

  2786.         vis_fzero(ZERO);

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

  2788. 

  2789.         ref = vis_alignaddr(ref);

  2790.         height >>= 2;

  2791.         do {    /* 47 cycles */

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

  2793. 

  2794.                 vis_ld64_2(ref, 8, TMP2);

  2795.                 ref += stride;

  2796. 

  2797.                 vis_alignaddr_g0((void *)off);

  2798. 

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

  2800.                 vis_faligndata(TMP0, TMP2, REF_0);

  2801. 

  2802.                 vis_ld64_2(ref, 8, TMP6);

  2803.                 ref += stride;

  2804. 

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

  2806. 

  2807.                 vis_ld64_2(ref, 8, TMP10);

  2808.                 ref += stride;

  2809.                 vis_faligndata(TMP4, TMP6, REF_4);

  2810. 

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

  2812. 

  2813.                 vis_ld64_2(ref, 8, TMP14);

  2814.                 ref += stride;

  2815.                 vis_faligndata(TMP8, TMP10, REF_S0);

  2816. 

  2817.                 vis_faligndata(TMP12, TMP14, REF_S4);

  2818. 

  2819.                 if (off != 0x7) {

  2820.                         vis_alignaddr_g0((void *)off_plus_1);

  2821. 

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

  2823.                         vis_faligndata(TMP0, TMP2, REF_2);

  2824. 

  2825.                         vis_ld64_2(dest, stride, DST_2);

  2826.                         vis_faligndata(TMP4, TMP6, REF_6);

  2827. 

  2828.                         vis_faligndata(TMP8, TMP10, REF_S2);

  2829. 

  2830.                         vis_faligndata(TMP12, TMP14, REF_S6);

  2831.                 } else {

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

  2833.                         vis_src1(TMP2, REF_2);

  2834. 

  2835.                         vis_ld64_2(dest, stride, DST_2);

  2836.                         vis_src1(TMP6, REF_6);

  2837. 

  2838.                         vis_src1(TMP10, REF_S2);

  2839. 

  2840.                         vis_src1(TMP14, REF_S6);

  2841.                 }

  2842. 

  2843.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  2844.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2845. 

  2846.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2847.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  2848. 

  2849.                 vis_padd16(TMP0, CONST_3, TMP0);

  2850.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  2851. 

  2852.                 vis_padd16(TMP2, CONST_3, TMP2);

  2853.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  2854. 

  2855.                 vis_padd16(TMP0, TMP4, TMP0);

  2856.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  2857. 

  2858.                 vis_padd16(TMP2, TMP6, TMP2);

  2859.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  2860. 

  2861.                 vis_padd16(TMP0, TMP16, TMP0);

  2862.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  2863. 

  2864.                 vis_padd16(TMP2, TMP18, TMP2);

  2865.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2866. 

  2867.                 vis_padd16(TMP8, CONST_3, TMP8);

  2868.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  2869. 

  2870.                 vis_padd16(TMP8, TMP12, TMP8);

  2871.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  2872. 

  2873.                 vis_padd16(TMP10, TMP14, TMP10);

  2874.                 vis_pack16(TMP0, DST_0);

  2875. 

  2876.                 vis_pack16(TMP2, DST_1);

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

  2878.                 dest += stride;

  2879.                 vis_padd16(TMP10, CONST_3, TMP10);

  2880. 

  2881.                 vis_ld64_2(dest, stride, DST_0);

  2882.                 vis_padd16(TMP8, TMP16, TMP8);

  2883. 

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

  2885.                 vis_padd16(TMP10, TMP18, TMP10);

  2886.                 vis_pack16(TMP8, DST_2);

  2887. 

  2888.                 vis_pack16(TMP10, DST_3);

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

  2890.                 dest += stride;

  2891. 

  2892.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  2893.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  2894. 

  2895.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  2896.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  2897. 

  2898.                 vis_padd16(TMP0, CONST_3, TMP0);

  2899.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  2900. 

  2901.                 vis_padd16(TMP2, CONST_3, TMP2);

  2902.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  2903. 

  2904.                 vis_padd16(TMP0, TMP24, TMP0);

  2905.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  2906. 

  2907.                 vis_padd16(TMP2, TMP6, TMP2);

  2908.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  2909. 

  2910.                 vis_padd16(TMP8, CONST_3, TMP8);

  2911.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  2912. 

  2913.                 vis_padd16(TMP10, CONST_3, TMP10);

  2914.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  2915. 

  2916.                 vis_padd16(TMP8, TMP12, TMP8);

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

  2918. 

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

  2920.                 vis_padd16(TMP0, TMP16, TMP0);

  2921. 

  2922.                 vis_padd16(TMP2, TMP18, TMP2);

  2923.                 vis_pack16(TMP0, DST_0);

  2924. 

  2925.                 vis_padd16(TMP10, TMP14, TMP10);

  2926.                 vis_pack16(TMP2, DST_1);

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

  2928.                 dest += stride;

  2929. 

  2930.                 vis_padd16(TMP8, TMP20, TMP8);

  2931. 

  2932.                 vis_padd16(TMP10, TMP22, TMP10);

  2933.                 vis_pack16(TMP8, DST_2);

  2934. 

  2935.                 vis_pack16(TMP10, DST_3);

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

  2937.                 dest += stride;

  2938.         } while (--height);

  2939. }

  2940. 

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

  2942.                              const int stride, int height)

  2943. {

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

  2945. 

  2946.         ref = vis_alignaddr(ref);

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

  2948. 

  2949.         vis_ld64_2(ref, 8, TMP2);

  2950. 

  2951.         vis_ld64_2(ref, 16, TMP4);

  2952.         ref += stride;

  2953. 

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

  2955.         vis_faligndata(TMP0, TMP2, REF_0);

  2956. 

  2957.         vis_ld64_2(ref, 8, TMP8);

  2958.         vis_faligndata(TMP2, TMP4, REF_4);

  2959. 

  2960.         vis_ld64_2(ref, 16, TMP10);

  2961.         ref += stride;

  2962. 

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

  2964.         vis_faligndata(TMP6, TMP8, REF_2);

  2965. 

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

  2967.         vis_faligndata(TMP8, TMP10, REF_6);

  2968. 

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

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

  2971.         do {    /* 24 cycles */

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

  2973.                 vis_xor(REF_0, REF_2, TMP12);

  2974. 

  2975.                 vis_ld64_2(ref, 8, TMP2);

  2976.                 vis_xor(REF_4, REF_6, TMP16);

  2977. 

  2978.                 vis_ld64_2(ref, 16, TMP4);

  2979.                 ref += stride;

  2980.                 vis_and(REF_0, REF_2, TMP14);

  2981. 

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

  2983.                 vis_and(REF_4, REF_6, TMP18);

  2984. 

  2985.                 vis_ld64_2(ref, 8, TMP8);

  2986.                 vis_faligndata(TMP0, TMP2, REF_0);

  2987. 

  2988.                 vis_ld64_2(ref, 16, TMP10);

  2989.                 ref += stride;

  2990.                 vis_faligndata(TMP2, TMP4, REF_4);

  2991. 

  2992.                 vis_and(TMP12, MASK_fe, TMP12);

  2993. 

  2994.                 vis_and(TMP16, MASK_fe, TMP16);

  2995.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2996. 

  2997.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  2998.                 vis_xor(REF_0, REF_2, TMP0);

  2999. 

  3000.                 vis_xor(REF_4, REF_6, TMP2);

  3001. 

  3002.                 vis_and(REF_0, REF_2, TMP20);

  3003. 

  3004.                 vis_and(TMP12, MASK_7f, TMP12);

  3005. 

  3006.                 vis_and(TMP16, MASK_7f, TMP16);

  3007. 

  3008.                 vis_padd16(TMP14, TMP12, TMP12);

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

  3010. 

  3011.                 vis_padd16(TMP18, TMP16, TMP16);

  3012.                 vis_st64_2(TMP16, dest, 8);

  3013.                 dest += stride;

  3014. 

  3015.                 vis_and(REF_4, REF_6, TMP18);

  3016. 

  3017.                 vis_and(TMP0, MASK_fe, TMP0);

  3018. 

  3019.                 vis_and(TMP2, MASK_fe, TMP2);

  3020.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  3021. 

  3022.                 vis_faligndata(TMP6, TMP8, REF_2);

  3023.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  3024. 

  3025.                 vis_faligndata(TMP8, TMP10, REF_6);

  3026. 

  3027.                 vis_and(TMP0, MASK_7f, TMP0);

  3028. 

  3029.                 vis_and(TMP2, MASK_7f, TMP2);

  3030. 

  3031.                 vis_padd16(TMP20, TMP0, TMP0);

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

  3033. 

  3034.                 vis_padd16(TMP18, TMP2, TMP2);

  3035.                 vis_st64_2(TMP2, dest, 8);

  3036.                 dest += stride;

  3037.         } while (--height);

  3038. 

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

  3040.         vis_xor(REF_0, REF_2, TMP12);

  3041. 

  3042.         vis_ld64_2(ref, 8, TMP2);

  3043.         vis_xor(REF_4, REF_6, TMP16);

  3044. 

  3045.         vis_ld64_2(ref, 16, TMP4);

  3046.         vis_and(REF_0, REF_2, TMP14);

  3047. 

  3048.         vis_and(REF_4, REF_6, TMP18);

  3049. 

  3050.         vis_faligndata(TMP0, TMP2, REF_0);

  3051. 

  3052.         vis_faligndata(TMP2, TMP4, REF_4);

  3053. 

  3054.         vis_and(TMP12, MASK_fe, TMP12);

  3055. 

  3056.         vis_and(TMP16, MASK_fe, TMP16);

  3057.         vis_mul8x16(CONST_128, TMP12, TMP12);

  3058. 

  3059.         vis_mul8x16(CONST_128, TMP16, TMP16);

  3060.         vis_xor(REF_0, REF_2, TMP0);

  3061. 

  3062.         vis_xor(REF_4, REF_6, TMP2);

  3063. 

  3064.         vis_and(REF_0, REF_2, TMP20);

  3065. 

  3066.         vis_and(TMP12, MASK_7f, TMP12);

  3067. 

  3068.         vis_and(TMP16, MASK_7f, TMP16);

  3069. 

  3070.         vis_padd16(TMP14, TMP12, TMP12);

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

  3072. 

  3073.         vis_padd16(TMP18, TMP16, TMP16);

  3074.         vis_st64_2(TMP16, dest, 8);

  3075.         dest += stride;

  3076. 

  3077.         vis_and(REF_4, REF_6, TMP18);

  3078. 

  3079.         vis_and(TMP0, MASK_fe, TMP0);

  3080. 

  3081.         vis_and(TMP2, MASK_fe, TMP2);

  3082.         vis_mul8x16(CONST_128, TMP0, TMP0);

  3083. 

  3084.         vis_mul8x16(CONST_128, TMP2, TMP2);

  3085. 

  3086.         vis_and(TMP0, MASK_7f, TMP0);

  3087. 

  3088.         vis_and(TMP2, MASK_7f, TMP2);

  3089. 

  3090.         vis_padd16(TMP20, TMP0, TMP0);

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

  3092. 

  3093.         vis_padd16(TMP18, TMP2, TMP2);

  3094.         vis_st64_2(TMP2, dest, 8);

  3095. }

  3096. 

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

  3098.                             const int stride, int height)

  3099. {

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

  3101. 

  3102.         ref = vis_alignaddr(ref);

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

  3104. 

  3105.         vis_ld64_2(ref, 8, TMP2);

  3106.         ref += stride;

  3107. 

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

  3109. 

  3110.         vis_ld64_2(ref, 8, TMP6);

  3111.         ref += stride;

  3112. 

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

  3114.         vis_faligndata(TMP0, TMP2, REF_0);

  3115. 

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

  3117.         vis_faligndata(TMP4, TMP6, REF_2);

  3118. 

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

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

  3121.         do {    /* 12 cycles */

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

  3123.                 vis_xor(REF_0, REF_2, TMP4);

  3124. 

  3125.                 vis_ld64_2(ref, 8, TMP2);

  3126.                 ref += stride;

  3127.                 vis_and(TMP4, MASK_fe, TMP4);

  3128. 

  3129.                 vis_and(REF_0, REF_2, TMP6);

  3130.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  3131. 

  3132.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  3134. 

  3135.                 vis_ld64_2(ref, 8, TMP2);

  3136.                 ref += stride;

  3137.                 vis_xor(REF_0, REF_2, TMP12);

  3138. 

  3139.                 vis_and(TMP4, MASK_7f, TMP4);

  3140. 

  3141.                 vis_and(TMP12, MASK_fe, TMP12);

  3142. 

  3143.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  3144.                 vis_and(REF_0, REF_2, TMP14);

  3145. 

  3146.                 vis_padd16(TMP6, TMP4, DST_0);

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

  3148.                 dest += stride;

  3149. 

  3150.                 vis_faligndata(TMP0, TMP2, REF_2);

  3151. 

  3152.                 vis_and(TMP12, MASK_7f, TMP12);

  3153. 

  3154.                 vis_padd16(TMP14, TMP12, DST_0);

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

  3156.                 dest += stride;

  3157.         } while (--height);

  3158. 

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

  3160.         vis_xor(REF_0, REF_2, TMP4);

  3161. 

  3162.         vis_ld64_2(ref, 8, TMP2);

  3163.         vis_and(TMP4, MASK_fe, TMP4);

  3164. 

  3165.         vis_and(REF_0, REF_2, TMP6);

  3166.         vis_mul8x16(CONST_128, TMP4, TMP4);

  3167. 

  3168.         vis_faligndata(TMP0, TMP2, REF_0);

  3169. 

  3170.         vis_xor(REF_0, REF_2, TMP12);

  3171. 

  3172.         vis_and(TMP4, MASK_7f, TMP4);

  3173. 

  3174.         vis_and(TMP12, MASK_fe, TMP12);

  3175. 

  3176.         vis_mul8x16(CONST_128, TMP12, TMP12);

  3177.         vis_and(REF_0, REF_2, TMP14);

  3178. 

  3179.         vis_padd16(TMP6, TMP4, DST_0);

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

  3181.         dest += stride;

  3182. 

  3183.         vis_and(TMP12, MASK_7f, TMP12);

  3184. 

  3185.         vis_padd16(TMP14, TMP12, DST_0);

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

  3187. }

  3188. 

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

  3190.                              const int stride, int height)

  3191. {

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

  3193.         int stride_8 = stride + 8;

  3194.         int stride_16 = stride + 16;

  3195. 

  3196.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3197. 

  3198.         ref = vis_alignaddr(ref);

  3199. 

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

  3201.         vis_fzero(ZERO);

  3202. 

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

  3204. 

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

  3206. 

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

  3208.         vis_faligndata(TMP0, TMP2, REF_2);

  3209. 

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

  3211.         vis_faligndata(TMP2, TMP4, REF_6);

  3212.         height >>= 1;

  3213. 

  3214.         do {    /* 31 cycles */

  3215.                 vis_ld64_2(ref, stride, TMP0);

  3216.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  3217.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  3218. 

  3219.                 vis_ld64_2(ref, stride_8, TMP2);

  3220.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  3221.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  3222. 

  3223.                 vis_ld64_2(ref, stride_16, TMP4);

  3224.                 ref += stride;

  3225. 

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

  3227.                 vis_faligndata(TMP0, TMP2, REF_0);

  3228. 

  3229.                 vis_ld64_2(dest, 8, DST_2);

  3230.                 vis_faligndata(TMP2, TMP4, REF_4);

  3231. 

  3232.                 vis_ld64_2(ref, stride, TMP6);

  3233.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  3234.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  3235. 

  3236.                 vis_ld64_2(ref, stride_8, TMP8);

  3237.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  3238. 

  3239.                 vis_ld64_2(ref, stride_16, TMP10);

  3240.                 ref += stride;

  3241. 

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

  3243.                 vis_faligndata(TMP6, TMP8, REF_2);

  3244.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3245. 

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

  3247.                 vis_faligndata(TMP8, TMP10, REF_6);

  3248.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  3249. 

  3250.                 vis_padd16(TMP0, CONST_3, TMP0);

  3251.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  3252. 

  3253.                 vis_padd16(TMP2, CONST_3, TMP2);

  3254.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  3255. 

  3256.                 vis_padd16(TMP4, CONST_3, TMP4);

  3257.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  3258. 

  3259.                 vis_padd16(TMP6, CONST_3, TMP6);

  3260. 

  3261.                 vis_padd16(TMP12, TMP20, TMP12);

  3262.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  3263. 

  3264.                 vis_padd16(TMP14, TMP22, TMP14);

  3265.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  3266. 

  3267.                 vis_padd16(TMP16, TMP24, TMP16);

  3268.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  3269. 

  3270.                 vis_padd16(TMP18, TMP26, TMP18);

  3271.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  3272. 

  3273.                 vis_padd16(TMP12, TMP0, TMP12);

  3274.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  3275. 

  3276.                 vis_padd16(TMP14, TMP2, TMP14);

  3277.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  3278. 

  3279.                 vis_padd16(TMP16, TMP4, TMP16);

  3280.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  3281. 

  3282.                 vis_padd16(TMP18, TMP6, TMP18);

  3283.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  3284. 

  3285.                 vis_pack16(TMP12, DST_0);

  3286.                 vis_padd16(TMP28, TMP0, TMP12);

  3287. 

  3288.                 vis_pack16(TMP14, DST_1);

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

  3290.                 vis_padd16(TMP30, TMP2, TMP14);

  3291. 

  3292.                 vis_pack16(TMP16, DST_2);

  3293.                 vis_padd16(REF_S4, TMP4, TMP16);

  3294. 

  3295.                 vis_pack16(TMP18, DST_3);

  3296.                 vis_st64_2(DST_2, dest, 8);

  3297.                 dest += stride;

  3298.                 vis_padd16(REF_S6, TMP6, TMP18);

  3299. 

  3300.                 vis_padd16(TMP12, TMP20, TMP12);

  3301. 

  3302.                 vis_padd16(TMP14, TMP22, TMP14);

  3303.                 vis_pack16(TMP12, DST_0);

  3304. 

  3305.                 vis_padd16(TMP16, TMP24, TMP16);

  3306.                 vis_pack16(TMP14, DST_1);

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

  3308. 

  3309.                 vis_padd16(TMP18, TMP26, TMP18);

  3310.                 vis_pack16(TMP16, DST_2);

  3311. 

  3312.                 vis_pack16(TMP18, DST_3);

  3313.                 vis_st64_2(DST_2, dest, 8);

  3314.                 dest += stride;

  3315.         } while (--height);

  3316. }

  3317. 

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

  3319.                             const int stride, int height)

  3320. {

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

  3322.         int stride_8 = stride + 8;

  3323. 

  3324.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3325. 

  3326.         ref = vis_alignaddr(ref);

  3327. 

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

  3329.         vis_fzero(ZERO);

  3330. 

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

  3332. 

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

  3334.         vis_faligndata(TMP0, TMP2, REF_2);

  3335. 

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

  3337. 

  3338.         height >>= 1;

  3339.         do {    /* 20 cycles */

  3340.                 vis_ld64_2(ref, stride, TMP0);

  3341.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  3342.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  3343. 

  3344.                 vis_ld64_2(ref, stride_8, TMP2);

  3345.                 ref += stride;

  3346. 

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

  3348. 

  3349.                 vis_ld64_2(dest, stride, DST_2);

  3350.                 vis_faligndata(TMP0, TMP2, REF_0);

  3351. 

  3352.                 vis_ld64_2(ref, stride, TMP4);

  3353.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  3354.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  3355. 

  3356.                 vis_ld64_2(ref, stride_8, TMP6);

  3357.                 ref += stride;

  3358.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  3359.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  3360. 

  3361.                 vis_padd16(TMP12, CONST_3, TMP12);

  3362.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  3363. 

  3364.                 vis_padd16(TMP14, CONST_3, TMP14);

  3365.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  3366. 

  3367.                 vis_faligndata(TMP4, TMP6, REF_2);

  3368. 

  3369.                 vis_padd16(TMP8, TMP12, TMP8);

  3370. 

  3371.                 vis_padd16(TMP10, TMP14, TMP10);

  3372.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  3373. 

  3374.                 vis_padd16(TMP8, TMP16, TMP0);

  3375.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  3376. 

  3377.                 vis_padd16(TMP10, TMP18, TMP2);

  3378.                 vis_pack16(TMP0, DST_0);

  3379. 

  3380.                 vis_pack16(TMP2, DST_1);

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

  3382.                 dest += stride;

  3383.                 vis_padd16(TMP12, TMP20, TMP12);

  3384. 

  3385.                 vis_padd16(TMP14, TMP22, TMP14);

  3386. 

  3387.                 vis_padd16(TMP12, TMP24, TMP0);

  3388. 

  3389.                 vis_padd16(TMP14, TMP26, TMP2);

  3390.                 vis_pack16(TMP0, DST_2);

  3391. 

  3392.                 vis_pack16(TMP2, DST_3);

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

  3394.                 dest += stride;

  3395.         } while (--height);

  3396. }

  3397. 

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

  3399.                                        const int stride, int height)

  3400. {

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

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

  3403.         unsigned long off_plus_1 = off + 1;

  3404.         int stride_8 = stride + 8;

  3405.         int stride_16 = stride + 16;

  3406. 

  3407.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3408. 

  3409.         ref = vis_alignaddr(ref);

  3410. 

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

  3412.         vis_fzero(ZERO);

  3413. 

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

  3415. 

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

  3417. 

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

  3419.         vis_faligndata(TMP0, TMP2, REF_S0);

  3420. 

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

  3422.         vis_faligndata(TMP2, TMP4, REF_S4);

  3423. 

  3424.         if (off != 0x7) {

  3425.                 vis_alignaddr_g0((void *)off_plus_1);

  3426.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3427.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3428.         } else {

  3429.                 vis_src1(TMP2, REF_S2);

  3430.                 vis_src1(TMP4, REF_S6);

  3431.         }

  3432. 

  3433.         height >>= 1;

  3434.         do {

  3435.                 vis_ld64_2(ref, stride, TMP0);

  3436.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3437.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3438. 

  3439.                 vis_alignaddr_g0((void *)off);

  3440. 

  3441.                 vis_ld64_2(ref, stride_8, TMP2);

  3442.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3443.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3444. 

  3445.                 vis_ld64_2(ref, stride_16, TMP4);

  3446.                 ref += stride;

  3447.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3448.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3449. 

  3450.                 vis_ld64_2(ref, stride, TMP6);

  3451.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3452.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3453. 

  3454.                 vis_ld64_2(ref, stride_8, TMP8);

  3455.                 vis_faligndata(TMP0, TMP2, REF_0);

  3456. 

  3457.                 vis_ld64_2(ref, stride_16, TMP10);

  3458.                 ref += stride;

  3459.                 vis_faligndata(TMP2, TMP4, REF_4);

  3460. 

  3461.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3462. 

  3463.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3464. 

  3465.                 if (off != 0x7) {

  3466.                         vis_alignaddr_g0((void *)off_plus_1);

  3467.                         vis_faligndata(TMP0, TMP2, REF_2);

  3468.                         vis_faligndata(TMP2, TMP4, REF_6);

  3469.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3470.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3471.                 } else {

  3472.                         vis_src1(TMP2, REF_2);

  3473.                         vis_src1(TMP4, REF_6);

  3474.                         vis_src1(TMP8, REF_S2);

  3475.                         vis_src1(TMP10, REF_S6);

  3476.                 }

  3477. 

  3478.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  3479.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3480. 

  3481.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3482.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3483. 

  3484.                 vis_padd16(TMP0, CONST_2, TMP8);

  3485.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  3486. 

  3487.                 vis_padd16(TMP2, CONST_1, TMP10);

  3488.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  3489. 

  3490.                 vis_padd16(TMP8, TMP4, TMP8);

  3491.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  3492. 

  3493.                 vis_padd16(TMP10, TMP6, TMP10);

  3494.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  3495. 

  3496.                 vis_padd16(TMP12, TMP8, TMP12);

  3497. 

  3498.                 vis_padd16(TMP14, TMP10, TMP14);

  3499. 

  3500.                 vis_padd16(TMP12, TMP16, TMP12);

  3501. 

  3502.                 vis_padd16(TMP14, TMP18, TMP14);

  3503.                 vis_pack16(TMP12, DST_0);

  3504. 

  3505.                 vis_pack16(TMP14, DST_1);

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

  3507.                 vis_padd16(TMP0, CONST_1, TMP12);

  3508. 

  3509.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  3510.                 vis_padd16(TMP2, CONST_1, TMP14);

  3511. 

  3512.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  3513.                 vis_padd16(TMP12, TMP4, TMP12);

  3514. 

  3515.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  3516.                 vis_padd16(TMP14, TMP6, TMP14);

  3517. 

  3518.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  3519.                 vis_padd16(TMP20, TMP12, TMP20);

  3520. 

  3521.                 vis_padd16(TMP22, TMP14, TMP22);

  3522. 

  3523.                 vis_padd16(TMP20, TMP24, TMP20);

  3524. 

  3525.                 vis_padd16(TMP22, TMP26, TMP22);

  3526.                 vis_pack16(TMP20, DST_2);

  3527. 

  3528.                 vis_pack16(TMP22, DST_3);

  3529.                 vis_st64_2(DST_2, dest, 8);

  3530.                 dest += stride;

  3531.                 vis_padd16(TMP0, TMP4, TMP24);

  3532. 

  3533.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  3534.                 vis_padd16(TMP2, TMP6, TMP26);

  3535. 

  3536.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  3537.                 vis_padd16(TMP24, TMP8, TMP24);

  3538. 

  3539.                 vis_padd16(TMP26, TMP10, TMP26);

  3540.                 vis_pack16(TMP24, DST_0);

  3541. 

  3542.                 vis_pack16(TMP26, DST_1);

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

  3544.                 vis_pmerge(ZERO, REF_S6, TMP4);

  3545. 

  3546.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  3547. 

  3548.                 vis_padd16(TMP0, TMP4, TMP0);

  3549. 

  3550.                 vis_padd16(TMP2, TMP6, TMP2);

  3551. 

  3552.                 vis_padd16(TMP0, TMP12, TMP0);

  3553. 

  3554.                 vis_padd16(TMP2, TMP14, TMP2);

  3555.                 vis_pack16(TMP0, DST_2);

  3556. 

  3557.                 vis_pack16(TMP2, DST_3);

  3558.                 vis_st64_2(DST_2, dest, 8);

  3559.                 dest += stride;

  3560.         } while (--height);

  3561. }

  3562. 

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

  3564.                                       const int stride, int height)

  3565. {

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

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

  3568.         unsigned long off_plus_1 = off + 1;

  3569.         int stride_8 = stride + 8;

  3570. 

  3571.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3572. 

  3573.         ref = vis_alignaddr(ref);

  3574. 

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

  3576.         vis_fzero(ZERO);

  3577. 

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

  3579. 

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

  3581. 

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

  3583.         vis_faligndata(TMP0, TMP2, REF_S0);

  3584. 

  3585.         if (off != 0x7) {

  3586.                 vis_alignaddr_g0((void *)off_plus_1);

  3587.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3588.         } else {

  3589.                 vis_src1(TMP2, REF_S2);

  3590.         }

  3591. 

  3592.         height >>= 1;

  3593.         do {    /* 26 cycles */

  3594.                 vis_ld64_2(ref, stride, TMP0);

  3595.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  3596.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  3597. 

  3598.                 vis_alignaddr_g0((void *)off);

  3599. 

  3600.                 vis_ld64_2(ref, stride_8, TMP2);

  3601.                 ref += stride;

  3602.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  3603.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  3604. 

  3605.                 vis_ld64_2(ref, stride, TMP4);

  3606. 

  3607.                 vis_ld64_2(ref, stride_8, TMP6);

  3608.                 ref += stride;

  3609.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3610. 

  3611.                 vis_pmerge(ZERO, REF_S4, TMP18);

  3612. 

  3613.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  3614. 

  3615.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3616. 

  3617.                 if (off != 0x7) {

  3618.                         vis_alignaddr_g0((void *)off_plus_1);

  3619.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3620.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3621.                 } else {

  3622.                         vis_src1(TMP2, REF_S6);

  3623.                         vis_src1(TMP6, REF_S2);

  3624.                 }

  3625. 

  3626.                 vis_padd16(TMP18, CONST_1, TMP18);

  3627.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  3628. 

  3629.                 vis_padd16(TMP20, CONST_1, TMP20);

  3630.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  3631. 

  3632.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  3633.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  3634. 

  3635.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  3636.                 vis_padd16(TMP18, TMP22, TMP18);

  3637. 

  3638.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  3639.                 vis_padd16(TMP20, TMP24, TMP20);

  3640. 

  3641.                 vis_padd16(TMP8,  TMP18, TMP8);

  3642. 

  3643.                 vis_padd16(TMP10, TMP20, TMP10);

  3644. 

  3645.                 vis_padd16(TMP8,  TMP12, TMP8);

  3646. 

  3647.                 vis_padd16(TMP10, TMP14, TMP10);

  3648.                 vis_pack16(TMP8,  DST_0);

  3649. 

  3650.                 vis_pack16(TMP10, DST_1);

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

  3652.                 dest += stride;

  3653.                 vis_padd16(TMP18, TMP26, TMP18);

  3654. 

  3655.                 vis_padd16(TMP20, TMP28, TMP20);

  3656. 

  3657.                 vis_padd16(TMP18, TMP30, TMP18);

  3658. 

  3659.                 vis_padd16(TMP20, TMP32, TMP20);

  3660.                 vis_pack16(TMP18, DST_2);

  3661. 

  3662.                 vis_pack16(TMP20, DST_3);

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

  3664.                 dest += stride;

  3665.         } while (--height);

  3666. }

  3667. 

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

  3669.                                        const int stride, int height)

  3670. {

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

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

  3673.         unsigned long off_plus_1 = off + 1;

  3674.         int stride_8 = stride + 8;

  3675.         int stride_16 = stride + 16;

  3676. 

  3677.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3678. 

  3679.         ref = vis_alignaddr(ref);

  3680. 

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

  3682.         vis_fzero(ZERO);

  3683. 

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

  3685. 

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

  3687. 

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

  3689.         vis_faligndata(TMP0, TMP2, REF_S0);

  3690. 

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

  3692.         vis_faligndata(TMP2, TMP4, REF_S4);

  3693. 

  3694.         if (off != 0x7) {

  3695.                 vis_alignaddr_g0((void *)off_plus_1);

  3696.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3697.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3698.         } else {

  3699.                 vis_src1(TMP2, REF_S2);

  3700.                 vis_src1(TMP4, REF_S6);

  3701.         }

  3702. 

  3703.         height >>= 1;

  3704.         do {    /* 55 cycles */

  3705.                 vis_ld64_2(ref, stride, TMP0);

  3706.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3707.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3708. 

  3709.                 vis_alignaddr_g0((void *)off);

  3710. 

  3711.                 vis_ld64_2(ref, stride_8, TMP2);

  3712.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3713.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3714. 

  3715.                 vis_ld64_2(ref, stride_16, TMP4);

  3716.                 ref += stride;

  3717.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3718.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3719. 

  3720.                 vis_ld64_2(ref, stride, TMP6);

  3721.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3722.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3723. 

  3724.                 vis_ld64_2(ref, stride_8, TMP8);

  3725.                 vis_faligndata(TMP0, TMP2, REF_0);

  3726. 

  3727.                 vis_ld64_2(ref, stride_16, TMP10);

  3728.                 ref += stride;

  3729.                 vis_faligndata(TMP2, TMP4, REF_4);

  3730. 

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

  3732.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3733. 

  3734.                 vis_ld64_2(dest, 8, DST_2);

  3735.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3736. 

  3737.                 if (off != 0x7) {

  3738.                         vis_alignaddr_g0((void *)off_plus_1);

  3739.                         vis_faligndata(TMP0, TMP2, REF_2);

  3740.                         vis_faligndata(TMP2, TMP4, REF_6);

  3741.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3742.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3743.                 } else {

  3744.                         vis_src1(TMP2, REF_2);

  3745.                         vis_src1(TMP4, REF_6);

  3746.                         vis_src1(TMP8, REF_S2);

  3747.                         vis_src1(TMP10, REF_S6);

  3748.                 }

  3749. 

  3750.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3751.                 vis_pmerge(ZERO, REF_0, TMP0);

  3752. 

  3753.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3754.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3755. 

  3756.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3757.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3758. 

  3759.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3760.                 vis_padd16(TMP0, CONST_6, TMP0);

  3761. 

  3762.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3763.                 vis_padd16(TMP2, CONST_6, TMP2);

  3764. 

  3765.                 vis_padd16(TMP0, TMP4, TMP0);

  3766.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  3767. 

  3768.                 vis_padd16(TMP2, TMP6, TMP2);

  3769.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3770. 

  3771.                 vis_padd16(TMP12, TMP0, TMP12);

  3772.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  3773. 

  3774.                 vis_padd16(TMP14, TMP2, TMP14);

  3775.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  3776. 

  3777.                 vis_padd16(TMP12, TMP16, TMP12);

  3778.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  3779. 

  3780.                 vis_padd16(TMP14, TMP18, TMP14);

  3781.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  3782. 

  3783.                 vis_padd16(TMP12, TMP30, TMP12);

  3784. 

  3785.                 vis_padd16(TMP14, TMP32, TMP14);

  3786.                 vis_pack16(TMP12, DST_0);

  3787. 

  3788.                 vis_pack16(TMP14, DST_1);

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

  3790.                 vis_padd16(TMP4, CONST_6, TMP4);

  3791. 

  3792.                 vis_ld64_2(dest, stride, DST_0);

  3793.                 vis_padd16(TMP6, CONST_6, TMP6);

  3794.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3795. 

  3796.                 vis_padd16(TMP4, TMP8, TMP4);

  3797.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  3798. 

  3799.                 vis_padd16(TMP6, TMP10, TMP6);

  3800. 

  3801.                 vis_padd16(TMP20, TMP4, TMP20);

  3802. 

  3803.                 vis_padd16(TMP22, TMP6, TMP22);

  3804. 

  3805.                 vis_padd16(TMP20, TMP24, TMP20);

  3806. 

  3807.                 vis_padd16(TMP22, TMP26, TMP22);

  3808. 

  3809.                 vis_padd16(TMP20, REF_0, TMP20);

  3810.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  3811. 

  3812.                 vis_padd16(TMP22, REF_2, TMP22);

  3813.                 vis_pack16(TMP20, DST_2);

  3814. 

  3815.                 vis_pack16(TMP22, DST_3);

  3816.                 vis_st64_2(DST_2, dest, 8);

  3817.                 dest += stride;

  3818. 

  3819.                 vis_ld64_2(dest, 8, DST_2);

  3820.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3821.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  3822. 

  3823.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3824.                 vis_padd16(REF_4, TMP0, TMP8);

  3825. 

  3826.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  3827.                 vis_padd16(REF_6, TMP2, TMP10);

  3828. 

  3829.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  3830.                 vis_padd16(TMP8, TMP12, TMP8);

  3831. 

  3832.                 vis_padd16(TMP10, TMP14, TMP10);

  3833. 

  3834.                 vis_padd16(TMP8, TMP30, TMP8);

  3835. 

  3836.                 vis_padd16(TMP10, TMP32, TMP10);

  3837.                 vis_pack16(TMP8, DST_0);

  3838. 

  3839.                 vis_pack16(TMP10, DST_1);

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

  3841. 

  3842.                 vis_padd16(REF_0, TMP4, REF_0);

  3843. 

  3844.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  3845.                 vis_padd16(REF_2, TMP6, REF_2);

  3846. 

  3847.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  3848.                 vis_padd16(REF_0, REF_4, REF_0);

  3849. 

  3850.                 vis_padd16(REF_2, REF_6, REF_2);

  3851. 

  3852.                 vis_padd16(REF_0, TMP30, REF_0);

  3853. 

  3854.                 /* stall */

  3855. 

  3856.                 vis_padd16(REF_2, TMP32, REF_2);

  3857.                 vis_pack16(REF_0, DST_2);

  3858. 

  3859.                 vis_pack16(REF_2, DST_3);

  3860.                 vis_st64_2(DST_2, dest, 8);

  3861.                 dest += stride;

  3862.         } while (--height);

  3863. }

  3864. 

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

  3866.                                       const int stride, int height)

  3867. {

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

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

  3870.         unsigned long off_plus_1 = off + 1;

  3871.         int stride_8 = stride + 8;

  3872. 

  3873.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3874. 

  3875.         ref = vis_alignaddr(ref);

  3876. 

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

  3878.         vis_fzero(ZERO);

  3879. 

  3880.         vis_ld64_2(ref, 8, TMP2);

  3881. 

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

  3883. 

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

  3885.         vis_faligndata(TMP0, TMP2, REF_S0);

  3886. 

  3887.         if (off != 0x7) {

  3888.                 vis_alignaddr_g0((void *)off_plus_1);

  3889.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3890.         } else {

  3891.                 vis_src1(TMP2, REF_S2);

  3892.         }

  3893. 

  3894.         height >>= 1;

  3895.         do {    /* 31 cycles */

  3896.                 vis_ld64_2(ref, stride, TMP0);

  3897.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  3898.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  3899. 

  3900.                 vis_ld64_2(ref, stride_8, TMP2);

  3901.                 ref += stride;

  3902.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3903.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  3904. 

  3905.                 vis_alignaddr_g0((void *)off);

  3906. 

  3907.                 vis_ld64_2(ref, stride, TMP4);

  3908.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3909. 

  3910.                 vis_ld64_2(ref, stride_8, TMP6);

  3911.                 ref += stride;

  3912. 

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

  3914.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3915. 

  3916.                 vis_ld64_2(dest, stride, DST_2);

  3917. 

  3918.                 if (off != 0x7) {

  3919.                         vis_alignaddr_g0((void *)off_plus_1);

  3920.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3921.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3922.                 } else {

  3923.                         vis_src1(TMP2, REF_S6);

  3924.                         vis_src1(TMP6, REF_S2);

  3925.                 }

  3926. 

  3927.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3928.                 vis_pmerge(ZERO, REF_S4, TMP22);

  3929. 

  3930.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3931.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  3932. 

  3933.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  3934.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  3935. 

  3936.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  3937.                 vis_padd16(TMP22, CONST_6, TMP22);

  3938. 

  3939.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  3940.                 vis_padd16(TMP24, CONST_6, TMP24);

  3941. 

  3942.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3943.                 vis_padd16(TMP22, TMP26, TMP22);

  3944. 

  3945.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3946.                 vis_padd16(TMP24, TMP28, TMP24);

  3947. 

  3948.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  3949.                 vis_padd16(TMP8, TMP22, TMP8);

  3950. 

  3951.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  3952.                 vis_padd16(TMP10, TMP24, TMP10);

  3953. 

  3954.                 vis_padd16(TMP8, TMP12, TMP8);

  3955. 

  3956.                 vis_padd16(TMP10, TMP14, TMP10);

  3957. 

  3958.                 vis_padd16(TMP8, TMP30, TMP8);

  3959. 

  3960.                 vis_padd16(TMP10, TMP32, TMP10);

  3961.                 vis_pack16(TMP8, DST_0);

  3962. 

  3963.                 vis_pack16(TMP10, DST_1);

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

  3965.                 dest += stride;

  3966. 

  3967.                 vis_padd16(REF_S4, TMP22, TMP12);

  3968. 

  3969.                 vis_padd16(REF_S6, TMP24, TMP14);

  3970. 

  3971.                 vis_padd16(TMP12, TMP26, TMP12);

  3972. 

  3973.                 vis_padd16(TMP14, TMP28, TMP14);

  3974. 

  3975.                 vis_padd16(TMP12, REF_0, TMP12);

  3976. 

  3977.                 vis_padd16(TMP14, REF_2, TMP14);

  3978.                 vis_pack16(TMP12, DST_2);

  3979. 

  3980.                 vis_pack16(TMP14, DST_3);

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

  3982.                 dest += stride;

  3983.         } while (--height);

  3984. }

  3985. 

  3986. /* End of no rounding code */

  3987. 

  3988. #define ACCEL_SPARC_VIS 1

  3989. #define ACCEL_SPARC_VIS2 2

  3990. 

  3991. static int vis_level ()

  3992. {

  3993.     int accel = 0;

  3994.     accel |= ACCEL_SPARC_VIS;

  3995.     accel |= ACCEL_SPARC_VIS2;

  3996.     return accel;

  3997. }

  3998. 

  3999. /* libavcodec initialization code */

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

  4001. {

  4002.   /* VIS-specific optimizations */

  4003.   int accel = vis_level ();

  4004. 

  4005.   if (accel & ACCEL_SPARC_VIS) {

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

  4007.           c->idct_put = ff_simple_idct_put_vis;

  4008.           c->idct_add = ff_simple_idct_add_vis;

  4009.           c->idct     = ff_simple_idct_vis;

  4010.           c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;

  4011.       }

  4012. 

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

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

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

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

  4017. 

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

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

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

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

  4022. 

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

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

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

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

  4027. 

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

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

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

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

  4032. 

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

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

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

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

  4037. 

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

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

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

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

  4042. 

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

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

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

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

  4047. 

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

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

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

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

  4052.   }

  4053. }