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

4098 lines
120KB
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. #include <signal.h>

  30. #include <setjmp.h>

  31. 

  32. #include "dsputil.h"

  33. 

  34. #include "vis.h"

  35. 

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

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

  38. extern void ff_simple_idct_vis(DCTELEM *data);

  39. 

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

  41.  * motion comp code, which is:

  42.  *

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

  44.  *

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

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

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

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

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

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

  51.  *

  52.  *      fxor            f0,   f2, f10

  53.  *      fand            f10,  f4, f10

  54.  *      fmul8x16        f8,  f10, f10

  55.  *      fand            f10,  f6, f10

  56.  *      for             f0,   f2, f12

  57.  *      fpsub16         f12, f10, f10

  58.  */

  59. 

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

  61. 

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

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

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

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

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

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

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

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

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

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

  72.         {256, 512, 256, 512};

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

  74.         {256, 1024, 256, 1024};

  75. 

  76. #define REF_0           0

  77. #define REF_0_1         1

  78. #define REF_2           2

  79. #define REF_2_1         3

  80. #define REF_4           4

  81. #define REF_4_1         5

  82. #define REF_6           6

  83. #define REF_6_1         7

  84. #define REF_S0          8

  85. #define REF_S0_1        9

  86. #define REF_S2          10

  87. #define REF_S2_1        11

  88. #define REF_S4          12

  89. #define REF_S4_1        13

  90. #define REF_S6          14

  91. #define REF_S6_1        15

  92. #define DST_0           16

  93. #define DST_1           17

  94. #define DST_2           18

  95. #define DST_3           19

  96. #define CONST_1         20

  97. #define CONST_2         20

  98. #define CONST_3         20

  99. #define CONST_6         20

  100. #define MASK_fe         20

  101. #define CONST_128       22

  102. #define CONST_256       22

  103. #define CONST_512       22

  104. #define CONST_1024      22

  105. #define TMP0            24

  106. #define TMP1            25

  107. #define TMP2            26

  108. #define TMP3            27

  109. #define TMP4            28

  110. #define TMP5            29

  111. #define ZERO            30

  112. #define MASK_7f         30

  113. 

  114. #define TMP6            32

  115. #define TMP8            34

  116. #define TMP10           36

  117. #define TMP12           38

  118. #define TMP14           40

  119. #define TMP16           42

  120. #define TMP18           44

  121. #define TMP20           46

  122. #define TMP22           48

  123. #define TMP24           50

  124. #define TMP26           52

  125. #define TMP28           54

  126. #define TMP30           56

  127. #define TMP32           58

  128. 

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

  130.                              const int stride, int height)

  131. {

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

  133. 

  134.         ref = vis_alignaddr(ref);

  135.         do {    /* 5 cycles */

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

  137. 

  138.                 vis_ld64_2(ref, 8, TMP2);

  139. 

  140.                 vis_ld64_2(ref, 16, TMP4);

  141.                 ref += stride;

  142. 

  143.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  145. 

  146.                 vis_faligndata(TMP2, TMP4, REF_2);

  147.                 vis_st64_2(REF_2, dest, 8);

  148.                 dest += stride;

  149.         } while (--height);

  150. }

  151. 

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

  153.                             const int stride, int height)

  154. {

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

  156. 

  157.         ref = vis_alignaddr(ref);

  158.         do {    /* 4 cycles */

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

  160. 

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

  162.                 ref += stride;

  163. 

  164.                 /* stall */

  165. 

  166.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  168.                 dest += stride;

  169.         } while (--height);

  170. }

  171. 

  172. 

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

  174.                              const int stride, int height)

  175. {

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

  177.         int stride_8 = stride + 8;

  178. 

  179.         ref = vis_alignaddr(ref);

  180. 

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

  182. 

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

  184. 

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

  186. 

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

  188. 

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

  190. 

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

  192.         vis_faligndata(TMP0, TMP2, REF_0);

  193. 

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

  195.         vis_faligndata(TMP2, TMP4, REF_2);

  196. 

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

  198. 

  199.         ref += stride;

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

  201. 

  202.         do {    /* 24 cycles */

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

  204.                 vis_xor(DST_0, REF_0, TMP6);

  205. 

  206.                 vis_ld64_2(ref, 8, TMP2);

  207.                 vis_and(TMP6, MASK_fe, TMP6);

  208. 

  209.                 vis_ld64_2(ref, 16, TMP4);

  210.                 ref += stride;

  211.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  212.                 vis_xor(DST_2, REF_2, TMP8);

  213. 

  214.                 vis_and(TMP8, MASK_fe, TMP8);

  215. 

  216.                 vis_or(DST_0, REF_0, TMP10);

  217.                 vis_ld64_2(dest, stride, DST_0);

  218.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  219. 

  220.                 vis_or(DST_2, REF_2, TMP12);

  221.                 vis_ld64_2(dest, stride_8, DST_2);

  222. 

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

  224.                 vis_and(TMP6, MASK_7f, TMP6);

  225. 

  226.                 vis_and(TMP8, MASK_7f, TMP8);

  227. 

  228.                 vis_psub16(TMP10, TMP6, TMP6);

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

  230. 

  231.                 vis_psub16(TMP12, TMP8, TMP8);

  232.                 vis_st64_2(TMP8, dest, 8);

  233. 

  234.                 dest += stride;

  235.                 vis_ld64_2(ref, 8, TMP16);

  236.                 vis_faligndata(TMP0, TMP2, REF_0);

  237. 

  238.                 vis_ld64_2(ref, 16, TMP18);

  239.                 vis_faligndata(TMP2, TMP4, REF_2);

  240.                 ref += stride;

  241. 

  242.                 vis_xor(DST_0, REF_0, TMP20);

  243. 

  244.                 vis_and(TMP20, MASK_fe, TMP20);

  245. 

  246.                 vis_xor(DST_2, REF_2, TMP22);

  247.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  248. 

  249.                 vis_and(TMP22, MASK_fe, TMP22);

  250. 

  251.                 vis_or(DST_0, REF_0, TMP24);

  252.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  253. 

  254.                 vis_or(DST_2, REF_2, TMP26);

  255. 

  256.                 vis_ld64_2(dest, stride, DST_0);

  257.                 vis_faligndata(TMP14, TMP16, REF_0);

  258. 

  259.                 vis_ld64_2(dest, stride_8, DST_2);

  260.                 vis_faligndata(TMP16, TMP18, REF_2);

  261. 

  262.                 vis_and(TMP20, MASK_7f, TMP20);

  263. 

  264.                 vis_and(TMP22, MASK_7f, TMP22);

  265. 

  266.                 vis_psub16(TMP24, TMP20, TMP20);

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

  268. 

  269.                 vis_psub16(TMP26, TMP22, TMP22);

  270.                 vis_st64_2(TMP22, dest, 8);

  271.                 dest += stride;

  272.         } while (--height);

  273. 

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

  275.         vis_xor(DST_0, REF_0, TMP6);

  276. 

  277.         vis_ld64_2(ref, 8, TMP2);

  278.         vis_and(TMP6, MASK_fe, TMP6);

  279. 

  280.         vis_ld64_2(ref, 16, TMP4);

  281.         vis_mul8x16(CONST_128, TMP6, TMP6);

  282.         vis_xor(DST_2, REF_2, TMP8);

  283. 

  284.         vis_and(TMP8, MASK_fe, TMP8);

  285. 

  286.         vis_or(DST_0, REF_0, TMP10);

  287.         vis_ld64_2(dest, stride, DST_0);

  288.         vis_mul8x16(CONST_128, TMP8, TMP8);

  289. 

  290.         vis_or(DST_2, REF_2, TMP12);

  291.         vis_ld64_2(dest, stride_8, DST_2);

  292. 

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

  294.         vis_and(TMP6, MASK_7f, TMP6);

  295. 

  296.         vis_and(TMP8, MASK_7f, TMP8);

  297. 

  298.         vis_psub16(TMP10, TMP6, TMP6);

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

  300. 

  301.         vis_psub16(TMP12, TMP8, TMP8);

  302.         vis_st64_2(TMP8, dest, 8);

  303. 

  304.         dest += stride;

  305.         vis_faligndata(TMP0, TMP2, REF_0);

  306. 

  307.         vis_faligndata(TMP2, TMP4, REF_2);

  308. 

  309.         vis_xor(DST_0, REF_0, TMP20);

  310. 

  311.         vis_and(TMP20, MASK_fe, TMP20);

  312. 

  313.         vis_xor(DST_2, REF_2, TMP22);

  314.         vis_mul8x16(CONST_128, TMP20, TMP20);

  315. 

  316.         vis_and(TMP22, MASK_fe, TMP22);

  317. 

  318.         vis_or(DST_0, REF_0, TMP24);

  319.         vis_mul8x16(CONST_128, TMP22, TMP22);

  320. 

  321.         vis_or(DST_2, REF_2, TMP26);

  322. 

  323.         vis_and(TMP20, MASK_7f, TMP20);

  324. 

  325.         vis_and(TMP22, MASK_7f, TMP22);

  326. 

  327.         vis_psub16(TMP24, TMP20, TMP20);

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

  329. 

  330.         vis_psub16(TMP26, TMP22, TMP22);

  331.         vis_st64_2(TMP22, dest, 8);

  332. }

  333. 

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

  335.                             const int stride, int height)

  336. {

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

  338. 

  339.         ref = vis_alignaddr(ref);

  340. 

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

  342. 

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

  344. 

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

  346. 

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

  348. 

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

  350.         vis_faligndata(TMP0, TMP2, REF_0);

  351. 

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

  353. 

  354.         ref += stride;

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

  356. 

  357.         do {    /* 12 cycles */

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

  359.                 vis_xor(DST_0, REF_0, TMP4);

  360. 

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

  362.                 vis_and(TMP4, MASK_fe, TMP4);

  363. 

  364.                 vis_or(DST_0, REF_0, TMP6);

  365.                 vis_ld64_2(dest, stride, DST_0);

  366.                 ref += stride;

  367.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  368. 

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

  370.                 vis_faligndata(TMP0, TMP2, REF_0);

  371. 

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

  373.                 vis_xor(DST_0, REF_0, TMP0);

  374.                 ref += stride;

  375. 

  376.                 vis_and(TMP0, MASK_fe, TMP0);

  377. 

  378.                 vis_and(TMP4, MASK_7f, TMP4);

  379. 

  380.                 vis_psub16(TMP6, TMP4, TMP4);

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

  382.                 dest += stride;

  383.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  384. 

  385.                 vis_or(DST_0, REF_0, TMP6);

  386.                 vis_ld64_2(dest, stride, DST_0);

  387. 

  388.                 vis_faligndata(TMP12, TMP2, REF_0);

  389. 

  390.                 vis_and(TMP0, MASK_7f, TMP0);

  391. 

  392.                 vis_psub16(TMP6, TMP0, TMP4);

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

  394.                 dest += stride;

  395.         } while (--height);

  396. 

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

  398.         vis_xor(DST_0, REF_0, TMP4);

  399. 

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

  401.         vis_and(TMP4, MASK_fe, TMP4);

  402. 

  403.         vis_or(DST_0, REF_0, TMP6);

  404.         vis_ld64_2(dest, stride, DST_0);

  405.         vis_mul8x16(CONST_128, TMP4, TMP4);

  406. 

  407.         vis_faligndata(TMP0, TMP2, REF_0);

  408. 

  409.         vis_xor(DST_0, REF_0, TMP0);

  410. 

  411.         vis_and(TMP0, MASK_fe, TMP0);

  412. 

  413.         vis_and(TMP4, MASK_7f, TMP4);

  414. 

  415.         vis_psub16(TMP6, TMP4, TMP4);

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

  417.         dest += stride;

  418.         vis_mul8x16(CONST_128, TMP0, TMP0);

  419. 

  420.         vis_or(DST_0, REF_0, TMP6);

  421. 

  422.         vis_and(TMP0, MASK_7f, TMP0);

  423. 

  424.         vis_psub16(TMP6, TMP0, TMP4);

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

  426. }

  427. 

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

  429.                              const int stride, int height)

  430. {

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

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

  433.         unsigned long off_plus_1 = off + 1;

  434. 

  435.         ref = vis_alignaddr(ref);

  436. 

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

  438. 

  439.         vis_ld64_2(ref, 8,  TMP2);

  440. 

  441.         vis_ld64_2(ref, 16, TMP4);

  442. 

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

  444. 

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

  446.         vis_faligndata(TMP0, TMP2, REF_0);

  447. 

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

  449.         vis_faligndata(TMP2, TMP4, REF_4);

  450. 

  451.         if (off != 0x7) {

  452.                 vis_alignaddr_g0((void *)off_plus_1);

  453.                 vis_faligndata(TMP0, TMP2, REF_2);

  454.                 vis_faligndata(TMP2, TMP4, REF_6);

  455.         } else {

  456.                 vis_src1(TMP2, REF_2);

  457.                 vis_src1(TMP4, REF_6);

  458.         }

  459. 

  460.         ref += stride;

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

  462. 

  463.         do {    /* 34 cycles */

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

  465.                 vis_xor(REF_0, REF_2, TMP6);

  466. 

  467.                 vis_ld64_2(ref, 8,  TMP2);

  468.                 vis_xor(REF_4, REF_6, TMP8);

  469. 

  470.                 vis_ld64_2(ref, 16, TMP4);

  471.                 vis_and(TMP6, MASK_fe, TMP6);

  472.                 ref += stride;

  473. 

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

  475.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  476.                 vis_and(TMP8, MASK_fe, TMP8);

  477. 

  478.                 vis_ld64_2(ref, 8,  TMP16);

  479.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  480.                 vis_or(REF_0, REF_2, TMP10);

  481. 

  482.                 vis_ld64_2(ref, 16, TMP18);

  483.                 ref += stride;

  484.                 vis_or(REF_4, REF_6, TMP12);

  485. 

  486.                 vis_alignaddr_g0((void *)off);

  487. 

  488.                 vis_faligndata(TMP0, TMP2, REF_0);

  489. 

  490.                 vis_faligndata(TMP2, TMP4, REF_4);

  491. 

  492.                 if (off != 0x7) {

  493.                         vis_alignaddr_g0((void *)off_plus_1);

  494.                         vis_faligndata(TMP0, TMP2, REF_2);

  495.                         vis_faligndata(TMP2, TMP4, REF_6);

  496.                 } else {

  497.                         vis_src1(TMP2, REF_2);

  498.                         vis_src1(TMP4, REF_6);

  499.                 }

  500. 

  501.                 vis_and(TMP6, MASK_7f, TMP6);

  502. 

  503.                 vis_and(TMP8, MASK_7f, TMP8);

  504. 

  505.                 vis_psub16(TMP10, TMP6, TMP6);

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

  507. 

  508.                 vis_psub16(TMP12, TMP8, TMP8);

  509.                 vis_st64_2(TMP8, dest, 8);

  510.                 dest += stride;

  511. 

  512.                 vis_xor(REF_0, REF_2, TMP6);

  513. 

  514.                 vis_xor(REF_4, REF_6, TMP8);

  515. 

  516.                 vis_and(TMP6, MASK_fe, TMP6);

  517. 

  518.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  519.                 vis_and(TMP8, MASK_fe, TMP8);

  520. 

  521.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  522.                 vis_or(REF_0, REF_2, TMP10);

  523. 

  524.                 vis_or(REF_4, REF_6, TMP12);

  525. 

  526.                 vis_alignaddr_g0((void *)off);

  527. 

  528.                 vis_faligndata(TMP14, TMP16, REF_0);

  529. 

  530.                 vis_faligndata(TMP16, TMP18, REF_4);

  531. 

  532.                 if (off != 0x7) {

  533.                         vis_alignaddr_g0((void *)off_plus_1);

  534.                         vis_faligndata(TMP14, TMP16, REF_2);

  535.                         vis_faligndata(TMP16, TMP18, REF_6);

  536.                 } else {

  537.                         vis_src1(TMP16, REF_2);

  538.                         vis_src1(TMP18, REF_6);

  539.                 }

  540. 

  541.                 vis_and(TMP6, MASK_7f, TMP6);

  542. 

  543.                 vis_and(TMP8, MASK_7f, TMP8);

  544. 

  545.                 vis_psub16(TMP10, TMP6, TMP6);

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

  547. 

  548.                 vis_psub16(TMP12, TMP8, TMP8);

  549.                 vis_st64_2(TMP8, dest, 8);

  550.                 dest += stride;

  551.         } while (--height);

  552. 

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

  554.         vis_xor(REF_0, REF_2, TMP6);

  555. 

  556.         vis_ld64_2(ref, 8,  TMP2);

  557.         vis_xor(REF_4, REF_6, TMP8);

  558. 

  559.         vis_ld64_2(ref, 16, TMP4);

  560.         vis_and(TMP6, MASK_fe, TMP6);

  561. 

  562.         vis_mul8x16(CONST_128, TMP6, TMP6);

  563.         vis_and(TMP8, MASK_fe, TMP8);

  564. 

  565.         vis_mul8x16(CONST_128, TMP8, TMP8);

  566.         vis_or(REF_0, REF_2, TMP10);

  567. 

  568.         vis_or(REF_4, REF_6, TMP12);

  569. 

  570.         vis_alignaddr_g0((void *)off);

  571. 

  572.         vis_faligndata(TMP0, TMP2, REF_0);

  573. 

  574.         vis_faligndata(TMP2, TMP4, REF_4);

  575. 

  576.         if (off != 0x7) {

  577.                 vis_alignaddr_g0((void *)off_plus_1);

  578.                 vis_faligndata(TMP0, TMP2, REF_2);

  579.                 vis_faligndata(TMP2, TMP4, REF_6);

  580.         } else {

  581.                 vis_src1(TMP2, REF_2);

  582.                 vis_src1(TMP4, REF_6);

  583.         }

  584. 

  585.         vis_and(TMP6, MASK_7f, TMP6);

  586. 

  587.         vis_and(TMP8, MASK_7f, TMP8);

  588. 

  589.         vis_psub16(TMP10, TMP6, TMP6);

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

  591. 

  592.         vis_psub16(TMP12, TMP8, TMP8);

  593.         vis_st64_2(TMP8, dest, 8);

  594.         dest += stride;

  595. 

  596.         vis_xor(REF_0, REF_2, TMP6);

  597. 

  598.         vis_xor(REF_4, REF_6, TMP8);

  599. 

  600.         vis_and(TMP6, MASK_fe, TMP6);

  601. 

  602.         vis_mul8x16(CONST_128, TMP6, TMP6);

  603.         vis_and(TMP8, MASK_fe, TMP8);

  604. 

  605.         vis_mul8x16(CONST_128, TMP8, TMP8);

  606.         vis_or(REF_0, REF_2, TMP10);

  607. 

  608.         vis_or(REF_4, REF_6, TMP12);

  609. 

  610.         vis_and(TMP6, MASK_7f, TMP6);

  611. 

  612.         vis_and(TMP8, MASK_7f, TMP8);

  613. 

  614.         vis_psub16(TMP10, TMP6, TMP6);

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

  616. 

  617.         vis_psub16(TMP12, TMP8, TMP8);

  618.         vis_st64_2(TMP8, dest, 8);

  619. }

  620. 

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

  622.                             const int stride, int height)

  623. {

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

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

  626.         unsigned long off_plus_1 = off + 1;

  627. 

  628.         ref = vis_alignaddr(ref);

  629. 

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

  631. 

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

  633. 

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

  635. 

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

  637. 

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

  639.         vis_faligndata(TMP0, TMP2, REF_0);

  640. 

  641.         if (off != 0x7) {

  642.                 vis_alignaddr_g0((void *)off_plus_1);

  643.                 vis_faligndata(TMP0, TMP2, REF_2);

  644.         } else {

  645.                 vis_src1(TMP2, REF_2);

  646.         }

  647. 

  648.         ref += stride;

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

  650. 

  651.         do {    /* 20 cycles */

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

  653.                 vis_xor(REF_0, REF_2, TMP4);

  654. 

  655.                 vis_ld64_2(ref, 8, TMP2);

  656.                 vis_and(TMP4, MASK_fe, TMP4);

  657.                 ref += stride;

  658. 

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

  660.                 vis_or(REF_0, REF_2, TMP6);

  661.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  662. 

  663.                 vis_alignaddr_g0((void *)off);

  664. 

  665.                 vis_ld64_2(ref, 8, TMP10);

  666.                 ref += stride;

  667.                 vis_faligndata(TMP0, TMP2, REF_0);

  668. 

  669.                 if (off != 0x7) {

  670.                         vis_alignaddr_g0((void *)off_plus_1);

  671.                         vis_faligndata(TMP0, TMP2, REF_2);

  672.                 } else {

  673.                         vis_src1(TMP2, REF_2);

  674.                 }

  675. 

  676.                 vis_and(TMP4, MASK_7f, TMP4);

  677. 

  678.                 vis_psub16(TMP6, TMP4, DST_0);

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

  680.                 dest += stride;

  681. 

  682.                 vis_xor(REF_0, REF_2, TMP12);

  683. 

  684.                 vis_and(TMP12, MASK_fe, TMP12);

  685. 

  686.                 vis_or(REF_0, REF_2, TMP14);

  687.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  688. 

  689.                 vis_alignaddr_g0((void *)off);

  690.                 vis_faligndata(TMP8, TMP10, REF_0);

  691.                 if (off != 0x7) {

  692.                         vis_alignaddr_g0((void *)off_plus_1);

  693.                         vis_faligndata(TMP8, TMP10, REF_2);

  694.                 } else {

  695.                         vis_src1(TMP10, REF_2);

  696.                 }

  697. 

  698.                 vis_and(TMP12, MASK_7f, TMP12);

  699. 

  700.                 vis_psub16(TMP14, TMP12, DST_0);

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

  702.                 dest += stride;

  703.         } while (--height);

  704. 

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

  706.         vis_xor(REF_0, REF_2, TMP4);

  707. 

  708.         vis_ld64_2(ref, 8, TMP2);

  709.         vis_and(TMP4, MASK_fe, TMP4);

  710. 

  711.         vis_or(REF_0, REF_2, TMP6);

  712.         vis_mul8x16(CONST_128, TMP4, TMP4);

  713. 

  714.         vis_alignaddr_g0((void *)off);

  715. 

  716.         vis_faligndata(TMP0, TMP2, REF_0);

  717. 

  718.         if (off != 0x7) {

  719.                 vis_alignaddr_g0((void *)off_plus_1);

  720.                 vis_faligndata(TMP0, TMP2, REF_2);

  721.         } else {

  722.                 vis_src1(TMP2, REF_2);

  723.         }

  724. 

  725.         vis_and(TMP4, MASK_7f, TMP4);

  726. 

  727.         vis_psub16(TMP6, TMP4, DST_0);

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

  729.         dest += stride;

  730. 

  731.         vis_xor(REF_0, REF_2, TMP12);

  732. 

  733.         vis_and(TMP12, MASK_fe, TMP12);

  734. 

  735.         vis_or(REF_0, REF_2, TMP14);

  736.         vis_mul8x16(CONST_128, TMP12, TMP12);

  737. 

  738.         vis_and(TMP12, MASK_7f, TMP12);

  739. 

  740.         vis_psub16(TMP14, TMP12, DST_0);

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

  742.         dest += stride;

  743. }

  744. 

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

  746.                              const int stride, int height)

  747. {

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

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

  750.         unsigned long off_plus_1 = off + 1;

  751. 

  752.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  753. 

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

  755.         vis_fzero(ZERO);

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

  757. 

  758.         ref = vis_alignaddr(ref);

  759.         do {    /* 26 cycles */

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

  761. 

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

  763. 

  764.                 vis_alignaddr_g0((void *)off);

  765. 

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

  767. 

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

  769.                 vis_faligndata(TMP0, TMP2, REF_0);

  770. 

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

  772.                 vis_faligndata(TMP2, TMP4, REF_4);

  773. 

  774.                 if (off != 0x7) {

  775.                         vis_alignaddr_g0((void *)off_plus_1);

  776.                         vis_faligndata(TMP0, TMP2, REF_2);

  777.                         vis_faligndata(TMP2, TMP4, REF_6);

  778.                 } else {

  779.                         vis_src1(TMP2, REF_2);

  780.                         vis_src1(TMP4, REF_6);

  781.                 }

  782. 

  783.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  784. 

  785.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  786.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  787. 

  788.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  789. 

  790.                 vis_padd16(TMP0, TMP4, TMP0);

  791. 

  792.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  793.                 vis_padd16(TMP2, TMP6, TMP2);

  794. 

  795.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  796. 

  797.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  798. 

  799.                 vis_padd16(TMP0, TMP4, TMP0);

  800.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  801. 

  802.                 vis_padd16(TMP2, TMP6, TMP2);

  803.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  804. 

  805.                 vis_padd16(TMP0, CONST_3, TMP8);

  806.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  807. 

  808.                 vis_padd16(TMP2, CONST_3, TMP10);

  809.                 vis_pack16(TMP8, DST_0);

  810. 

  811.                 vis_pack16(TMP10, DST_1);

  812.                 vis_padd16(TMP16, TMP12, TMP0);

  813. 

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

  815.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  816.                 vis_padd16(TMP18, TMP14, TMP2);

  817. 

  818.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  819.                 vis_padd16(TMP0, CONST_3, TMP0);

  820. 

  821.                 vis_padd16(TMP2, CONST_3, TMP2);

  822. 

  823.                 vis_padd16(TMP0, TMP4, TMP0);

  824. 

  825.                 vis_padd16(TMP2, TMP6, TMP2);

  826.                 vis_pack16(TMP0, DST_2);

  827. 

  828.                 vis_pack16(TMP2, DST_3);

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

  830. 

  831.                 ref += stride;

  832.                 dest += stride;

  833.         } while (--height);

  834. }

  835. 

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

  837.                             const int stride, int height)

  838. {

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

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

  841.         unsigned long off_plus_1 = off + 1;

  842.         int stride_times_2 = stride << 1;

  843. 

  844.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  845. 

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

  847.         vis_fzero(ZERO);

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

  849. 

  850.         ref = vis_alignaddr(ref);

  851.         height >>= 2;

  852.         do {    /* 47 cycles */

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

  854. 

  855.                 vis_ld64_2(ref, 8, TMP2);

  856.                 ref += stride;

  857. 

  858.                 vis_alignaddr_g0((void *)off);

  859. 

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

  861.                 vis_faligndata(TMP0, TMP2, REF_0);

  862. 

  863.                 vis_ld64_2(ref, 8, TMP6);

  864.                 ref += stride;

  865. 

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

  867. 

  868.                 vis_ld64_2(ref, 8, TMP10);

  869.                 ref += stride;

  870.                 vis_faligndata(TMP4, TMP6, REF_4);

  871. 

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

  873. 

  874.                 vis_ld64_2(ref, 8, TMP14);

  875.                 ref += stride;

  876.                 vis_faligndata(TMP8, TMP10, REF_S0);

  877. 

  878.                 vis_faligndata(TMP12, TMP14, REF_S4);

  879. 

  880.                 if (off != 0x7) {

  881.                         vis_alignaddr_g0((void *)off_plus_1);

  882. 

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

  884.                         vis_faligndata(TMP0, TMP2, REF_2);

  885. 

  886.                         vis_ld64_2(dest, stride, DST_2);

  887.                         vis_faligndata(TMP4, TMP6, REF_6);

  888. 

  889.                         vis_faligndata(TMP8, TMP10, REF_S2);

  890. 

  891.                         vis_faligndata(TMP12, TMP14, REF_S6);

  892.                 } else {

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

  894.                         vis_src1(TMP2, REF_2);

  895. 

  896.                         vis_ld64_2(dest, stride, DST_2);

  897.                         vis_src1(TMP6, REF_6);

  898. 

  899.                         vis_src1(TMP10, REF_S2);

  900. 

  901.                         vis_src1(TMP14, REF_S6);

  902.                 }

  903. 

  904.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  905.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  906. 

  907.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  908.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  909. 

  910.                 vis_padd16(TMP0, CONST_3, TMP0);

  911.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  912. 

  913.                 vis_padd16(TMP2, CONST_3, TMP2);

  914.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  915. 

  916.                 vis_padd16(TMP0, TMP4, TMP0);

  917.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  918. 

  919.                 vis_padd16(TMP2, TMP6, TMP2);

  920.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  921. 

  922.                 vis_padd16(TMP0, TMP16, TMP0);

  923.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  924. 

  925.                 vis_padd16(TMP2, TMP18, TMP2);

  926.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  927. 

  928.                 vis_padd16(TMP8, CONST_3, TMP8);

  929.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  930. 

  931.                 vis_padd16(TMP8, TMP12, TMP8);

  932.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  933. 

  934.                 vis_padd16(TMP10, TMP14, TMP10);

  935.                 vis_pack16(TMP0, DST_0);

  936. 

  937.                 vis_pack16(TMP2, DST_1);

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

  939.                 dest += stride;

  940.                 vis_padd16(TMP10, CONST_3, TMP10);

  941. 

  942.                 vis_ld64_2(dest, stride, DST_0);

  943.                 vis_padd16(TMP8, TMP16, TMP8);

  944. 

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

  946.                 vis_padd16(TMP10, TMP18, TMP10);

  947.                 vis_pack16(TMP8, DST_2);

  948. 

  949.                 vis_pack16(TMP10, DST_3);

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

  951.                 dest += stride;

  952. 

  953.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  954.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  955. 

  956.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  957.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  958. 

  959.                 vis_padd16(TMP0, CONST_3, TMP0);

  960.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  961. 

  962.                 vis_padd16(TMP2, CONST_3, TMP2);

  963.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  964. 

  965.                 vis_padd16(TMP0, TMP24, TMP0);

  966.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  967. 

  968.                 vis_padd16(TMP2, TMP6, TMP2);

  969.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  970. 

  971.                 vis_padd16(TMP8, CONST_3, TMP8);

  972.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  973. 

  974.                 vis_padd16(TMP10, CONST_3, TMP10);

  975.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  976. 

  977.                 vis_padd16(TMP8, TMP12, TMP8);

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

  979. 

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

  981.                 vis_padd16(TMP0, TMP16, TMP0);

  982. 

  983.                 vis_padd16(TMP2, TMP18, TMP2);

  984.                 vis_pack16(TMP0, DST_0);

  985. 

  986.                 vis_padd16(TMP10, TMP14, TMP10);

  987.                 vis_pack16(TMP2, DST_1);

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

  989.                 dest += stride;

  990. 

  991.                 vis_padd16(TMP8, TMP20, TMP8);

  992. 

  993.                 vis_padd16(TMP10, TMP22, TMP10);

  994.                 vis_pack16(TMP8, DST_2);

  995. 

  996.                 vis_pack16(TMP10, DST_3);

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

  998.                 dest += stride;

  999.         } while (--height);

  1000. }

  1001. 

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

  1003.                              const int stride, int height)

  1004. {

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

  1006. 

  1007.         ref = vis_alignaddr(ref);

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

  1009. 

  1010.         vis_ld64_2(ref, 8, TMP2);

  1011. 

  1012.         vis_ld64_2(ref, 16, TMP4);

  1013.         ref += stride;

  1014. 

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

  1016.         vis_faligndata(TMP0, TMP2, REF_0);

  1017. 

  1018.         vis_ld64_2(ref, 8, TMP8);

  1019.         vis_faligndata(TMP2, TMP4, REF_4);

  1020. 

  1021.         vis_ld64_2(ref, 16, TMP10);

  1022.         ref += stride;

  1023. 

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

  1025.         vis_faligndata(TMP6, TMP8, REF_2);

  1026. 

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

  1028.         vis_faligndata(TMP8, TMP10, REF_6);

  1029. 

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

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

  1032.         do {    /* 24 cycles */

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

  1034.                 vis_xor(REF_0, REF_2, TMP12);

  1035. 

  1036.                 vis_ld64_2(ref, 8, TMP2);

  1037.                 vis_xor(REF_4, REF_6, TMP16);

  1038. 

  1039.                 vis_ld64_2(ref, 16, TMP4);

  1040.                 ref += stride;

  1041.                 vis_or(REF_0, REF_2, TMP14);

  1042. 

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

  1044.                 vis_or(REF_4, REF_6, TMP18);

  1045. 

  1046.                 vis_ld64_2(ref, 8, TMP8);

  1047.                 vis_faligndata(TMP0, TMP2, REF_0);

  1048. 

  1049.                 vis_ld64_2(ref, 16, TMP10);

  1050.                 ref += stride;

  1051.                 vis_faligndata(TMP2, TMP4, REF_4);

  1052. 

  1053.                 vis_and(TMP12, MASK_fe, TMP12);

  1054. 

  1055.                 vis_and(TMP16, MASK_fe, TMP16);

  1056.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1057. 

  1058.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  1059.                 vis_xor(REF_0, REF_2, TMP0);

  1060. 

  1061.                 vis_xor(REF_4, REF_6, TMP2);

  1062. 

  1063.                 vis_or(REF_0, REF_2, TMP20);

  1064. 

  1065.                 vis_and(TMP12, MASK_7f, TMP12);

  1066. 

  1067.                 vis_and(TMP16, MASK_7f, TMP16);

  1068. 

  1069.                 vis_psub16(TMP14, TMP12, TMP12);

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

  1071. 

  1072.                 vis_psub16(TMP18, TMP16, TMP16);

  1073.                 vis_st64_2(TMP16, dest, 8);

  1074.                 dest += stride;

  1075. 

  1076.                 vis_or(REF_4, REF_6, TMP18);

  1077. 

  1078.                 vis_and(TMP0, MASK_fe, TMP0);

  1079. 

  1080.                 vis_and(TMP2, MASK_fe, TMP2);

  1081.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  1082. 

  1083.                 vis_faligndata(TMP6, TMP8, REF_2);

  1084.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  1085. 

  1086.                 vis_faligndata(TMP8, TMP10, REF_6);

  1087. 

  1088.                 vis_and(TMP0, MASK_7f, TMP0);

  1089. 

  1090.                 vis_and(TMP2, MASK_7f, TMP2);

  1091. 

  1092.                 vis_psub16(TMP20, TMP0, TMP0);

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

  1094. 

  1095.                 vis_psub16(TMP18, TMP2, TMP2);

  1096.                 vis_st64_2(TMP2, dest, 8);

  1097.                 dest += stride;

  1098.         } while (--height);

  1099. 

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

  1101.         vis_xor(REF_0, REF_2, TMP12);

  1102. 

  1103.         vis_ld64_2(ref, 8, TMP2);

  1104.         vis_xor(REF_4, REF_6, TMP16);

  1105. 

  1106.         vis_ld64_2(ref, 16, TMP4);

  1107.         vis_or(REF_0, REF_2, TMP14);

  1108. 

  1109.         vis_or(REF_4, REF_6, TMP18);

  1110. 

  1111.         vis_faligndata(TMP0, TMP2, REF_0);

  1112. 

  1113.         vis_faligndata(TMP2, TMP4, REF_4);

  1114. 

  1115.         vis_and(TMP12, MASK_fe, TMP12);

  1116. 

  1117.         vis_and(TMP16, MASK_fe, TMP16);

  1118.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1119. 

  1120.         vis_mul8x16(CONST_128, TMP16, TMP16);

  1121.         vis_xor(REF_0, REF_2, TMP0);

  1122. 

  1123.         vis_xor(REF_4, REF_6, TMP2);

  1124. 

  1125.         vis_or(REF_0, REF_2, TMP20);

  1126. 

  1127.         vis_and(TMP12, MASK_7f, TMP12);

  1128. 

  1129.         vis_and(TMP16, MASK_7f, TMP16);

  1130. 

  1131.         vis_psub16(TMP14, TMP12, TMP12);

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

  1133. 

  1134.         vis_psub16(TMP18, TMP16, TMP16);

  1135.         vis_st64_2(TMP16, dest, 8);

  1136.         dest += stride;

  1137. 

  1138.         vis_or(REF_4, REF_6, TMP18);

  1139. 

  1140.         vis_and(TMP0, MASK_fe, TMP0);

  1141. 

  1142.         vis_and(TMP2, MASK_fe, TMP2);

  1143.         vis_mul8x16(CONST_128, TMP0, TMP0);

  1144. 

  1145.         vis_mul8x16(CONST_128, TMP2, TMP2);

  1146. 

  1147.         vis_and(TMP0, MASK_7f, TMP0);

  1148. 

  1149.         vis_and(TMP2, MASK_7f, TMP2);

  1150. 

  1151.         vis_psub16(TMP20, TMP0, TMP0);

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

  1153. 

  1154.         vis_psub16(TMP18, TMP2, TMP2);

  1155.         vis_st64_2(TMP2, dest, 8);

  1156. }

  1157. 

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

  1159.                             const int stride, int height)

  1160. {

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

  1162. 

  1163.         ref = vis_alignaddr(ref);

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

  1165. 

  1166.         vis_ld64_2(ref, 8, TMP2);

  1167.         ref += stride;

  1168. 

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

  1170. 

  1171.         vis_ld64_2(ref, 8, TMP6);

  1172.         ref += stride;

  1173. 

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

  1175.         vis_faligndata(TMP0, TMP2, REF_0);

  1176. 

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

  1178.         vis_faligndata(TMP4, TMP6, REF_2);

  1179. 

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

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

  1182.         do {    /* 12 cycles */

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

  1184.                 vis_xor(REF_0, REF_2, TMP4);

  1185. 

  1186.                 vis_ld64_2(ref, 8, TMP2);

  1187.                 ref += stride;

  1188.                 vis_and(TMP4, MASK_fe, TMP4);

  1189. 

  1190.                 vis_or(REF_0, REF_2, TMP6);

  1191.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  1192. 

  1193.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  1195. 

  1196.                 vis_ld64_2(ref, 8, TMP2);

  1197.                 ref += stride;

  1198.                 vis_xor(REF_0, REF_2, TMP12);

  1199. 

  1200.                 vis_and(TMP4, MASK_7f, TMP4);

  1201. 

  1202.                 vis_and(TMP12, MASK_fe, TMP12);

  1203. 

  1204.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1205.                 vis_or(REF_0, REF_2, TMP14);

  1206. 

  1207.                 vis_psub16(TMP6, TMP4, DST_0);

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

  1209.                 dest += stride;

  1210. 

  1211.                 vis_faligndata(TMP0, TMP2, REF_2);

  1212. 

  1213.                 vis_and(TMP12, MASK_7f, TMP12);

  1214. 

  1215.                 vis_psub16(TMP14, TMP12, DST_0);

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

  1217.                 dest += stride;

  1218.         } while (--height);

  1219. 

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

  1221.         vis_xor(REF_0, REF_2, TMP4);

  1222. 

  1223.         vis_ld64_2(ref, 8, TMP2);

  1224.         vis_and(TMP4, MASK_fe, TMP4);

  1225. 

  1226.         vis_or(REF_0, REF_2, TMP6);

  1227.         vis_mul8x16(CONST_128, TMP4, TMP4);

  1228. 

  1229.         vis_faligndata(TMP0, TMP2, REF_0);

  1230. 

  1231.         vis_xor(REF_0, REF_2, TMP12);

  1232. 

  1233.         vis_and(TMP4, MASK_7f, TMP4);

  1234. 

  1235.         vis_and(TMP12, MASK_fe, TMP12);

  1236. 

  1237.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1238.         vis_or(REF_0, REF_2, TMP14);

  1239. 

  1240.         vis_psub16(TMP6, TMP4, DST_0);

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

  1242.         dest += stride;

  1243. 

  1244.         vis_and(TMP12, MASK_7f, TMP12);

  1245. 

  1246.         vis_psub16(TMP14, TMP12, DST_0);

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

  1248. }

  1249. 

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

  1251.                              const int stride, int height)

  1252. {

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

  1254.         int stride_8 = stride + 8;

  1255.         int stride_16 = stride + 16;

  1256. 

  1257.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1258. 

  1259.         ref = vis_alignaddr(ref);

  1260. 

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

  1262.         vis_fzero(ZERO);

  1263. 

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

  1265. 

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

  1267. 

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

  1269.         vis_faligndata(TMP0, TMP2, REF_2);

  1270. 

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

  1272.         vis_faligndata(TMP2, TMP4, REF_6);

  1273.         height >>= 1;

  1274. 

  1275.         do {    /* 31 cycles */

  1276.                 vis_ld64_2(ref, stride, TMP0);

  1277.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  1278.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  1279. 

  1280.                 vis_ld64_2(ref, stride_8, TMP2);

  1281.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  1282.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  1283. 

  1284.                 vis_ld64_2(ref, stride_16, TMP4);

  1285.                 ref += stride;

  1286. 

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

  1288.                 vis_faligndata(TMP0, TMP2, REF_0);

  1289. 

  1290.                 vis_ld64_2(dest, 8, DST_2);

  1291.                 vis_faligndata(TMP2, TMP4, REF_4);

  1292. 

  1293.                 vis_ld64_2(ref, stride, TMP6);

  1294.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  1295.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  1296. 

  1297.                 vis_ld64_2(ref, stride_8, TMP8);

  1298.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  1299. 

  1300.                 vis_ld64_2(ref, stride_16, TMP10);

  1301.                 ref += stride;

  1302. 

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

  1304.                 vis_faligndata(TMP6, TMP8, REF_2);

  1305.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1306. 

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

  1308.                 vis_faligndata(TMP8, TMP10, REF_6);

  1309.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  1310. 

  1311.                 vis_padd16(TMP0, CONST_3, TMP0);

  1312.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  1313. 

  1314.                 vis_padd16(TMP2, CONST_3, TMP2);

  1315.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1316. 

  1317.                 vis_padd16(TMP4, CONST_3, TMP4);

  1318.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1319. 

  1320.                 vis_padd16(TMP6, CONST_3, TMP6);

  1321. 

  1322.                 vis_padd16(TMP12, TMP20, TMP12);

  1323.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  1324. 

  1325.                 vis_padd16(TMP14, TMP22, TMP14);

  1326.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  1327. 

  1328.                 vis_padd16(TMP16, TMP24, TMP16);

  1329.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  1330. 

  1331.                 vis_padd16(TMP18, TMP26, TMP18);

  1332.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  1333. 

  1334.                 vis_padd16(TMP12, TMP0, TMP12);

  1335.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  1336. 

  1337.                 vis_padd16(TMP14, TMP2, TMP14);

  1338.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  1339. 

  1340.                 vis_padd16(TMP16, TMP4, TMP16);

  1341.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  1342. 

  1343.                 vis_padd16(TMP18, TMP6, TMP18);

  1344.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  1345. 

  1346.                 vis_pack16(TMP12, DST_0);

  1347.                 vis_padd16(TMP28, TMP0, TMP12);

  1348. 

  1349.                 vis_pack16(TMP14, DST_1);

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

  1351.                 vis_padd16(TMP30, TMP2, TMP14);

  1352. 

  1353.                 vis_pack16(TMP16, DST_2);

  1354.                 vis_padd16(REF_S4, TMP4, TMP16);

  1355. 

  1356.                 vis_pack16(TMP18, DST_3);

  1357.                 vis_st64_2(DST_2, dest, 8);

  1358.                 dest += stride;

  1359.                 vis_padd16(REF_S6, TMP6, TMP18);

  1360. 

  1361.                 vis_padd16(TMP12, TMP20, TMP12);

  1362. 

  1363.                 vis_padd16(TMP14, TMP22, TMP14);

  1364.                 vis_pack16(TMP12, DST_0);

  1365. 

  1366.                 vis_padd16(TMP16, TMP24, TMP16);

  1367.                 vis_pack16(TMP14, DST_1);

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

  1369. 

  1370.                 vis_padd16(TMP18, TMP26, TMP18);

  1371.                 vis_pack16(TMP16, DST_2);

  1372. 

  1373.                 vis_pack16(TMP18, DST_3);

  1374.                 vis_st64_2(DST_2, dest, 8);

  1375.                 dest += stride;

  1376.         } while (--height);

  1377. }

  1378. 

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

  1380.                             const int stride, int height)

  1381. {

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

  1383.         int stride_8 = stride + 8;

  1384. 

  1385.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1386. 

  1387.         ref = vis_alignaddr(ref);

  1388. 

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

  1390.         vis_fzero(ZERO);

  1391. 

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

  1393. 

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

  1395.         vis_faligndata(TMP0, TMP2, REF_2);

  1396. 

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

  1398. 

  1399.         height >>= 1;

  1400.         do {    /* 20 cycles */

  1401.                 vis_ld64_2(ref, stride, TMP0);

  1402.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  1403.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  1404. 

  1405.                 vis_ld64_2(ref, stride_8, TMP2);

  1406.                 ref += stride;

  1407. 

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

  1409. 

  1410.                 vis_ld64_2(dest, stride, DST_2);

  1411.                 vis_faligndata(TMP0, TMP2, REF_0);

  1412. 

  1413.                 vis_ld64_2(ref, stride, TMP4);

  1414.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  1415.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  1416. 

  1417.                 vis_ld64_2(ref, stride_8, TMP6);

  1418.                 ref += stride;

  1419.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  1420.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  1421. 

  1422.                 vis_padd16(TMP12, CONST_3, TMP12);

  1423.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1424. 

  1425.                 vis_padd16(TMP14, CONST_3, TMP14);

  1426.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1427. 

  1428.                 vis_faligndata(TMP4, TMP6, REF_2);

  1429. 

  1430.                 vis_padd16(TMP8, TMP12, TMP8);

  1431. 

  1432.                 vis_padd16(TMP10, TMP14, TMP10);

  1433.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  1434. 

  1435.                 vis_padd16(TMP8, TMP16, TMP0);

  1436.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  1437. 

  1438.                 vis_padd16(TMP10, TMP18, TMP2);

  1439.                 vis_pack16(TMP0, DST_0);

  1440. 

  1441.                 vis_pack16(TMP2, DST_1);

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

  1443.                 dest += stride;

  1444.                 vis_padd16(TMP12, TMP20, TMP12);

  1445. 

  1446.                 vis_padd16(TMP14, TMP22, TMP14);

  1447. 

  1448.                 vis_padd16(TMP12, TMP24, TMP0);

  1449. 

  1450.                 vis_padd16(TMP14, TMP26, TMP2);

  1451.                 vis_pack16(TMP0, DST_2);

  1452. 

  1453.                 vis_pack16(TMP2, DST_3);

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

  1455.                 dest += stride;

  1456.         } while (--height);

  1457. }

  1458. 

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

  1460.                               const int stride, int height)

  1461. {

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

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

  1464.         unsigned long off_plus_1 = off + 1;

  1465.         int stride_8 = stride + 8;

  1466.         int stride_16 = stride + 16;

  1467. 

  1468.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1469. 

  1470.         ref = vis_alignaddr(ref);

  1471. 

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

  1473.         vis_fzero(ZERO);

  1474. 

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

  1476. 

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

  1478. 

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

  1480.         vis_faligndata(TMP0, TMP2, REF_S0);

  1481. 

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

  1483.         vis_faligndata(TMP2, TMP4, REF_S4);

  1484. 

  1485.         if (off != 0x7) {

  1486.                 vis_alignaddr_g0((void *)off_plus_1);

  1487.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1488.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1489.         } else {

  1490.                 vis_src1(TMP2, REF_S2);

  1491.                 vis_src1(TMP4, REF_S6);

  1492.         }

  1493. 

  1494.         height >>= 1;

  1495.         do {

  1496.                 vis_ld64_2(ref, stride, TMP0);

  1497.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1498.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1499. 

  1500.                 vis_alignaddr_g0((void *)off);

  1501. 

  1502.                 vis_ld64_2(ref, stride_8, TMP2);

  1503.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1504.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1505. 

  1506.                 vis_ld64_2(ref, stride_16, TMP4);

  1507.                 ref += stride;

  1508.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1509.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1510. 

  1511.                 vis_ld64_2(ref, stride, TMP6);

  1512.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1513.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1514. 

  1515.                 vis_ld64_2(ref, stride_8, TMP8);

  1516.                 vis_faligndata(TMP0, TMP2, REF_0);

  1517. 

  1518.                 vis_ld64_2(ref, stride_16, TMP10);

  1519.                 ref += stride;

  1520.                 vis_faligndata(TMP2, TMP4, REF_4);

  1521. 

  1522.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1523. 

  1524.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1525. 

  1526.                 if (off != 0x7) {

  1527.                         vis_alignaddr_g0((void *)off_plus_1);

  1528.                         vis_faligndata(TMP0, TMP2, REF_2);

  1529.                         vis_faligndata(TMP2, TMP4, REF_6);

  1530.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1531.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1532.                 } else {

  1533.                         vis_src1(TMP2, REF_2);

  1534.                         vis_src1(TMP4, REF_6);

  1535.                         vis_src1(TMP8, REF_S2);

  1536.                         vis_src1(TMP10, REF_S6);

  1537.                 }

  1538. 

  1539.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  1540.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1541. 

  1542.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1543.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1544. 

  1545.                 vis_padd16(TMP0, CONST_2, TMP8);

  1546.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  1547. 

  1548.                 vis_padd16(TMP2, CONST_2, TMP10);

  1549.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  1550. 

  1551.                 vis_padd16(TMP8, TMP4, TMP8);

  1552.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  1553. 

  1554.                 vis_padd16(TMP10, TMP6, TMP10);

  1555.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  1556. 

  1557.                 vis_padd16(TMP12, TMP8, TMP12);

  1558. 

  1559.                 vis_padd16(TMP14, TMP10, TMP14);

  1560. 

  1561.                 vis_padd16(TMP12, TMP16, TMP12);

  1562. 

  1563.                 vis_padd16(TMP14, TMP18, TMP14);

  1564.                 vis_pack16(TMP12, DST_0);

  1565. 

  1566.                 vis_pack16(TMP14, DST_1);

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

  1568.                 vis_padd16(TMP0, CONST_2, TMP12);

  1569. 

  1570.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  1571.                 vis_padd16(TMP2, CONST_2, TMP14);

  1572. 

  1573.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  1574.                 vis_padd16(TMP12, TMP4, TMP12);

  1575. 

  1576.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  1577.                 vis_padd16(TMP14, TMP6, TMP14);

  1578. 

  1579.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  1580.                 vis_padd16(TMP20, TMP12, TMP20);

  1581. 

  1582.                 vis_padd16(TMP22, TMP14, TMP22);

  1583. 

  1584.                 vis_padd16(TMP20, TMP24, TMP20);

  1585. 

  1586.                 vis_padd16(TMP22, TMP26, TMP22);

  1587.                 vis_pack16(TMP20, DST_2);

  1588. 

  1589.                 vis_pack16(TMP22, DST_3);

  1590.                 vis_st64_2(DST_2, dest, 8);

  1591.                 dest += stride;

  1592.                 vis_padd16(TMP0, TMP4, TMP24);

  1593. 

  1594.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  1595.                 vis_padd16(TMP2, TMP6, TMP26);

  1596. 

  1597.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  1598.                 vis_padd16(TMP24, TMP8, TMP24);

  1599. 

  1600.                 vis_padd16(TMP26, TMP10, TMP26);

  1601.                 vis_pack16(TMP24, DST_0);

  1602. 

  1603.                 vis_pack16(TMP26, DST_1);

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

  1605.                 vis_pmerge(ZERO, REF_S6, TMP4);

  1606. 

  1607.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  1608. 

  1609.                 vis_padd16(TMP0, TMP4, TMP0);

  1610. 

  1611.                 vis_padd16(TMP2, TMP6, TMP2);

  1612. 

  1613.                 vis_padd16(TMP0, TMP12, TMP0);

  1614. 

  1615.                 vis_padd16(TMP2, TMP14, TMP2);

  1616.                 vis_pack16(TMP0, DST_2);

  1617. 

  1618.                 vis_pack16(TMP2, DST_3);

  1619.                 vis_st64_2(DST_2, dest, 8);

  1620.                 dest += stride;

  1621.         } while (--height);

  1622. }

  1623. 

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

  1625.                              const int stride, int height)

  1626. {

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

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

  1629.         unsigned long off_plus_1 = off + 1;

  1630.         int stride_8 = stride + 8;

  1631. 

  1632.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1633. 

  1634.         ref = vis_alignaddr(ref);

  1635. 

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

  1637.         vis_fzero(ZERO);

  1638. 

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

  1640. 

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

  1642. 

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

  1644.         vis_faligndata(TMP0, TMP2, REF_S0);

  1645. 

  1646.         if (off != 0x7) {

  1647.                 vis_alignaddr_g0((void *)off_plus_1);

  1648.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1649.         } else {

  1650.                 vis_src1(TMP2, REF_S2);

  1651.         }

  1652. 

  1653.         height >>= 1;

  1654.         do {    /* 26 cycles */

  1655.                 vis_ld64_2(ref, stride, TMP0);

  1656.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  1657.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  1658. 

  1659.                 vis_alignaddr_g0((void *)off);

  1660. 

  1661.                 vis_ld64_2(ref, stride_8, TMP2);

  1662.                 ref += stride;

  1663.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  1664.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  1665. 

  1666.                 vis_ld64_2(ref, stride, TMP4);

  1667. 

  1668.                 vis_ld64_2(ref, stride_8, TMP6);

  1669.                 ref += stride;

  1670.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1671. 

  1672.                 vis_pmerge(ZERO, REF_S4, TMP18);

  1673. 

  1674.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  1675. 

  1676.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1677. 

  1678.                 if (off != 0x7) {

  1679.                         vis_alignaddr_g0((void *)off_plus_1);

  1680.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1681.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1682.                 } else {

  1683.                         vis_src1(TMP2, REF_S6);

  1684.                         vis_src1(TMP6, REF_S2);

  1685.                 }

  1686. 

  1687.                 vis_padd16(TMP18, CONST_2, TMP18);

  1688.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  1689. 

  1690.                 vis_padd16(TMP20, CONST_2, TMP20);

  1691.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  1692. 

  1693.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  1694.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  1695. 

  1696.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  1697.                 vis_padd16(TMP18, TMP22, TMP18);

  1698. 

  1699.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  1700.                 vis_padd16(TMP20, TMP24, TMP20);

  1701. 

  1702.                 vis_padd16(TMP8,  TMP18, TMP8);

  1703. 

  1704.                 vis_padd16(TMP10, TMP20, TMP10);

  1705. 

  1706.                 vis_padd16(TMP8,  TMP12, TMP8);

  1707. 

  1708.                 vis_padd16(TMP10, TMP14, TMP10);

  1709.                 vis_pack16(TMP8,  DST_0);

  1710. 

  1711.                 vis_pack16(TMP10, DST_1);

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

  1713.                 dest += stride;

  1714.                 vis_padd16(TMP18, TMP26, TMP18);

  1715. 

  1716.                 vis_padd16(TMP20, TMP28, TMP20);

  1717. 

  1718.                 vis_padd16(TMP18, TMP30, TMP18);

  1719. 

  1720.                 vis_padd16(TMP20, TMP32, TMP20);

  1721.                 vis_pack16(TMP18, DST_2);

  1722. 

  1723.                 vis_pack16(TMP20, DST_3);

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

  1725.                 dest += stride;

  1726.         } while (--height);

  1727. }

  1728. 

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

  1730.                               const int stride, int height)

  1731. {

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

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

  1734.         unsigned long off_plus_1 = off + 1;

  1735.         int stride_8 = stride + 8;

  1736.         int stride_16 = stride + 16;

  1737. 

  1738.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1739. 

  1740.         ref = vis_alignaddr(ref);

  1741. 

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

  1743.         vis_fzero(ZERO);

  1744. 

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

  1746. 

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

  1748. 

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

  1750.         vis_faligndata(TMP0, TMP2, REF_S0);

  1751. 

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

  1753.         vis_faligndata(TMP2, TMP4, REF_S4);

  1754. 

  1755.         if (off != 0x7) {

  1756.                 vis_alignaddr_g0((void *)off_plus_1);

  1757.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1758.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1759.         } else {

  1760.                 vis_src1(TMP2, REF_S2);

  1761.                 vis_src1(TMP4, REF_S6);

  1762.         }

  1763. 

  1764.         height >>= 1;

  1765.         do {    /* 55 cycles */

  1766.                 vis_ld64_2(ref, stride, TMP0);

  1767.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1768.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1769. 

  1770.                 vis_alignaddr_g0((void *)off);

  1771. 

  1772.                 vis_ld64_2(ref, stride_8, TMP2);

  1773.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1774.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1775. 

  1776.                 vis_ld64_2(ref, stride_16, TMP4);

  1777.                 ref += stride;

  1778.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1779.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1780. 

  1781.                 vis_ld64_2(ref, stride, TMP6);

  1782.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1783.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1784. 

  1785.                 vis_ld64_2(ref, stride_8, TMP8);

  1786.                 vis_faligndata(TMP0, TMP2, REF_0);

  1787. 

  1788.                 vis_ld64_2(ref, stride_16, TMP10);

  1789.                 ref += stride;

  1790.                 vis_faligndata(TMP2, TMP4, REF_4);

  1791. 

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

  1793.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1794. 

  1795.                 vis_ld64_2(dest, 8, DST_2);

  1796.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1797. 

  1798.                 if (off != 0x7) {

  1799.                         vis_alignaddr_g0((void *)off_plus_1);

  1800.                         vis_faligndata(TMP0, TMP2, REF_2);

  1801.                         vis_faligndata(TMP2, TMP4, REF_6);

  1802.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1803.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1804.                 } else {

  1805.                         vis_src1(TMP2, REF_2);

  1806.                         vis_src1(TMP4, REF_6);

  1807.                         vis_src1(TMP8, REF_S2);

  1808.                         vis_src1(TMP10, REF_S6);

  1809.                 }

  1810. 

  1811.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1812.                 vis_pmerge(ZERO, REF_0, TMP0);

  1813. 

  1814.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1815.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1816. 

  1817.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1818.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1819. 

  1820.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1821.                 vis_padd16(TMP0, CONST_6, TMP0);

  1822. 

  1823.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1824.                 vis_padd16(TMP2, CONST_6, TMP2);

  1825. 

  1826.                 vis_padd16(TMP0, TMP4, TMP0);

  1827.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  1828. 

  1829.                 vis_padd16(TMP2, TMP6, TMP2);

  1830.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1831. 

  1832.                 vis_padd16(TMP12, TMP0, TMP12);

  1833.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  1834. 

  1835.                 vis_padd16(TMP14, TMP2, TMP14);

  1836.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  1837. 

  1838.                 vis_padd16(TMP12, TMP16, TMP12);

  1839.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  1840. 

  1841.                 vis_padd16(TMP14, TMP18, TMP14);

  1842.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  1843. 

  1844.                 vis_padd16(TMP12, TMP30, TMP12);

  1845. 

  1846.                 vis_padd16(TMP14, TMP32, TMP14);

  1847.                 vis_pack16(TMP12, DST_0);

  1848. 

  1849.                 vis_pack16(TMP14, DST_1);

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

  1851.                 vis_padd16(TMP4, CONST_6, TMP4);

  1852. 

  1853.                 vis_ld64_2(dest, stride, DST_0);

  1854.                 vis_padd16(TMP6, CONST_6, TMP6);

  1855.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1856. 

  1857.                 vis_padd16(TMP4, TMP8, TMP4);

  1858.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  1859. 

  1860.                 vis_padd16(TMP6, TMP10, TMP6);

  1861. 

  1862.                 vis_padd16(TMP20, TMP4, TMP20);

  1863. 

  1864.                 vis_padd16(TMP22, TMP6, TMP22);

  1865. 

  1866.                 vis_padd16(TMP20, TMP24, TMP20);

  1867. 

  1868.                 vis_padd16(TMP22, TMP26, TMP22);

  1869. 

  1870.                 vis_padd16(TMP20, REF_0, TMP20);

  1871.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  1872. 

  1873.                 vis_padd16(TMP22, REF_2, TMP22);

  1874.                 vis_pack16(TMP20, DST_2);

  1875. 

  1876.                 vis_pack16(TMP22, DST_3);

  1877.                 vis_st64_2(DST_2, dest, 8);

  1878.                 dest += stride;

  1879. 

  1880.                 vis_ld64_2(dest, 8, DST_2);

  1881.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1882.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  1883. 

  1884.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1885.                 vis_padd16(REF_4, TMP0, TMP8);

  1886. 

  1887.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  1888.                 vis_padd16(REF_6, TMP2, TMP10);

  1889. 

  1890.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  1891.                 vis_padd16(TMP8, TMP12, TMP8);

  1892. 

  1893.                 vis_padd16(TMP10, TMP14, TMP10);

  1894. 

  1895.                 vis_padd16(TMP8, TMP30, TMP8);

  1896. 

  1897.                 vis_padd16(TMP10, TMP32, TMP10);

  1898.                 vis_pack16(TMP8, DST_0);

  1899. 

  1900.                 vis_pack16(TMP10, DST_1);

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

  1902. 

  1903.                 vis_padd16(REF_0, TMP4, REF_0);

  1904. 

  1905.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  1906.                 vis_padd16(REF_2, TMP6, REF_2);

  1907. 

  1908.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  1909.                 vis_padd16(REF_0, REF_4, REF_0);

  1910. 

  1911.                 vis_padd16(REF_2, REF_6, REF_2);

  1912. 

  1913.                 vis_padd16(REF_0, TMP30, REF_0);

  1914. 

  1915.                 /* stall */

  1916. 

  1917.                 vis_padd16(REF_2, TMP32, REF_2);

  1918.                 vis_pack16(REF_0, DST_2);

  1919. 

  1920.                 vis_pack16(REF_2, DST_3);

  1921.                 vis_st64_2(DST_2, dest, 8);

  1922.                 dest += stride;

  1923.         } while (--height);

  1924. }

  1925. 

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

  1927.                              const int stride, int height)

  1928. {

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

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

  1931.         unsigned long off_plus_1 = off + 1;

  1932.         int stride_8 = stride + 8;

  1933. 

  1934.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1935. 

  1936.         ref = vis_alignaddr(ref);

  1937. 

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

  1939.         vis_fzero(ZERO);

  1940. 

  1941.         vis_ld64_2(ref, 8, TMP2);

  1942. 

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

  1944. 

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

  1946.         vis_faligndata(TMP0, TMP2, REF_S0);

  1947. 

  1948.         if (off != 0x7) {

  1949.                 vis_alignaddr_g0((void *)off_plus_1);

  1950.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1951.         } else {

  1952.                 vis_src1(TMP2, REF_S2);

  1953.         }

  1954. 

  1955.         height >>= 1;

  1956.         do {    /* 31 cycles */

  1957.                 vis_ld64_2(ref, stride, TMP0);

  1958.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  1959.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  1960. 

  1961.                 vis_ld64_2(ref, stride_8, TMP2);

  1962.                 ref += stride;

  1963.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1964.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  1965. 

  1966.                 vis_alignaddr_g0((void *)off);

  1967. 

  1968.                 vis_ld64_2(ref, stride, TMP4);

  1969.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1970. 

  1971.                 vis_ld64_2(ref, stride_8, TMP6);

  1972.                 ref += stride;

  1973. 

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

  1975.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1976. 

  1977.                 vis_ld64_2(dest, stride, DST_2);

  1978. 

  1979.                 if (off != 0x7) {

  1980.                         vis_alignaddr_g0((void *)off_plus_1);

  1981.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1982.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1983.                 } else {

  1984.                         vis_src1(TMP2, REF_S6);

  1985.                         vis_src1(TMP6, REF_S2);

  1986.                 }

  1987. 

  1988.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1989.                 vis_pmerge(ZERO, REF_S4, TMP22);

  1990. 

  1991.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1992.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  1993. 

  1994.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  1995.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  1996. 

  1997.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  1998.                 vis_padd16(TMP22, CONST_6, TMP22);

  1999. 

  2000.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  2001.                 vis_padd16(TMP24, CONST_6, TMP24);

  2002. 

  2003.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  2004.                 vis_padd16(TMP22, TMP26, TMP22);

  2005. 

  2006.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  2007.                 vis_padd16(TMP24, TMP28, TMP24);

  2008. 

  2009.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  2010.                 vis_padd16(TMP8, TMP22, TMP8);

  2011. 

  2012.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  2013.                 vis_padd16(TMP10, TMP24, TMP10);

  2014. 

  2015.                 vis_padd16(TMP8, TMP12, TMP8);

  2016. 

  2017.                 vis_padd16(TMP10, TMP14, TMP10);

  2018. 

  2019.                 vis_padd16(TMP8, TMP30, TMP8);

  2020. 

  2021.                 vis_padd16(TMP10, TMP32, TMP10);

  2022.                 vis_pack16(TMP8, DST_0);

  2023. 

  2024.                 vis_pack16(TMP10, DST_1);

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

  2026.                 dest += stride;

  2027. 

  2028.                 vis_padd16(REF_S4, TMP22, TMP12);

  2029. 

  2030.                 vis_padd16(REF_S6, TMP24, TMP14);

  2031. 

  2032.                 vis_padd16(TMP12, TMP26, TMP12);

  2033. 

  2034.                 vis_padd16(TMP14, TMP28, TMP14);

  2035. 

  2036.                 vis_padd16(TMP12, REF_0, TMP12);

  2037. 

  2038.                 vis_padd16(TMP14, REF_2, TMP14);

  2039.                 vis_pack16(TMP12, DST_2);

  2040. 

  2041.                 vis_pack16(TMP14, DST_3);

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

  2043.                 dest += stride;

  2044.         } while (--height);

  2045. }

  2046. 

  2047. /* End of rounding code */

  2048. 

  2049. /* Start of no rounding code */

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

  2051.  * motion comp code, which is:

  2052.  *

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

  2054.  *

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

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

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

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

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

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

  2061.  *

  2062.  *      fxor            f0,   f2, f10

  2063.  *      fand            f10,  f4, f10

  2064.  *      fmul8x16        f8,  f10, f10

  2065.  *      fand            f10,  f6, f10

  2066.  *      fand            f0,   f2, f12

  2067.  *      fpadd16         f12, f10, f10

  2068.  */

  2069. 

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

  2071.                                       const int stride, int height)

  2072. {

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

  2074. 

  2075.         ref = vis_alignaddr(ref);

  2076.         do {    /* 5 cycles */

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

  2078. 

  2079.                 vis_ld64_2(ref, 8, TMP2);

  2080. 

  2081.                 vis_ld64_2(ref, 16, TMP4);

  2082.                 ref += stride;

  2083. 

  2084.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2086. 

  2087.                 vis_faligndata(TMP2, TMP4, REF_2);

  2088.                 vis_st64_2(REF_2, dest, 8);

  2089.                 dest += stride;

  2090.         } while (--height);

  2091. }

  2092. 

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

  2094.                             const int stride, int height)

  2095. {

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

  2097. 

  2098.         ref = vis_alignaddr(ref);

  2099.         do {    /* 4 cycles */

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

  2101. 

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

  2103.                 ref += stride;

  2104. 

  2105.                 /* stall */

  2106. 

  2107.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2109.                 dest += stride;

  2110.         } while (--height);

  2111. }

  2112. 

  2113. 

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

  2115.                              const int stride, int height)

  2116. {

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

  2118.         int stride_8 = stride + 8;

  2119. 

  2120.         ref = vis_alignaddr(ref);

  2121. 

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

  2123. 

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

  2125. 

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

  2127. 

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

  2129. 

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

  2131. 

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

  2133.         vis_faligndata(TMP0, TMP2, REF_0);

  2134. 

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

  2136.         vis_faligndata(TMP2, TMP4, REF_2);

  2137. 

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

  2139. 

  2140.         ref += stride;

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

  2142. 

  2143.         do {    /* 24 cycles */

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

  2145.                 vis_xor(DST_0, REF_0, TMP6);

  2146. 

  2147.                 vis_ld64_2(ref, 8, TMP2);

  2148.                 vis_and(TMP6, MASK_fe, TMP6);

  2149. 

  2150.                 vis_ld64_2(ref, 16, TMP4);

  2151.                 ref += stride;

  2152.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2153.                 vis_xor(DST_2, REF_2, TMP8);

  2154. 

  2155.                 vis_and(TMP8, MASK_fe, TMP8);

  2156. 

  2157.                 vis_and(DST_0, REF_0, TMP10);

  2158.                 vis_ld64_2(dest, stride, DST_0);

  2159.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2160. 

  2161.                 vis_and(DST_2, REF_2, TMP12);

  2162.                 vis_ld64_2(dest, stride_8, DST_2);

  2163. 

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

  2165.                 vis_and(TMP6, MASK_7f, TMP6);

  2166. 

  2167.                 vis_and(TMP8, MASK_7f, TMP8);

  2168. 

  2169.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2171. 

  2172.                 vis_padd16(TMP12, TMP8, TMP8);

  2173.                 vis_st64_2(TMP8, dest, 8);

  2174. 

  2175.                 dest += stride;

  2176.                 vis_ld64_2(ref, 8, TMP16);

  2177.                 vis_faligndata(TMP0, TMP2, REF_0);

  2178. 

  2179.                 vis_ld64_2(ref, 16, TMP18);

  2180.                 vis_faligndata(TMP2, TMP4, REF_2);

  2181.                 ref += stride;

  2182. 

  2183.                 vis_xor(DST_0, REF_0, TMP20);

  2184. 

  2185.                 vis_and(TMP20, MASK_fe, TMP20);

  2186. 

  2187.                 vis_xor(DST_2, REF_2, TMP22);

  2188.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  2189. 

  2190.                 vis_and(TMP22, MASK_fe, TMP22);

  2191. 

  2192.                 vis_and(DST_0, REF_0, TMP24);

  2193.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  2194. 

  2195.                 vis_and(DST_2, REF_2, TMP26);

  2196. 

  2197.                 vis_ld64_2(dest, stride, DST_0);

  2198.                 vis_faligndata(TMP14, TMP16, REF_0);

  2199. 

  2200.                 vis_ld64_2(dest, stride_8, DST_2);

  2201.                 vis_faligndata(TMP16, TMP18, REF_2);

  2202. 

  2203.                 vis_and(TMP20, MASK_7f, TMP20);

  2204. 

  2205.                 vis_and(TMP22, MASK_7f, TMP22);

  2206. 

  2207.                 vis_padd16(TMP24, TMP20, TMP20);

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

  2209. 

  2210.                 vis_padd16(TMP26, TMP22, TMP22);

  2211.                 vis_st64_2(TMP22, dest, 8);

  2212.                 dest += stride;

  2213.         } while (--height);

  2214. 

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

  2216.         vis_xor(DST_0, REF_0, TMP6);

  2217. 

  2218.         vis_ld64_2(ref, 8, TMP2);

  2219.         vis_and(TMP6, MASK_fe, TMP6);

  2220. 

  2221.         vis_ld64_2(ref, 16, TMP4);

  2222.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2223.         vis_xor(DST_2, REF_2, TMP8);

  2224. 

  2225.         vis_and(TMP8, MASK_fe, TMP8);

  2226. 

  2227.         vis_and(DST_0, REF_0, TMP10);

  2228.         vis_ld64_2(dest, stride, DST_0);

  2229.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2230. 

  2231.         vis_and(DST_2, REF_2, TMP12);

  2232.         vis_ld64_2(dest, stride_8, DST_2);

  2233. 

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

  2235.         vis_and(TMP6, MASK_7f, TMP6);

  2236. 

  2237.         vis_and(TMP8, MASK_7f, TMP8);

  2238. 

  2239.         vis_padd16(TMP10, TMP6, TMP6);

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

  2241. 

  2242.         vis_padd16(TMP12, TMP8, TMP8);

  2243.         vis_st64_2(TMP8, dest, 8);

  2244. 

  2245.         dest += stride;

  2246.         vis_faligndata(TMP0, TMP2, REF_0);

  2247. 

  2248.         vis_faligndata(TMP2, TMP4, REF_2);

  2249. 

  2250.         vis_xor(DST_0, REF_0, TMP20);

  2251. 

  2252.         vis_and(TMP20, MASK_fe, TMP20);

  2253. 

  2254.         vis_xor(DST_2, REF_2, TMP22);

  2255.         vis_mul8x16(CONST_128, TMP20, TMP20);

  2256. 

  2257.         vis_and(TMP22, MASK_fe, TMP22);

  2258. 

  2259.         vis_and(DST_0, REF_0, TMP24);

  2260.         vis_mul8x16(CONST_128, TMP22, TMP22);

  2261. 

  2262.         vis_and(DST_2, REF_2, TMP26);

  2263. 

  2264.         vis_and(TMP20, MASK_7f, TMP20);

  2265. 

  2266.         vis_and(TMP22, MASK_7f, TMP22);

  2267. 

  2268.         vis_padd16(TMP24, TMP20, TMP20);

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

  2270. 

  2271.         vis_padd16(TMP26, TMP22, TMP22);

  2272.         vis_st64_2(TMP22, dest, 8);

  2273. }

  2274. 

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

  2276.                             const int stride, int height)

  2277. {

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

  2279. 

  2280.         ref = vis_alignaddr(ref);

  2281. 

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

  2283. 

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

  2285. 

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

  2287. 

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

  2289. 

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

  2291.         vis_faligndata(TMP0, TMP2, REF_0);

  2292. 

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

  2294. 

  2295.         ref += stride;

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

  2297. 

  2298.         do {    /* 12 cycles */

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

  2300.                 vis_xor(DST_0, REF_0, TMP4);

  2301. 

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

  2303.                 vis_and(TMP4, MASK_fe, TMP4);

  2304. 

  2305.                 vis_and(DST_0, REF_0, TMP6);

  2306.                 vis_ld64_2(dest, stride, DST_0);

  2307.                 ref += stride;

  2308.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2309. 

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

  2311.                 vis_faligndata(TMP0, TMP2, REF_0);

  2312. 

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

  2314.                 vis_xor(DST_0, REF_0, TMP0);

  2315.                 ref += stride;

  2316. 

  2317.                 vis_and(TMP0, MASK_fe, TMP0);

  2318. 

  2319.                 vis_and(TMP4, MASK_7f, TMP4);

  2320. 

  2321.                 vis_padd16(TMP6, TMP4, TMP4);

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

  2323.                 dest += stride;

  2324.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  2325. 

  2326.                 vis_and(DST_0, REF_0, TMP6);

  2327.                 vis_ld64_2(dest, stride, DST_0);

  2328. 

  2329.                 vis_faligndata(TMP12, TMP2, REF_0);

  2330. 

  2331.                 vis_and(TMP0, MASK_7f, TMP0);

  2332. 

  2333.                 vis_padd16(TMP6, TMP0, TMP4);

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

  2335.                 dest += stride;

  2336.         } while (--height);

  2337. 

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

  2339.         vis_xor(DST_0, REF_0, TMP4);

  2340. 

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

  2342.         vis_and(TMP4, MASK_fe, TMP4);

  2343. 

  2344.         vis_and(DST_0, REF_0, TMP6);

  2345.         vis_ld64_2(dest, stride, DST_0);

  2346.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2347. 

  2348.         vis_faligndata(TMP0, TMP2, REF_0);

  2349. 

  2350.         vis_xor(DST_0, REF_0, TMP0);

  2351. 

  2352.         vis_and(TMP0, MASK_fe, TMP0);

  2353. 

  2354.         vis_and(TMP4, MASK_7f, TMP4);

  2355. 

  2356.         vis_padd16(TMP6, TMP4, TMP4);

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

  2358.         dest += stride;

  2359.         vis_mul8x16(CONST_128, TMP0, TMP0);

  2360. 

  2361.         vis_and(DST_0, REF_0, TMP6);

  2362. 

  2363.         vis_and(TMP0, MASK_7f, TMP0);

  2364. 

  2365.         vis_padd16(TMP6, TMP0, TMP4);

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

  2367. }

  2368. 

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

  2370.                              const int stride, int height)

  2371. {

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

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

  2374.         unsigned long off_plus_1 = off + 1;

  2375. 

  2376.         ref = vis_alignaddr(ref);

  2377. 

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

  2379. 

  2380.         vis_ld64_2(ref, 8,  TMP2);

  2381. 

  2382.         vis_ld64_2(ref, 16, TMP4);

  2383. 

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

  2385. 

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

  2387.         vis_faligndata(TMP0, TMP2, REF_0);

  2388. 

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

  2390.         vis_faligndata(TMP2, TMP4, REF_4);

  2391. 

  2392.         if (off != 0x7) {

  2393.                 vis_alignaddr_g0((void *)off_plus_1);

  2394.                 vis_faligndata(TMP0, TMP2, REF_2);

  2395.                 vis_faligndata(TMP2, TMP4, REF_6);

  2396.         } else {

  2397.                 vis_src1(TMP2, REF_2);

  2398.                 vis_src1(TMP4, REF_6);

  2399.         }

  2400. 

  2401.         ref += stride;

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

  2403. 

  2404.         do {    /* 34 cycles */

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

  2406.                 vis_xor(REF_0, REF_2, TMP6);

  2407. 

  2408.                 vis_ld64_2(ref, 8,  TMP2);

  2409.                 vis_xor(REF_4, REF_6, TMP8);

  2410. 

  2411.                 vis_ld64_2(ref, 16, TMP4);

  2412.                 vis_and(TMP6, MASK_fe, TMP6);

  2413.                 ref += stride;

  2414. 

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

  2416.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2417.                 vis_and(TMP8, MASK_fe, TMP8);

  2418. 

  2419.                 vis_ld64_2(ref, 8,  TMP16);

  2420.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2421.                 vis_and(REF_0, REF_2, TMP10);

  2422. 

  2423.                 vis_ld64_2(ref, 16, TMP18);

  2424.                 ref += stride;

  2425.                 vis_and(REF_4, REF_6, TMP12);

  2426. 

  2427.                 vis_alignaddr_g0((void *)off);

  2428. 

  2429.                 vis_faligndata(TMP0, TMP2, REF_0);

  2430. 

  2431.                 vis_faligndata(TMP2, TMP4, REF_4);

  2432. 

  2433.                 if (off != 0x7) {

  2434.                         vis_alignaddr_g0((void *)off_plus_1);

  2435.                         vis_faligndata(TMP0, TMP2, REF_2);

  2436.                         vis_faligndata(TMP2, TMP4, REF_6);

  2437.                 } else {

  2438.                         vis_src1(TMP2, REF_2);

  2439.                         vis_src1(TMP4, REF_6);

  2440.                 }

  2441. 

  2442.                 vis_and(TMP6, MASK_7f, TMP6);

  2443. 

  2444.                 vis_and(TMP8, MASK_7f, TMP8);

  2445. 

  2446.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2448. 

  2449.                 vis_padd16(TMP12, TMP8, TMP8);

  2450.                 vis_st64_2(TMP8, dest, 8);

  2451.                 dest += stride;

  2452. 

  2453.                 vis_xor(REF_0, REF_2, TMP6);

  2454. 

  2455.                 vis_xor(REF_4, REF_6, TMP8);

  2456. 

  2457.                 vis_and(TMP6, MASK_fe, TMP6);

  2458. 

  2459.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2460.                 vis_and(TMP8, MASK_fe, TMP8);

  2461. 

  2462.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2463.                 vis_and(REF_0, REF_2, TMP10);

  2464. 

  2465.                 vis_and(REF_4, REF_6, TMP12);

  2466. 

  2467.                 vis_alignaddr_g0((void *)off);

  2468. 

  2469.                 vis_faligndata(TMP14, TMP16, REF_0);

  2470. 

  2471.                 vis_faligndata(TMP16, TMP18, REF_4);

  2472. 

  2473.                 if (off != 0x7) {

  2474.                         vis_alignaddr_g0((void *)off_plus_1);

  2475.                         vis_faligndata(TMP14, TMP16, REF_2);

  2476.                         vis_faligndata(TMP16, TMP18, REF_6);

  2477.                 } else {

  2478.                         vis_src1(TMP16, REF_2);

  2479.                         vis_src1(TMP18, REF_6);

  2480.                 }

  2481. 

  2482.                 vis_and(TMP6, MASK_7f, TMP6);

  2483. 

  2484.                 vis_and(TMP8, MASK_7f, TMP8);

  2485. 

  2486.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2488. 

  2489.                 vis_padd16(TMP12, TMP8, TMP8);

  2490.                 vis_st64_2(TMP8, dest, 8);

  2491.                 dest += stride;

  2492.         } while (--height);

  2493. 

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

  2495.         vis_xor(REF_0, REF_2, TMP6);

  2496. 

  2497.         vis_ld64_2(ref, 8,  TMP2);

  2498.         vis_xor(REF_4, REF_6, TMP8);

  2499. 

  2500.         vis_ld64_2(ref, 16, TMP4);

  2501.         vis_and(TMP6, MASK_fe, TMP6);

  2502. 

  2503.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2504.         vis_and(TMP8, MASK_fe, TMP8);

  2505. 

  2506.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2507.         vis_and(REF_0, REF_2, TMP10);

  2508. 

  2509.         vis_and(REF_4, REF_6, TMP12);

  2510. 

  2511.         vis_alignaddr_g0((void *)off);

  2512. 

  2513.         vis_faligndata(TMP0, TMP2, REF_0);

  2514. 

  2515.         vis_faligndata(TMP2, TMP4, REF_4);

  2516. 

  2517.         if (off != 0x7) {

  2518.                 vis_alignaddr_g0((void *)off_plus_1);

  2519.                 vis_faligndata(TMP0, TMP2, REF_2);

  2520.                 vis_faligndata(TMP2, TMP4, REF_6);

  2521.         } else {

  2522.                 vis_src1(TMP2, REF_2);

  2523.                 vis_src1(TMP4, REF_6);

  2524.         }

  2525. 

  2526.         vis_and(TMP6, MASK_7f, TMP6);

  2527. 

  2528.         vis_and(TMP8, MASK_7f, TMP8);

  2529. 

  2530.         vis_padd16(TMP10, TMP6, TMP6);

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

  2532. 

  2533.         vis_padd16(TMP12, TMP8, TMP8);

  2534.         vis_st64_2(TMP8, dest, 8);

  2535.         dest += stride;

  2536. 

  2537.         vis_xor(REF_0, REF_2, TMP6);

  2538. 

  2539.         vis_xor(REF_4, REF_6, TMP8);

  2540. 

  2541.         vis_and(TMP6, MASK_fe, TMP6);

  2542. 

  2543.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2544.         vis_and(TMP8, MASK_fe, TMP8);

  2545. 

  2546.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2547.         vis_and(REF_0, REF_2, TMP10);

  2548. 

  2549.         vis_and(REF_4, REF_6, TMP12);

  2550. 

  2551.         vis_and(TMP6, MASK_7f, TMP6);

  2552. 

  2553.         vis_and(TMP8, MASK_7f, TMP8);

  2554. 

  2555.         vis_padd16(TMP10, TMP6, TMP6);

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

  2557. 

  2558.         vis_padd16(TMP12, TMP8, TMP8);

  2559.         vis_st64_2(TMP8, dest, 8);

  2560. }

  2561. 

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

  2563.                             const int stride, int height)

  2564. {

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

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

  2567.         unsigned long off_plus_1 = off + 1;

  2568. 

  2569.         ref = vis_alignaddr(ref);

  2570. 

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

  2572. 

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

  2574. 

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

  2576. 

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

  2578. 

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

  2580.         vis_faligndata(TMP0, TMP2, REF_0);

  2581. 

  2582.         if (off != 0x7) {

  2583.                 vis_alignaddr_g0((void *)off_plus_1);

  2584.                 vis_faligndata(TMP0, TMP2, REF_2);

  2585.         } else {

  2586.                 vis_src1(TMP2, REF_2);

  2587.         }

  2588. 

  2589.         ref += stride;

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

  2591. 

  2592.         do {    /* 20 cycles */

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

  2594.                 vis_xor(REF_0, REF_2, TMP4);

  2595. 

  2596.                 vis_ld64_2(ref, 8, TMP2);

  2597.                 vis_and(TMP4, MASK_fe, TMP4);

  2598.                 ref += stride;

  2599. 

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

  2601.                 vis_and(REF_0, REF_2, TMP6);

  2602.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2603. 

  2604.                 vis_alignaddr_g0((void *)off);

  2605. 

  2606.                 vis_ld64_2(ref, 8, TMP10);

  2607.                 ref += stride;

  2608.                 vis_faligndata(TMP0, TMP2, REF_0);

  2609. 

  2610.                 if (off != 0x7) {

  2611.                         vis_alignaddr_g0((void *)off_plus_1);

  2612.                         vis_faligndata(TMP0, TMP2, REF_2);

  2613.                 } else {

  2614.                         vis_src1(TMP2, REF_2);

  2615.                 }

  2616. 

  2617.                 vis_and(TMP4, MASK_7f, TMP4);

  2618. 

  2619.                 vis_padd16(TMP6, TMP4, DST_0);

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

  2621.                 dest += stride;

  2622. 

  2623.                 vis_xor(REF_0, REF_2, TMP12);

  2624. 

  2625.                 vis_and(TMP12, MASK_fe, TMP12);

  2626. 

  2627.                 vis_and(REF_0, REF_2, TMP14);

  2628.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2629. 

  2630.                 vis_alignaddr_g0((void *)off);

  2631.                 vis_faligndata(TMP8, TMP10, REF_0);

  2632.                 if (off != 0x7) {

  2633.                         vis_alignaddr_g0((void *)off_plus_1);

  2634.                         vis_faligndata(TMP8, TMP10, REF_2);

  2635.                 } else {

  2636.                         vis_src1(TMP10, REF_2);

  2637.                 }

  2638. 

  2639.                 vis_and(TMP12, MASK_7f, TMP12);

  2640. 

  2641.                 vis_padd16(TMP14, TMP12, DST_0);

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

  2643.                 dest += stride;

  2644.         } while (--height);

  2645. 

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

  2647.         vis_xor(REF_0, REF_2, TMP4);

  2648. 

  2649.         vis_ld64_2(ref, 8, TMP2);

  2650.         vis_and(TMP4, MASK_fe, TMP4);

  2651. 

  2652.         vis_and(REF_0, REF_2, TMP6);

  2653.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2654. 

  2655.         vis_alignaddr_g0((void *)off);

  2656. 

  2657.         vis_faligndata(TMP0, TMP2, REF_0);

  2658. 

  2659.         if (off != 0x7) {

  2660.                 vis_alignaddr_g0((void *)off_plus_1);

  2661.                 vis_faligndata(TMP0, TMP2, REF_2);

  2662.         } else {

  2663.                 vis_src1(TMP2, REF_2);

  2664.         }

  2665. 

  2666.         vis_and(TMP4, MASK_7f, TMP4);

  2667. 

  2668.         vis_padd16(TMP6, TMP4, DST_0);

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

  2670.         dest += stride;

  2671. 

  2672.         vis_xor(REF_0, REF_2, TMP12);

  2673. 

  2674.         vis_and(TMP12, MASK_fe, TMP12);

  2675. 

  2676.         vis_and(REF_0, REF_2, TMP14);

  2677.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2678. 

  2679.         vis_and(TMP12, MASK_7f, TMP12);

  2680. 

  2681.         vis_padd16(TMP14, TMP12, DST_0);

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

  2683.         dest += stride;

  2684. }

  2685. 

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

  2687.                              const int stride, int height)

  2688. {

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

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

  2691.         unsigned long off_plus_1 = off + 1;

  2692. 

  2693.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2694. 

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

  2696.         vis_fzero(ZERO);

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

  2698. 

  2699.         ref = vis_alignaddr(ref);

  2700.         do {    /* 26 cycles */

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

  2702. 

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

  2704. 

  2705.                 vis_alignaddr_g0((void *)off);

  2706. 

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

  2708. 

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

  2710.                 vis_faligndata(TMP0, TMP2, REF_0);

  2711. 

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

  2713.                 vis_faligndata(TMP2, TMP4, REF_4);

  2714. 

  2715.                 if (off != 0x7) {

  2716.                         vis_alignaddr_g0((void *)off_plus_1);

  2717.                         vis_faligndata(TMP0, TMP2, REF_2);

  2718.                         vis_faligndata(TMP2, TMP4, REF_6);

  2719.                 } else {

  2720.                         vis_src1(TMP2, REF_2);

  2721.                         vis_src1(TMP4, REF_6);

  2722.                 }

  2723. 

  2724.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  2725. 

  2726.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2727.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2728. 

  2729.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  2730. 

  2731.                 vis_padd16(TMP0, TMP4, TMP0);

  2732. 

  2733.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  2734.                 vis_padd16(TMP2, TMP6, TMP2);

  2735. 

  2736.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  2737. 

  2738.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  2739. 

  2740.                 vis_padd16(TMP0, TMP4, TMP0);

  2741.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2742. 

  2743.                 vis_padd16(TMP2, TMP6, TMP2);

  2744.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  2745. 

  2746.                 vis_padd16(TMP0, CONST_3, TMP8);

  2747.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  2748. 

  2749.                 vis_padd16(TMP2, CONST_3, TMP10);

  2750.                 vis_pack16(TMP8, DST_0);

  2751. 

  2752.                 vis_pack16(TMP10, DST_1);

  2753.                 vis_padd16(TMP16, TMP12, TMP0);

  2754. 

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

  2756.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  2757.                 vis_padd16(TMP18, TMP14, TMP2);

  2758. 

  2759.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  2760.                 vis_padd16(TMP0, CONST_3, TMP0);

  2761. 

  2762.                 vis_padd16(TMP2, CONST_3, TMP2);

  2763. 

  2764.                 vis_padd16(TMP0, TMP4, TMP0);

  2765. 

  2766.                 vis_padd16(TMP2, TMP6, TMP2);

  2767.                 vis_pack16(TMP0, DST_2);

  2768. 

  2769.                 vis_pack16(TMP2, DST_3);

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

  2771. 

  2772.                 ref += stride;

  2773.                 dest += stride;

  2774.         } while (--height);

  2775. }

  2776. 

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

  2778.                             const int stride, int height)

  2779. {

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

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

  2782.         unsigned long off_plus_1 = off + 1;

  2783.         int stride_times_2 = stride << 1;

  2784. 

  2785.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2786. 

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

  2788.         vis_fzero(ZERO);

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

  2790. 

  2791.         ref = vis_alignaddr(ref);

  2792.         height >>= 2;

  2793.         do {    /* 47 cycles */

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

  2795. 

  2796.                 vis_ld64_2(ref, 8, TMP2);

  2797.                 ref += stride;

  2798. 

  2799.                 vis_alignaddr_g0((void *)off);

  2800. 

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

  2802.                 vis_faligndata(TMP0, TMP2, REF_0);

  2803. 

  2804.                 vis_ld64_2(ref, 8, TMP6);

  2805.                 ref += stride;

  2806. 

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

  2808. 

  2809.                 vis_ld64_2(ref, 8, TMP10);

  2810.                 ref += stride;

  2811.                 vis_faligndata(TMP4, TMP6, REF_4);

  2812. 

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

  2814. 

  2815.                 vis_ld64_2(ref, 8, TMP14);

  2816.                 ref += stride;

  2817.                 vis_faligndata(TMP8, TMP10, REF_S0);

  2818. 

  2819.                 vis_faligndata(TMP12, TMP14, REF_S4);

  2820. 

  2821.                 if (off != 0x7) {

  2822.                         vis_alignaddr_g0((void *)off_plus_1);

  2823. 

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

  2825.                         vis_faligndata(TMP0, TMP2, REF_2);

  2826. 

  2827.                         vis_ld64_2(dest, stride, DST_2);

  2828.                         vis_faligndata(TMP4, TMP6, REF_6);

  2829. 

  2830.                         vis_faligndata(TMP8, TMP10, REF_S2);

  2831. 

  2832.                         vis_faligndata(TMP12, TMP14, REF_S6);

  2833.                 } else {

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

  2835.                         vis_src1(TMP2, REF_2);

  2836. 

  2837.                         vis_ld64_2(dest, stride, DST_2);

  2838.                         vis_src1(TMP6, REF_6);

  2839. 

  2840.                         vis_src1(TMP10, REF_S2);

  2841. 

  2842.                         vis_src1(TMP14, REF_S6);

  2843.                 }

  2844. 

  2845.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  2846.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2847. 

  2848.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2849.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  2850. 

  2851.                 vis_padd16(TMP0, CONST_3, TMP0);

  2852.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  2853. 

  2854.                 vis_padd16(TMP2, CONST_3, TMP2);

  2855.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  2856. 

  2857.                 vis_padd16(TMP0, TMP4, TMP0);

  2858.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  2859. 

  2860.                 vis_padd16(TMP2, TMP6, TMP2);

  2861.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  2862. 

  2863.                 vis_padd16(TMP0, TMP16, TMP0);

  2864.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  2865. 

  2866.                 vis_padd16(TMP2, TMP18, TMP2);

  2867.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2868. 

  2869.                 vis_padd16(TMP8, CONST_3, TMP8);

  2870.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  2871. 

  2872.                 vis_padd16(TMP8, TMP12, TMP8);

  2873.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  2874. 

  2875.                 vis_padd16(TMP10, TMP14, TMP10);

  2876.                 vis_pack16(TMP0, DST_0);

  2877. 

  2878.                 vis_pack16(TMP2, DST_1);

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

  2880.                 dest += stride;

  2881.                 vis_padd16(TMP10, CONST_3, TMP10);

  2882. 

  2883.                 vis_ld64_2(dest, stride, DST_0);

  2884.                 vis_padd16(TMP8, TMP16, TMP8);

  2885. 

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

  2887.                 vis_padd16(TMP10, TMP18, TMP10);

  2888.                 vis_pack16(TMP8, DST_2);

  2889. 

  2890.                 vis_pack16(TMP10, DST_3);

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

  2892.                 dest += stride;

  2893. 

  2894.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  2895.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  2896. 

  2897.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  2898.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  2899. 

  2900.                 vis_padd16(TMP0, CONST_3, TMP0);

  2901.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  2902. 

  2903.                 vis_padd16(TMP2, CONST_3, TMP2);

  2904.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  2905. 

  2906.                 vis_padd16(TMP0, TMP24, TMP0);

  2907.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  2908. 

  2909.                 vis_padd16(TMP2, TMP6, TMP2);

  2910.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  2911. 

  2912.                 vis_padd16(TMP8, CONST_3, TMP8);

  2913.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  2914. 

  2915.                 vis_padd16(TMP10, CONST_3, TMP10);

  2916.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  2917. 

  2918.                 vis_padd16(TMP8, TMP12, TMP8);

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

  2920. 

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

  2922.                 vis_padd16(TMP0, TMP16, TMP0);

  2923. 

  2924.                 vis_padd16(TMP2, TMP18, TMP2);

  2925.                 vis_pack16(TMP0, DST_0);

  2926. 

  2927.                 vis_padd16(TMP10, TMP14, TMP10);

  2928.                 vis_pack16(TMP2, DST_1);

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

  2930.                 dest += stride;

  2931. 

  2932.                 vis_padd16(TMP8, TMP20, TMP8);

  2933. 

  2934.                 vis_padd16(TMP10, TMP22, TMP10);

  2935.                 vis_pack16(TMP8, DST_2);

  2936. 

  2937.                 vis_pack16(TMP10, DST_3);

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

  2939.                 dest += stride;

  2940.         } while (--height);

  2941. }

  2942. 

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

  2944.                              const int stride, int height)

  2945. {

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

  2947. 

  2948.         ref = vis_alignaddr(ref);

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

  2950. 

  2951.         vis_ld64_2(ref, 8, TMP2);

  2952. 

  2953.         vis_ld64_2(ref, 16, TMP4);

  2954.         ref += stride;

  2955. 

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

  2957.         vis_faligndata(TMP0, TMP2, REF_0);

  2958. 

  2959.         vis_ld64_2(ref, 8, TMP8);

  2960.         vis_faligndata(TMP2, TMP4, REF_4);

  2961. 

  2962.         vis_ld64_2(ref, 16, TMP10);

  2963.         ref += stride;

  2964. 

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

  2966.         vis_faligndata(TMP6, TMP8, REF_2);

  2967. 

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

  2969.         vis_faligndata(TMP8, TMP10, REF_6);

  2970. 

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

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

  2973.         do {    /* 24 cycles */

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

  2975.                 vis_xor(REF_0, REF_2, TMP12);

  2976. 

  2977.                 vis_ld64_2(ref, 8, TMP2);

  2978.                 vis_xor(REF_4, REF_6, TMP16);

  2979. 

  2980.                 vis_ld64_2(ref, 16, TMP4);

  2981.                 ref += stride;

  2982.                 vis_and(REF_0, REF_2, TMP14);

  2983. 

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

  2985.                 vis_and(REF_4, REF_6, TMP18);

  2986. 

  2987.                 vis_ld64_2(ref, 8, TMP8);

  2988.                 vis_faligndata(TMP0, TMP2, REF_0);

  2989. 

  2990.                 vis_ld64_2(ref, 16, TMP10);

  2991.                 ref += stride;

  2992.                 vis_faligndata(TMP2, TMP4, REF_4);

  2993. 

  2994.                 vis_and(TMP12, MASK_fe, TMP12);

  2995. 

  2996.                 vis_and(TMP16, MASK_fe, TMP16);

  2997.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2998. 

  2999.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  3000.                 vis_xor(REF_0, REF_2, TMP0);

  3001. 

  3002.                 vis_xor(REF_4, REF_6, TMP2);

  3003. 

  3004.                 vis_and(REF_0, REF_2, TMP20);

  3005. 

  3006.                 vis_and(TMP12, MASK_7f, TMP12);

  3007. 

  3008.                 vis_and(TMP16, MASK_7f, TMP16);

  3009. 

  3010.                 vis_padd16(TMP14, TMP12, TMP12);

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

  3012. 

  3013.                 vis_padd16(TMP18, TMP16, TMP16);

  3014.                 vis_st64_2(TMP16, dest, 8);

  3015.                 dest += stride;

  3016. 

  3017.                 vis_and(REF_4, REF_6, TMP18);

  3018. 

  3019.                 vis_and(TMP0, MASK_fe, TMP0);

  3020. 

  3021.                 vis_and(TMP2, MASK_fe, TMP2);

  3022.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  3023. 

  3024.                 vis_faligndata(TMP6, TMP8, REF_2);

  3025.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  3026. 

  3027.                 vis_faligndata(TMP8, TMP10, REF_6);

  3028. 

  3029.                 vis_and(TMP0, MASK_7f, TMP0);

  3030. 

  3031.                 vis_and(TMP2, MASK_7f, TMP2);

  3032. 

  3033.                 vis_padd16(TMP20, TMP0, TMP0);

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

  3035. 

  3036.                 vis_padd16(TMP18, TMP2, TMP2);

  3037.                 vis_st64_2(TMP2, dest, 8);

  3038.                 dest += stride;

  3039.         } while (--height);

  3040. 

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

  3042.         vis_xor(REF_0, REF_2, TMP12);

  3043. 

  3044.         vis_ld64_2(ref, 8, TMP2);

  3045.         vis_xor(REF_4, REF_6, TMP16);

  3046. 

  3047.         vis_ld64_2(ref, 16, TMP4);

  3048.         vis_and(REF_0, REF_2, TMP14);

  3049. 

  3050.         vis_and(REF_4, REF_6, TMP18);

  3051. 

  3052.         vis_faligndata(TMP0, TMP2, REF_0);

  3053. 

  3054.         vis_faligndata(TMP2, TMP4, REF_4);

  3055. 

  3056.         vis_and(TMP12, MASK_fe, TMP12);

  3057. 

  3058.         vis_and(TMP16, MASK_fe, TMP16);

  3059.         vis_mul8x16(CONST_128, TMP12, TMP12);

  3060. 

  3061.         vis_mul8x16(CONST_128, TMP16, TMP16);

  3062.         vis_xor(REF_0, REF_2, TMP0);

  3063. 

  3064.         vis_xor(REF_4, REF_6, TMP2);

  3065. 

  3066.         vis_and(REF_0, REF_2, TMP20);

  3067. 

  3068.         vis_and(TMP12, MASK_7f, TMP12);

  3069. 

  3070.         vis_and(TMP16, MASK_7f, TMP16);

  3071. 

  3072.         vis_padd16(TMP14, TMP12, TMP12);

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

  3074. 

  3075.         vis_padd16(TMP18, TMP16, TMP16);

  3076.         vis_st64_2(TMP16, dest, 8);

  3077.         dest += stride;

  3078. 

  3079.         vis_and(REF_4, REF_6, TMP18);

  3080. 

  3081.         vis_and(TMP0, MASK_fe, TMP0);

  3082. 

  3083.         vis_and(TMP2, MASK_fe, TMP2);

  3084.         vis_mul8x16(CONST_128, TMP0, TMP0);

  3085. 

  3086.         vis_mul8x16(CONST_128, TMP2, TMP2);

  3087. 

  3088.         vis_and(TMP0, MASK_7f, TMP0);

  3089. 

  3090.         vis_and(TMP2, MASK_7f, TMP2);

  3091. 

  3092.         vis_padd16(TMP20, TMP0, TMP0);

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

  3094. 

  3095.         vis_padd16(TMP18, TMP2, TMP2);

  3096.         vis_st64_2(TMP2, dest, 8);

  3097. }

  3098. 

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

  3100.                             const int stride, int height)

  3101. {

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

  3103. 

  3104.         ref = vis_alignaddr(ref);

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

  3106. 

  3107.         vis_ld64_2(ref, 8, TMP2);

  3108.         ref += stride;

  3109. 

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

  3111. 

  3112.         vis_ld64_2(ref, 8, TMP6);

  3113.         ref += stride;

  3114. 

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

  3116.         vis_faligndata(TMP0, TMP2, REF_0);

  3117. 

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

  3119.         vis_faligndata(TMP4, TMP6, REF_2);

  3120. 

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

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

  3123.         do {    /* 12 cycles */

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

  3125.                 vis_xor(REF_0, REF_2, TMP4);

  3126. 

  3127.                 vis_ld64_2(ref, 8, TMP2);

  3128.                 ref += stride;

  3129.                 vis_and(TMP4, MASK_fe, TMP4);

  3130. 

  3131.                 vis_and(REF_0, REF_2, TMP6);

  3132.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  3133. 

  3134.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  3136. 

  3137.                 vis_ld64_2(ref, 8, TMP2);

  3138.                 ref += stride;

  3139.                 vis_xor(REF_0, REF_2, TMP12);

  3140. 

  3141.                 vis_and(TMP4, MASK_7f, TMP4);

  3142. 

  3143.                 vis_and(TMP12, MASK_fe, TMP12);

  3144. 

  3145.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  3146.                 vis_and(REF_0, REF_2, TMP14);

  3147. 

  3148.                 vis_padd16(TMP6, TMP4, DST_0);

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

  3150.                 dest += stride;

  3151. 

  3152.                 vis_faligndata(TMP0, TMP2, REF_2);

  3153. 

  3154.                 vis_and(TMP12, MASK_7f, TMP12);

  3155. 

  3156.                 vis_padd16(TMP14, TMP12, DST_0);

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

  3158.                 dest += stride;

  3159.         } while (--height);

  3160. 

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

  3162.         vis_xor(REF_0, REF_2, TMP4);

  3163. 

  3164.         vis_ld64_2(ref, 8, TMP2);

  3165.         vis_and(TMP4, MASK_fe, TMP4);

  3166. 

  3167.         vis_and(REF_0, REF_2, TMP6);

  3168.         vis_mul8x16(CONST_128, TMP4, TMP4);

  3169. 

  3170.         vis_faligndata(TMP0, TMP2, REF_0);

  3171. 

  3172.         vis_xor(REF_0, REF_2, TMP12);

  3173. 

  3174.         vis_and(TMP4, MASK_7f, TMP4);

  3175. 

  3176.         vis_and(TMP12, MASK_fe, TMP12);

  3177. 

  3178.         vis_mul8x16(CONST_128, TMP12, TMP12);

  3179.         vis_and(REF_0, REF_2, TMP14);

  3180. 

  3181.         vis_padd16(TMP6, TMP4, DST_0);

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

  3183.         dest += stride;

  3184. 

  3185.         vis_and(TMP12, MASK_7f, TMP12);

  3186. 

  3187.         vis_padd16(TMP14, TMP12, DST_0);

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

  3189. }

  3190. 

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

  3192.                              const int stride, int height)

  3193. {

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

  3195.         int stride_8 = stride + 8;

  3196.         int stride_16 = stride + 16;

  3197. 

  3198.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3199. 

  3200.         ref = vis_alignaddr(ref);

  3201. 

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

  3203.         vis_fzero(ZERO);

  3204. 

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

  3206. 

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

  3208. 

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

  3210.         vis_faligndata(TMP0, TMP2, REF_2);

  3211. 

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

  3213.         vis_faligndata(TMP2, TMP4, REF_6);

  3214.         height >>= 1;

  3215. 

  3216.         do {    /* 31 cycles */

  3217.                 vis_ld64_2(ref, stride, TMP0);

  3218.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  3219.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  3220. 

  3221.                 vis_ld64_2(ref, stride_8, TMP2);

  3222.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  3223.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  3224. 

  3225.                 vis_ld64_2(ref, stride_16, TMP4);

  3226.                 ref += stride;

  3227. 

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

  3229.                 vis_faligndata(TMP0, TMP2, REF_0);

  3230. 

  3231.                 vis_ld64_2(dest, 8, DST_2);

  3232.                 vis_faligndata(TMP2, TMP4, REF_4);

  3233. 

  3234.                 vis_ld64_2(ref, stride, TMP6);

  3235.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  3236.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  3237. 

  3238.                 vis_ld64_2(ref, stride_8, TMP8);

  3239.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  3240. 

  3241.                 vis_ld64_2(ref, stride_16, TMP10);

  3242.                 ref += stride;

  3243. 

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

  3245.                 vis_faligndata(TMP6, TMP8, REF_2);

  3246.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3247. 

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

  3249.                 vis_faligndata(TMP8, TMP10, REF_6);

  3250.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  3251. 

  3252.                 vis_padd16(TMP0, CONST_3, TMP0);

  3253.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  3254. 

  3255.                 vis_padd16(TMP2, CONST_3, TMP2);

  3256.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  3257. 

  3258.                 vis_padd16(TMP4, CONST_3, TMP4);

  3259.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  3260. 

  3261.                 vis_padd16(TMP6, CONST_3, TMP6);

  3262. 

  3263.                 vis_padd16(TMP12, TMP20, TMP12);

  3264.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  3265. 

  3266.                 vis_padd16(TMP14, TMP22, TMP14);

  3267.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  3268. 

  3269.                 vis_padd16(TMP16, TMP24, TMP16);

  3270.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  3271. 

  3272.                 vis_padd16(TMP18, TMP26, TMP18);

  3273.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  3274. 

  3275.                 vis_padd16(TMP12, TMP0, TMP12);

  3276.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  3277. 

  3278.                 vis_padd16(TMP14, TMP2, TMP14);

  3279.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  3280. 

  3281.                 vis_padd16(TMP16, TMP4, TMP16);

  3282.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  3283. 

  3284.                 vis_padd16(TMP18, TMP6, TMP18);

  3285.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  3286. 

  3287.                 vis_pack16(TMP12, DST_0);

  3288.                 vis_padd16(TMP28, TMP0, TMP12);

  3289. 

  3290.                 vis_pack16(TMP14, DST_1);

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

  3292.                 vis_padd16(TMP30, TMP2, TMP14);

  3293. 

  3294.                 vis_pack16(TMP16, DST_2);

  3295.                 vis_padd16(REF_S4, TMP4, TMP16);

  3296. 

  3297.                 vis_pack16(TMP18, DST_3);

  3298.                 vis_st64_2(DST_2, dest, 8);

  3299.                 dest += stride;

  3300.                 vis_padd16(REF_S6, TMP6, TMP18);

  3301. 

  3302.                 vis_padd16(TMP12, TMP20, TMP12);

  3303. 

  3304.                 vis_padd16(TMP14, TMP22, TMP14);

  3305.                 vis_pack16(TMP12, DST_0);

  3306. 

  3307.                 vis_padd16(TMP16, TMP24, TMP16);

  3308.                 vis_pack16(TMP14, DST_1);

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

  3310. 

  3311.                 vis_padd16(TMP18, TMP26, TMP18);

  3312.                 vis_pack16(TMP16, DST_2);

  3313. 

  3314.                 vis_pack16(TMP18, DST_3);

  3315.                 vis_st64_2(DST_2, dest, 8);

  3316.                 dest += stride;

  3317.         } while (--height);

  3318. }

  3319. 

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

  3321.                             const int stride, int height)

  3322. {

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

  3324.         int stride_8 = stride + 8;

  3325. 

  3326.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3327. 

  3328.         ref = vis_alignaddr(ref);

  3329. 

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

  3331.         vis_fzero(ZERO);

  3332. 

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

  3334. 

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

  3336.         vis_faligndata(TMP0, TMP2, REF_2);

  3337. 

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

  3339. 

  3340.         height >>= 1;

  3341.         do {    /* 20 cycles */

  3342.                 vis_ld64_2(ref, stride, TMP0);

  3343.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  3344.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  3345. 

  3346.                 vis_ld64_2(ref, stride_8, TMP2);

  3347.                 ref += stride;

  3348. 

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

  3350. 

  3351.                 vis_ld64_2(dest, stride, DST_2);

  3352.                 vis_faligndata(TMP0, TMP2, REF_0);

  3353. 

  3354.                 vis_ld64_2(ref, stride, TMP4);

  3355.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  3356.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  3357. 

  3358.                 vis_ld64_2(ref, stride_8, TMP6);

  3359.                 ref += stride;

  3360.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  3361.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  3362. 

  3363.                 vis_padd16(TMP12, CONST_3, TMP12);

  3364.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  3365. 

  3366.                 vis_padd16(TMP14, CONST_3, TMP14);

  3367.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  3368. 

  3369.                 vis_faligndata(TMP4, TMP6, REF_2);

  3370. 

  3371.                 vis_padd16(TMP8, TMP12, TMP8);

  3372. 

  3373.                 vis_padd16(TMP10, TMP14, TMP10);

  3374.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  3375. 

  3376.                 vis_padd16(TMP8, TMP16, TMP0);

  3377.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  3378. 

  3379.                 vis_padd16(TMP10, TMP18, TMP2);

  3380.                 vis_pack16(TMP0, DST_0);

  3381. 

  3382.                 vis_pack16(TMP2, DST_1);

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

  3384.                 dest += stride;

  3385.                 vis_padd16(TMP12, TMP20, TMP12);

  3386. 

  3387.                 vis_padd16(TMP14, TMP22, TMP14);

  3388. 

  3389.                 vis_padd16(TMP12, TMP24, TMP0);

  3390. 

  3391.                 vis_padd16(TMP14, TMP26, TMP2);

  3392.                 vis_pack16(TMP0, DST_2);

  3393. 

  3394.                 vis_pack16(TMP2, DST_3);

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

  3396.                 dest += stride;

  3397.         } while (--height);

  3398. }

  3399. 

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

  3401.                                        const int stride, int height)

  3402. {

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

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

  3405.         unsigned long off_plus_1 = off + 1;

  3406.         int stride_8 = stride + 8;

  3407.         int stride_16 = stride + 16;

  3408. 

  3409.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3410. 

  3411.         ref = vis_alignaddr(ref);

  3412. 

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

  3414.         vis_fzero(ZERO);

  3415. 

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

  3417. 

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

  3419. 

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

  3421.         vis_faligndata(TMP0, TMP2, REF_S0);

  3422. 

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

  3424.         vis_faligndata(TMP2, TMP4, REF_S4);

  3425. 

  3426.         if (off != 0x7) {

  3427.                 vis_alignaddr_g0((void *)off_plus_1);

  3428.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3429.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3430.         } else {

  3431.                 vis_src1(TMP2, REF_S2);

  3432.                 vis_src1(TMP4, REF_S6);

  3433.         }

  3434. 

  3435.         height >>= 1;

  3436.         do {

  3437.                 vis_ld64_2(ref, stride, TMP0);

  3438.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3439.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3440. 

  3441.                 vis_alignaddr_g0((void *)off);

  3442. 

  3443.                 vis_ld64_2(ref, stride_8, TMP2);

  3444.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3445.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3446. 

  3447.                 vis_ld64_2(ref, stride_16, TMP4);

  3448.                 ref += stride;

  3449.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3450.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3451. 

  3452.                 vis_ld64_2(ref, stride, TMP6);

  3453.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3454.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3455. 

  3456.                 vis_ld64_2(ref, stride_8, TMP8);

  3457.                 vis_faligndata(TMP0, TMP2, REF_0);

  3458. 

  3459.                 vis_ld64_2(ref, stride_16, TMP10);

  3460.                 ref += stride;

  3461.                 vis_faligndata(TMP2, TMP4, REF_4);

  3462. 

  3463.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3464. 

  3465.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3466. 

  3467.                 if (off != 0x7) {

  3468.                         vis_alignaddr_g0((void *)off_plus_1);

  3469.                         vis_faligndata(TMP0, TMP2, REF_2);

  3470.                         vis_faligndata(TMP2, TMP4, REF_6);

  3471.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3472.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3473.                 } else {

  3474.                         vis_src1(TMP2, REF_2);

  3475.                         vis_src1(TMP4, REF_6);

  3476.                         vis_src1(TMP8, REF_S2);

  3477.                         vis_src1(TMP10, REF_S6);

  3478.                 }

  3479. 

  3480.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  3481.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3482. 

  3483.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3484.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3485. 

  3486.                 vis_padd16(TMP0, CONST_2, TMP8);

  3487.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  3488. 

  3489.                 vis_padd16(TMP2, CONST_1, TMP10);

  3490.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  3491. 

  3492.                 vis_padd16(TMP8, TMP4, TMP8);

  3493.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  3494. 

  3495.                 vis_padd16(TMP10, TMP6, TMP10);

  3496.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  3497. 

  3498.                 vis_padd16(TMP12, TMP8, TMP12);

  3499. 

  3500.                 vis_padd16(TMP14, TMP10, TMP14);

  3501. 

  3502.                 vis_padd16(TMP12, TMP16, TMP12);

  3503. 

  3504.                 vis_padd16(TMP14, TMP18, TMP14);

  3505.                 vis_pack16(TMP12, DST_0);

  3506. 

  3507.                 vis_pack16(TMP14, DST_1);

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

  3509.                 vis_padd16(TMP0, CONST_1, TMP12);

  3510. 

  3511.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  3512.                 vis_padd16(TMP2, CONST_1, TMP14);

  3513. 

  3514.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  3515.                 vis_padd16(TMP12, TMP4, TMP12);

  3516. 

  3517.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  3518.                 vis_padd16(TMP14, TMP6, TMP14);

  3519. 

  3520.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  3521.                 vis_padd16(TMP20, TMP12, TMP20);

  3522. 

  3523.                 vis_padd16(TMP22, TMP14, TMP22);

  3524. 

  3525.                 vis_padd16(TMP20, TMP24, TMP20);

  3526. 

  3527.                 vis_padd16(TMP22, TMP26, TMP22);

  3528.                 vis_pack16(TMP20, DST_2);

  3529. 

  3530.                 vis_pack16(TMP22, DST_3);

  3531.                 vis_st64_2(DST_2, dest, 8);

  3532.                 dest += stride;

  3533.                 vis_padd16(TMP0, TMP4, TMP24);

  3534. 

  3535.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  3536.                 vis_padd16(TMP2, TMP6, TMP26);

  3537. 

  3538.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  3539.                 vis_padd16(TMP24, TMP8, TMP24);

  3540. 

  3541.                 vis_padd16(TMP26, TMP10, TMP26);

  3542.                 vis_pack16(TMP24, DST_0);

  3543. 

  3544.                 vis_pack16(TMP26, DST_1);

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

  3546.                 vis_pmerge(ZERO, REF_S6, TMP4);

  3547. 

  3548.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  3549. 

  3550.                 vis_padd16(TMP0, TMP4, TMP0);

  3551. 

  3552.                 vis_padd16(TMP2, TMP6, TMP2);

  3553. 

  3554.                 vis_padd16(TMP0, TMP12, TMP0);

  3555. 

  3556.                 vis_padd16(TMP2, TMP14, TMP2);

  3557.                 vis_pack16(TMP0, DST_2);

  3558. 

  3559.                 vis_pack16(TMP2, DST_3);

  3560.                 vis_st64_2(DST_2, dest, 8);

  3561.                 dest += stride;

  3562.         } while (--height);

  3563. }

  3564. 

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

  3566.                                       const int stride, int height)

  3567. {

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

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

  3570.         unsigned long off_plus_1 = off + 1;

  3571.         int stride_8 = stride + 8;

  3572. 

  3573.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3574. 

  3575.         ref = vis_alignaddr(ref);

  3576. 

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

  3578.         vis_fzero(ZERO);

  3579. 

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

  3581. 

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

  3583. 

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

  3585.         vis_faligndata(TMP0, TMP2, REF_S0);

  3586. 

  3587.         if (off != 0x7) {

  3588.                 vis_alignaddr_g0((void *)off_plus_1);

  3589.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3590.         } else {

  3591.                 vis_src1(TMP2, REF_S2);

  3592.         }

  3593. 

  3594.         height >>= 1;

  3595.         do {    /* 26 cycles */

  3596.                 vis_ld64_2(ref, stride, TMP0);

  3597.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  3598.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  3599. 

  3600.                 vis_alignaddr_g0((void *)off);

  3601. 

  3602.                 vis_ld64_2(ref, stride_8, TMP2);

  3603.                 ref += stride;

  3604.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  3605.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  3606. 

  3607.                 vis_ld64_2(ref, stride, TMP4);

  3608. 

  3609.                 vis_ld64_2(ref, stride_8, TMP6);

  3610.                 ref += stride;

  3611.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3612. 

  3613.                 vis_pmerge(ZERO, REF_S4, TMP18);

  3614. 

  3615.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  3616. 

  3617.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3618. 

  3619.                 if (off != 0x7) {

  3620.                         vis_alignaddr_g0((void *)off_plus_1);

  3621.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3622.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3623.                 } else {

  3624.                         vis_src1(TMP2, REF_S6);

  3625.                         vis_src1(TMP6, REF_S2);

  3626.                 }

  3627. 

  3628.                 vis_padd16(TMP18, CONST_1, TMP18);

  3629.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  3630. 

  3631.                 vis_padd16(TMP20, CONST_1, TMP20);

  3632.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  3633. 

  3634.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  3635.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  3636. 

  3637.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  3638.                 vis_padd16(TMP18, TMP22, TMP18);

  3639. 

  3640.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  3641.                 vis_padd16(TMP20, TMP24, TMP20);

  3642. 

  3643.                 vis_padd16(TMP8,  TMP18, TMP8);

  3644. 

  3645.                 vis_padd16(TMP10, TMP20, TMP10);

  3646. 

  3647.                 vis_padd16(TMP8,  TMP12, TMP8);

  3648. 

  3649.                 vis_padd16(TMP10, TMP14, TMP10);

  3650.                 vis_pack16(TMP8,  DST_0);

  3651. 

  3652.                 vis_pack16(TMP10, DST_1);

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

  3654.                 dest += stride;

  3655.                 vis_padd16(TMP18, TMP26, TMP18);

  3656. 

  3657.                 vis_padd16(TMP20, TMP28, TMP20);

  3658. 

  3659.                 vis_padd16(TMP18, TMP30, TMP18);

  3660. 

  3661.                 vis_padd16(TMP20, TMP32, TMP20);

  3662.                 vis_pack16(TMP18, DST_2);

  3663. 

  3664.                 vis_pack16(TMP20, DST_3);

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

  3666.                 dest += stride;

  3667.         } while (--height);

  3668. }

  3669. 

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

  3671.                                        const int stride, int height)

  3672. {

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

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

  3675.         unsigned long off_plus_1 = off + 1;

  3676.         int stride_8 = stride + 8;

  3677.         int stride_16 = stride + 16;

  3678. 

  3679.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3680. 

  3681.         ref = vis_alignaddr(ref);

  3682. 

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

  3684.         vis_fzero(ZERO);

  3685. 

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

  3687. 

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

  3689. 

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

  3691.         vis_faligndata(TMP0, TMP2, REF_S0);

  3692. 

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

  3694.         vis_faligndata(TMP2, TMP4, REF_S4);

  3695. 

  3696.         if (off != 0x7) {

  3697.                 vis_alignaddr_g0((void *)off_plus_1);

  3698.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3699.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3700.         } else {

  3701.                 vis_src1(TMP2, REF_S2);

  3702.                 vis_src1(TMP4, REF_S6);

  3703.         }

  3704. 

  3705.         height >>= 1;

  3706.         do {    /* 55 cycles */

  3707.                 vis_ld64_2(ref, stride, TMP0);

  3708.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3709.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3710. 

  3711.                 vis_alignaddr_g0((void *)off);

  3712. 

  3713.                 vis_ld64_2(ref, stride_8, TMP2);

  3714.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3715.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3716. 

  3717.                 vis_ld64_2(ref, stride_16, TMP4);

  3718.                 ref += stride;

  3719.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3720.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3721. 

  3722.                 vis_ld64_2(ref, stride, TMP6);

  3723.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3724.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3725. 

  3726.                 vis_ld64_2(ref, stride_8, TMP8);

  3727.                 vis_faligndata(TMP0, TMP2, REF_0);

  3728. 

  3729.                 vis_ld64_2(ref, stride_16, TMP10);

  3730.                 ref += stride;

  3731.                 vis_faligndata(TMP2, TMP4, REF_4);

  3732. 

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

  3734.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3735. 

  3736.                 vis_ld64_2(dest, 8, DST_2);

  3737.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3738. 

  3739.                 if (off != 0x7) {

  3740.                         vis_alignaddr_g0((void *)off_plus_1);

  3741.                         vis_faligndata(TMP0, TMP2, REF_2);

  3742.                         vis_faligndata(TMP2, TMP4, REF_6);

  3743.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3744.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3745.                 } else {

  3746.                         vis_src1(TMP2, REF_2);

  3747.                         vis_src1(TMP4, REF_6);

  3748.                         vis_src1(TMP8, REF_S2);

  3749.                         vis_src1(TMP10, REF_S6);

  3750.                 }

  3751. 

  3752.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3753.                 vis_pmerge(ZERO, REF_0, TMP0);

  3754. 

  3755.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3756.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3757. 

  3758.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3759.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3760. 

  3761.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3762.                 vis_padd16(TMP0, CONST_6, TMP0);

  3763. 

  3764.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3765.                 vis_padd16(TMP2, CONST_6, TMP2);

  3766. 

  3767.                 vis_padd16(TMP0, TMP4, TMP0);

  3768.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  3769. 

  3770.                 vis_padd16(TMP2, TMP6, TMP2);

  3771.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3772. 

  3773.                 vis_padd16(TMP12, TMP0, TMP12);

  3774.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  3775. 

  3776.                 vis_padd16(TMP14, TMP2, TMP14);

  3777.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  3778. 

  3779.                 vis_padd16(TMP12, TMP16, TMP12);

  3780.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  3781. 

  3782.                 vis_padd16(TMP14, TMP18, TMP14);

  3783.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  3784. 

  3785.                 vis_padd16(TMP12, TMP30, TMP12);

  3786. 

  3787.                 vis_padd16(TMP14, TMP32, TMP14);

  3788.                 vis_pack16(TMP12, DST_0);

  3789. 

  3790.                 vis_pack16(TMP14, DST_1);

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

  3792.                 vis_padd16(TMP4, CONST_6, TMP4);

  3793. 

  3794.                 vis_ld64_2(dest, stride, DST_0);

  3795.                 vis_padd16(TMP6, CONST_6, TMP6);

  3796.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3797. 

  3798.                 vis_padd16(TMP4, TMP8, TMP4);

  3799.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  3800. 

  3801.                 vis_padd16(TMP6, TMP10, TMP6);

  3802. 

  3803.                 vis_padd16(TMP20, TMP4, TMP20);

  3804. 

  3805.                 vis_padd16(TMP22, TMP6, TMP22);

  3806. 

  3807.                 vis_padd16(TMP20, TMP24, TMP20);

  3808. 

  3809.                 vis_padd16(TMP22, TMP26, TMP22);

  3810. 

  3811.                 vis_padd16(TMP20, REF_0, TMP20);

  3812.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  3813. 

  3814.                 vis_padd16(TMP22, REF_2, TMP22);

  3815.                 vis_pack16(TMP20, DST_2);

  3816. 

  3817.                 vis_pack16(TMP22, DST_3);

  3818.                 vis_st64_2(DST_2, dest, 8);

  3819.                 dest += stride;

  3820. 

  3821.                 vis_ld64_2(dest, 8, DST_2);

  3822.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3823.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  3824. 

  3825.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3826.                 vis_padd16(REF_4, TMP0, TMP8);

  3827. 

  3828.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  3829.                 vis_padd16(REF_6, TMP2, TMP10);

  3830. 

  3831.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  3832.                 vis_padd16(TMP8, TMP12, TMP8);

  3833. 

  3834.                 vis_padd16(TMP10, TMP14, TMP10);

  3835. 

  3836.                 vis_padd16(TMP8, TMP30, TMP8);

  3837. 

  3838.                 vis_padd16(TMP10, TMP32, TMP10);

  3839.                 vis_pack16(TMP8, DST_0);

  3840. 

  3841.                 vis_pack16(TMP10, DST_1);

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

  3843. 

  3844.                 vis_padd16(REF_0, TMP4, REF_0);

  3845. 

  3846.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  3847.                 vis_padd16(REF_2, TMP6, REF_2);

  3848. 

  3849.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  3850.                 vis_padd16(REF_0, REF_4, REF_0);

  3851. 

  3852.                 vis_padd16(REF_2, REF_6, REF_2);

  3853. 

  3854.                 vis_padd16(REF_0, TMP30, REF_0);

  3855. 

  3856.                 /* stall */

  3857. 

  3858.                 vis_padd16(REF_2, TMP32, REF_2);

  3859.                 vis_pack16(REF_0, DST_2);

  3860. 

  3861.                 vis_pack16(REF_2, DST_3);

  3862.                 vis_st64_2(DST_2, dest, 8);

  3863.                 dest += stride;

  3864.         } while (--height);

  3865. }

  3866. 

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

  3868.                                       const int stride, int height)

  3869. {

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

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

  3872.         unsigned long off_plus_1 = off + 1;

  3873.         int stride_8 = stride + 8;

  3874. 

  3875.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3876. 

  3877.         ref = vis_alignaddr(ref);

  3878. 

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

  3880.         vis_fzero(ZERO);

  3881. 

  3882.         vis_ld64_2(ref, 8, TMP2);

  3883. 

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

  3885. 

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

  3887.         vis_faligndata(TMP0, TMP2, REF_S0);

  3888. 

  3889.         if (off != 0x7) {

  3890.                 vis_alignaddr_g0((void *)off_plus_1);

  3891.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3892.         } else {

  3893.                 vis_src1(TMP2, REF_S2);

  3894.         }

  3895. 

  3896.         height >>= 1;

  3897.         do {    /* 31 cycles */

  3898.                 vis_ld64_2(ref, stride, TMP0);

  3899.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  3900.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  3901. 

  3902.                 vis_ld64_2(ref, stride_8, TMP2);

  3903.                 ref += stride;

  3904.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3905.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  3906. 

  3907.                 vis_alignaddr_g0((void *)off);

  3908. 

  3909.                 vis_ld64_2(ref, stride, TMP4);

  3910.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3911. 

  3912.                 vis_ld64_2(ref, stride_8, TMP6);

  3913.                 ref += stride;

  3914. 

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

  3916.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3917. 

  3918.                 vis_ld64_2(dest, stride, DST_2);

  3919. 

  3920.                 if (off != 0x7) {

  3921.                         vis_alignaddr_g0((void *)off_plus_1);

  3922.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3923.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3924.                 } else {

  3925.                         vis_src1(TMP2, REF_S6);

  3926.                         vis_src1(TMP6, REF_S2);

  3927.                 }

  3928. 

  3929.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3930.                 vis_pmerge(ZERO, REF_S4, TMP22);

  3931. 

  3932.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3933.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  3934. 

  3935.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  3936.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  3937. 

  3938.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  3939.                 vis_padd16(TMP22, CONST_6, TMP22);

  3940. 

  3941.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  3942.                 vis_padd16(TMP24, CONST_6, TMP24);

  3943. 

  3944.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3945.                 vis_padd16(TMP22, TMP26, TMP22);

  3946. 

  3947.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3948.                 vis_padd16(TMP24, TMP28, TMP24);

  3949. 

  3950.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  3951.                 vis_padd16(TMP8, TMP22, TMP8);

  3952. 

  3953.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  3954.                 vis_padd16(TMP10, TMP24, TMP10);

  3955. 

  3956.                 vis_padd16(TMP8, TMP12, TMP8);

  3957. 

  3958.                 vis_padd16(TMP10, TMP14, TMP10);

  3959. 

  3960.                 vis_padd16(TMP8, TMP30, TMP8);

  3961. 

  3962.                 vis_padd16(TMP10, TMP32, TMP10);

  3963.                 vis_pack16(TMP8, DST_0);

  3964. 

  3965.                 vis_pack16(TMP10, DST_1);

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

  3967.                 dest += stride;

  3968. 

  3969.                 vis_padd16(REF_S4, TMP22, TMP12);

  3970. 

  3971.                 vis_padd16(REF_S6, TMP24, TMP14);

  3972. 

  3973.                 vis_padd16(TMP12, TMP26, TMP12);

  3974. 

  3975.                 vis_padd16(TMP14, TMP28, TMP14);

  3976. 

  3977.                 vis_padd16(TMP12, REF_0, TMP12);

  3978. 

  3979.                 vis_padd16(TMP14, REF_2, TMP14);

  3980.                 vis_pack16(TMP12, DST_2);

  3981. 

  3982.                 vis_pack16(TMP14, DST_3);

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

  3984.                 dest += stride;

  3985.         } while (--height);

  3986. }

  3987. 

  3988. /* End of no rounding code */

  3989. 

  3990. static sigjmp_buf jmpbuf;

  3991. static volatile sig_atomic_t canjump = 0;

  3992. 

  3993. static void sigill_handler (int sig)

  3994. {

  3995.     if (!canjump) {

  3996.         signal (sig, SIG_DFL);

  3997.         raise (sig);

  3998.     }

  3999. 

  4000.     canjump = 0;

  4001.     siglongjmp (jmpbuf, 1);

  4002. }

  4003. 

  4004. #define ACCEL_SPARC_VIS 1

  4005. #define ACCEL_SPARC_VIS2 2

  4006. 

  4007. static int vis_level ()

  4008. {

  4009.     int accel = 0;

  4010. 

  4011.     signal (SIGILL, sigill_handler);

  4012.     if (sigsetjmp (jmpbuf, 1)) {

  4013.         signal (SIGILL, SIG_DFL);

  4014.         return accel;

  4015.     }

  4016. 

  4017.     canjump = 1;

  4018. 

  4019.     /* pdist %f0, %f0, %f0 */

  4020.     __asm__ __volatile__(".word\t0x81b007c0");

  4021. 

  4022.     canjump = 0;

  4023.     accel |= ACCEL_SPARC_VIS;

  4024. 

  4025.     if (sigsetjmp (jmpbuf, 1)) {

  4026.         signal (SIGILL, SIG_DFL);

  4027.         return accel;

  4028.     }

  4029. 

  4030.     canjump = 1;

  4031. 

  4032.     /* edge8n %g0, %g0, %g0 */

  4033.     __asm__ __volatile__(".word\t0x81b00020");

  4034. 

  4035.     canjump = 0;

  4036.     accel |= ACCEL_SPARC_VIS2;

  4037. 

  4038.     signal (SIGILL, SIG_DFL);

  4039. 

  4040.     return accel;

  4041. }

  4042. 

  4043. /* libavcodec initialization code */

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

  4045. {

  4046.   /* VIS specific optimisations */

  4047.   int accel = vis_level ();

  4048. 

  4049.   if (accel & ACCEL_SPARC_VIS) {

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

  4051.           c->idct_put = ff_simple_idct_put_vis;

  4052.           c->idct_add = ff_simple_idct_add_vis;

  4053.           c->idct     = ff_simple_idct_vis;

  4054.           c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;

  4055.       }

  4056. 

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

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

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

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

  4061. 

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

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

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

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

  4066. 

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

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

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

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

  4071. 

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

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

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

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

  4076. 

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

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

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

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

  4081. 

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

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

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

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

  4086. 

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

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

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

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

  4091. 

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

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

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

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

  4096.   }

  4097. }