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.
50910 Commits
32 Branches
1.5GB
Tree: ed69c69a01
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ed69c69a01'
${ noResults }
FFmpeg/libavcodec/sparc/hpeldsp_vis.c

3538 lines
104KB
Raw Blame History 

  1. /*

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

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

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

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

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

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

  10.  *

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

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

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

  14.  * Lesser General Public License for more details.

  15.  *

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

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

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

  19.  */

  20. 

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

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

  23.  */

  24. 

  25. #include "config.h"

  26. 

  27. #include <inttypes.h>

  28. 

  29. #include "libavcodec/hpeldsp.h"

  30. #include "libavutil/mem.h"

  31. 

  32. #include "vis.h"

  33. 

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

  35.  * motion comp code, which is:

  36.  *

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

  38.  *

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

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

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

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

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

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

  45.  *

  46.  *      fxor            f0,   f2, f10

  47.  *      fand            f10,  f4, f10

  48.  *      fmul8x16        f8,  f10, f10

  49.  *      fand            f10,  f6, f10

  50.  *      for             f0,   f2, f12

  51.  *      fpsub16         f12, f10, f10

  52.  */

  53. 

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

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

  56. DECLARE_ALIGNED(8, static const int16_t, constants1)[] = DUP4 (1);

  57. DECLARE_ALIGNED(8, static const int16_t, constants2)[] = DUP4 (2);

  58. DECLARE_ALIGNED(8, static const int16_t, constants3)[] = DUP4 (3);

  59. DECLARE_ALIGNED(8, static const int16_t, constants6)[] = DUP4 (6);

  60. DECLARE_ALIGNED(8, static const int8_t, constants_fe)[] = DUP8 (0xfe);

  61. DECLARE_ALIGNED(8, static const int8_t, constants_7f)[] = DUP8 (0x7f);

  62. DECLARE_ALIGNED(8, static const int8_t, constants128)[] = DUP8 (128);

  63. DECLARE_ALIGNED(8, static const int16_t, constants256_512)[] =

  64.         {256, 512, 256, 512};

  65. DECLARE_ALIGNED(8, static const int16_t, constants256_1024)[] =

  66.         {256, 1024, 256, 1024};

  67. 

  68. #define REF_0           0

  69. #define REF_0_1         1

  70. #define REF_2           2

  71. #define REF_2_1         3

  72. #define REF_4           4

  73. #define REF_4_1         5

  74. #define REF_6           6

  75. #define REF_6_1         7

  76. #define REF_S0          8

  77. #define REF_S0_1        9

  78. #define REF_S2          10

  79. #define REF_S2_1        11

  80. #define REF_S4          12

  81. #define REF_S4_1        13

  82. #define REF_S6          14

  83. #define REF_S6_1        15

  84. #define DST_0           16

  85. #define DST_1           17

  86. #define DST_2           18

  87. #define DST_3           19

  88. #define CONST_1         20

  89. #define CONST_2         20

  90. #define CONST_3         20

  91. #define CONST_6         20

  92. #define MASK_fe         20

  93. #define CONST_128       22

  94. #define CONST_256       22

  95. #define CONST_512       22

  96. #define CONST_1024      22

  97. #define TMP0            24

  98. #define TMP1            25

  99. #define TMP2            26

  100. #define TMP3            27

  101. #define TMP4            28

  102. #define TMP5            29

  103. #define ZERO            30

  104. #define MASK_7f         30

  105. 

  106. #define TMP6            32

  107. #define TMP8            34

  108. #define TMP10           36

  109. #define TMP12           38

  110. #define TMP14           40

  111. #define TMP16           42

  112. #define TMP18           44

  113. #define TMP20           46

  114. #define TMP22           48

  115. #define TMP24           50

  116. #define TMP26           52

  117. #define TMP28           54

  118. #define TMP30           56

  119. #define TMP32           58

  120. 

  121. static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * ref,

  122.                              const ptrdiff_t stride, int height)

  123. {

  124.         ref = vis_alignaddr(ref);

  125.         do {    /* 5 cycles */

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

  127. 

  128.                 vis_ld64_2(ref, 8, TMP2);

  129. 

  130.                 vis_ld64_2(ref, 16, TMP4);

  131.                 ref += stride;

  132. 

  133.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  135. 

  136.                 vis_faligndata(TMP2, TMP4, REF_2);

  137.                 vis_st64_2(REF_2, dest, 8);

  138.                 dest += stride;

  139.         } while (--height);

  140. }

  141. 

  142. static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * ref,

  143.                             const ptrdiff_t stride, int height)

  144. {

  145.         ref = vis_alignaddr(ref);

  146.         do {    /* 4 cycles */

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

  148. 

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

  150.                 ref += stride;

  151. 

  152.                 /* stall */

  153. 

  154.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  156.                 dest += stride;

  157.         } while (--height);

  158. }

  159. 

  160. 

  161. static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * ref,

  162.                              const ptrdiff_t stride, int height)

  163. {

  164.         int stride_8 = stride + 8;

  165. 

  166.         ref = vis_alignaddr(ref);

  167. 

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

  169. 

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

  171. 

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

  173. 

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

  175. 

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

  177. 

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

  179.         vis_faligndata(TMP0, TMP2, REF_0);

  180. 

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

  182.         vis_faligndata(TMP2, TMP4, REF_2);

  183. 

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

  185. 

  186.         ref += stride;

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

  188. 

  189.         do {    /* 24 cycles */

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

  191.                 vis_xor(DST_0, REF_0, TMP6);

  192. 

  193.                 vis_ld64_2(ref, 8, TMP2);

  194.                 vis_and(TMP6, MASK_fe, TMP6);

  195. 

  196.                 vis_ld64_2(ref, 16, TMP4);

  197.                 ref += stride;

  198.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  199.                 vis_xor(DST_2, REF_2, TMP8);

  200. 

  201.                 vis_and(TMP8, MASK_fe, TMP8);

  202. 

  203.                 vis_or(DST_0, REF_0, TMP10);

  204.                 vis_ld64_2(dest, stride, DST_0);

  205.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  206. 

  207.                 vis_or(DST_2, REF_2, TMP12);

  208.                 vis_ld64_2(dest, stride_8, DST_2);

  209. 

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

  211.                 vis_and(TMP6, MASK_7f, TMP6);

  212. 

  213.                 vis_and(TMP8, MASK_7f, TMP8);

  214. 

  215.                 vis_psub16(TMP10, TMP6, TMP6);

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

  217. 

  218.                 vis_psub16(TMP12, TMP8, TMP8);

  219.                 vis_st64_2(TMP8, dest, 8);

  220. 

  221.                 dest += stride;

  222.                 vis_ld64_2(ref, 8, TMP16);

  223.                 vis_faligndata(TMP0, TMP2, REF_0);

  224. 

  225.                 vis_ld64_2(ref, 16, TMP18);

  226.                 vis_faligndata(TMP2, TMP4, REF_2);

  227.                 ref += stride;

  228. 

  229.                 vis_xor(DST_0, REF_0, TMP20);

  230. 

  231.                 vis_and(TMP20, MASK_fe, TMP20);

  232. 

  233.                 vis_xor(DST_2, REF_2, TMP22);

  234.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  235. 

  236.                 vis_and(TMP22, MASK_fe, TMP22);

  237. 

  238.                 vis_or(DST_0, REF_0, TMP24);

  239.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  240. 

  241.                 vis_or(DST_2, REF_2, TMP26);

  242. 

  243.                 vis_ld64_2(dest, stride, DST_0);

  244.                 vis_faligndata(TMP14, TMP16, REF_0);

  245. 

  246.                 vis_ld64_2(dest, stride_8, DST_2);

  247.                 vis_faligndata(TMP16, TMP18, REF_2);

  248. 

  249.                 vis_and(TMP20, MASK_7f, TMP20);

  250. 

  251.                 vis_and(TMP22, MASK_7f, TMP22);

  252. 

  253.                 vis_psub16(TMP24, TMP20, TMP20);

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

  255. 

  256.                 vis_psub16(TMP26, TMP22, TMP22);

  257.                 vis_st64_2(TMP22, dest, 8);

  258.                 dest += stride;

  259.         } while (--height);

  260. 

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

  262.         vis_xor(DST_0, REF_0, TMP6);

  263. 

  264.         vis_ld64_2(ref, 8, TMP2);

  265.         vis_and(TMP6, MASK_fe, TMP6);

  266. 

  267.         vis_ld64_2(ref, 16, TMP4);

  268.         vis_mul8x16(CONST_128, TMP6, TMP6);

  269.         vis_xor(DST_2, REF_2, TMP8);

  270. 

  271.         vis_and(TMP8, MASK_fe, TMP8);

  272. 

  273.         vis_or(DST_0, REF_0, TMP10);

  274.         vis_ld64_2(dest, stride, DST_0);

  275.         vis_mul8x16(CONST_128, TMP8, TMP8);

  276. 

  277.         vis_or(DST_2, REF_2, TMP12);

  278.         vis_ld64_2(dest, stride_8, DST_2);

  279. 

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

  281.         vis_and(TMP6, MASK_7f, TMP6);

  282. 

  283.         vis_and(TMP8, MASK_7f, TMP8);

  284. 

  285.         vis_psub16(TMP10, TMP6, TMP6);

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

  287. 

  288.         vis_psub16(TMP12, TMP8, TMP8);

  289.         vis_st64_2(TMP8, dest, 8);

  290. 

  291.         dest += stride;

  292.         vis_faligndata(TMP0, TMP2, REF_0);

  293. 

  294.         vis_faligndata(TMP2, TMP4, REF_2);

  295. 

  296.         vis_xor(DST_0, REF_0, TMP20);

  297. 

  298.         vis_and(TMP20, MASK_fe, TMP20);

  299. 

  300.         vis_xor(DST_2, REF_2, TMP22);

  301.         vis_mul8x16(CONST_128, TMP20, TMP20);

  302. 

  303.         vis_and(TMP22, MASK_fe, TMP22);

  304. 

  305.         vis_or(DST_0, REF_0, TMP24);

  306.         vis_mul8x16(CONST_128, TMP22, TMP22);

  307. 

  308.         vis_or(DST_2, REF_2, TMP26);

  309. 

  310.         vis_and(TMP20, MASK_7f, TMP20);

  311. 

  312.         vis_and(TMP22, MASK_7f, TMP22);

  313. 

  314.         vis_psub16(TMP24, TMP20, TMP20);

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

  316. 

  317.         vis_psub16(TMP26, TMP22, TMP22);

  318.         vis_st64_2(TMP22, dest, 8);

  319. }

  320. 

  321. static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * ref,

  322.                             const ptrdiff_t stride, int height)

  323. {

  324.         ref = vis_alignaddr(ref);

  325. 

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

  327. 

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

  329. 

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

  331. 

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

  333. 

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

  335.         vis_faligndata(TMP0, TMP2, REF_0);

  336. 

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

  338. 

  339.         ref += stride;

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

  341. 

  342.         do {    /* 12 cycles */

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

  344.                 vis_xor(DST_0, REF_0, TMP4);

  345. 

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

  347.                 vis_and(TMP4, MASK_fe, TMP4);

  348. 

  349.                 vis_or(DST_0, REF_0, TMP6);

  350.                 vis_ld64_2(dest, stride, DST_0);

  351.                 ref += stride;

  352.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  353. 

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

  355.                 vis_faligndata(TMP0, TMP2, REF_0);

  356. 

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

  358.                 vis_xor(DST_0, REF_0, TMP0);

  359.                 ref += stride;

  360. 

  361.                 vis_and(TMP0, MASK_fe, TMP0);

  362. 

  363.                 vis_and(TMP4, MASK_7f, TMP4);

  364. 

  365.                 vis_psub16(TMP6, TMP4, TMP4);

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

  367.                 dest += stride;

  368.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  369. 

  370.                 vis_or(DST_0, REF_0, TMP6);

  371.                 vis_ld64_2(dest, stride, DST_0);

  372. 

  373.                 vis_faligndata(TMP12, TMP2, REF_0);

  374. 

  375.                 vis_and(TMP0, MASK_7f, TMP0);

  376. 

  377.                 vis_psub16(TMP6, TMP0, TMP4);

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

  379.                 dest += stride;

  380.         } while (--height);

  381. 

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

  383.         vis_xor(DST_0, REF_0, TMP4);

  384. 

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

  386.         vis_and(TMP4, MASK_fe, TMP4);

  387. 

  388.         vis_or(DST_0, REF_0, TMP6);

  389.         vis_ld64_2(dest, stride, DST_0);

  390.         vis_mul8x16(CONST_128, TMP4, TMP4);

  391. 

  392.         vis_faligndata(TMP0, TMP2, REF_0);

  393. 

  394.         vis_xor(DST_0, REF_0, TMP0);

  395. 

  396.         vis_and(TMP0, MASK_fe, TMP0);

  397. 

  398.         vis_and(TMP4, MASK_7f, TMP4);

  399. 

  400.         vis_psub16(TMP6, TMP4, TMP4);

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

  402.         dest += stride;

  403.         vis_mul8x16(CONST_128, TMP0, TMP0);

  404. 

  405.         vis_or(DST_0, REF_0, TMP6);

  406. 

  407.         vis_and(TMP0, MASK_7f, TMP0);

  408. 

  409.         vis_psub16(TMP6, TMP0, TMP4);

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

  411. }

  412. 

  413. static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * ref,

  414.                              const ptrdiff_t stride, int height)

  415. {

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

  417.         unsigned long off_plus_1 = off + 1;

  418. 

  419.         ref = vis_alignaddr(ref);

  420. 

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

  422. 

  423.         vis_ld64_2(ref, 8,  TMP2);

  424. 

  425.         vis_ld64_2(ref, 16, TMP4);

  426. 

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

  428. 

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

  430.         vis_faligndata(TMP0, TMP2, REF_0);

  431. 

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

  433.         vis_faligndata(TMP2, TMP4, REF_4);

  434. 

  435.         if (off != 0x7) {

  436.                 vis_alignaddr_g0((void *)off_plus_1);

  437.                 vis_faligndata(TMP0, TMP2, REF_2);

  438.                 vis_faligndata(TMP2, TMP4, REF_6);

  439.         } else {

  440.                 vis_src1(TMP2, REF_2);

  441.                 vis_src1(TMP4, REF_6);

  442.         }

  443. 

  444.         ref += stride;

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

  446. 

  447.         do {    /* 34 cycles */

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

  449.                 vis_xor(REF_0, REF_2, TMP6);

  450. 

  451.                 vis_ld64_2(ref, 8,  TMP2);

  452.                 vis_xor(REF_4, REF_6, TMP8);

  453. 

  454.                 vis_ld64_2(ref, 16, TMP4);

  455.                 vis_and(TMP6, MASK_fe, TMP6);

  456.                 ref += stride;

  457. 

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

  459.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  460.                 vis_and(TMP8, MASK_fe, TMP8);

  461. 

  462.                 vis_ld64_2(ref, 8,  TMP16);

  463.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  464.                 vis_or(REF_0, REF_2, TMP10);

  465. 

  466.                 vis_ld64_2(ref, 16, TMP18);

  467.                 ref += stride;

  468.                 vis_or(REF_4, REF_6, TMP12);

  469. 

  470.                 vis_alignaddr_g0((void *)off);

  471. 

  472.                 vis_faligndata(TMP0, TMP2, REF_0);

  473. 

  474.                 vis_faligndata(TMP2, TMP4, REF_4);

  475. 

  476.                 if (off != 0x7) {

  477.                         vis_alignaddr_g0((void *)off_plus_1);

  478.                         vis_faligndata(TMP0, TMP2, REF_2);

  479.                         vis_faligndata(TMP2, TMP4, REF_6);

  480.                 } else {

  481.                         vis_src1(TMP2, REF_2);

  482.                         vis_src1(TMP4, REF_6);

  483.                 }

  484. 

  485.                 vis_and(TMP6, MASK_7f, TMP6);

  486. 

  487.                 vis_and(TMP8, MASK_7f, TMP8);

  488. 

  489.                 vis_psub16(TMP10, TMP6, TMP6);

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

  491. 

  492.                 vis_psub16(TMP12, TMP8, TMP8);

  493.                 vis_st64_2(TMP8, dest, 8);

  494.                 dest += stride;

  495. 

  496.                 vis_xor(REF_0, REF_2, TMP6);

  497. 

  498.                 vis_xor(REF_4, REF_6, TMP8);

  499. 

  500.                 vis_and(TMP6, MASK_fe, TMP6);

  501. 

  502.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  503.                 vis_and(TMP8, MASK_fe, TMP8);

  504. 

  505.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  506.                 vis_or(REF_0, REF_2, TMP10);

  507. 

  508.                 vis_or(REF_4, REF_6, TMP12);

  509. 

  510.                 vis_alignaddr_g0((void *)off);

  511. 

  512.                 vis_faligndata(TMP14, TMP16, REF_0);

  513. 

  514.                 vis_faligndata(TMP16, TMP18, REF_4);

  515. 

  516.                 if (off != 0x7) {

  517.                         vis_alignaddr_g0((void *)off_plus_1);

  518.                         vis_faligndata(TMP14, TMP16, REF_2);

  519.                         vis_faligndata(TMP16, TMP18, REF_6);

  520.                 } else {

  521.                         vis_src1(TMP16, REF_2);

  522.                         vis_src1(TMP18, REF_6);

  523.                 }

  524. 

  525.                 vis_and(TMP6, MASK_7f, TMP6);

  526. 

  527.                 vis_and(TMP8, MASK_7f, TMP8);

  528. 

  529.                 vis_psub16(TMP10, TMP6, TMP6);

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

  531. 

  532.                 vis_psub16(TMP12, TMP8, TMP8);

  533.                 vis_st64_2(TMP8, dest, 8);

  534.                 dest += stride;

  535.         } while (--height);

  536. 

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

  538.         vis_xor(REF_0, REF_2, TMP6);

  539. 

  540.         vis_ld64_2(ref, 8,  TMP2);

  541.         vis_xor(REF_4, REF_6, TMP8);

  542. 

  543.         vis_ld64_2(ref, 16, TMP4);

  544.         vis_and(TMP6, MASK_fe, TMP6);

  545. 

  546.         vis_mul8x16(CONST_128, TMP6, TMP6);

  547.         vis_and(TMP8, MASK_fe, TMP8);

  548. 

  549.         vis_mul8x16(CONST_128, TMP8, TMP8);

  550.         vis_or(REF_0, REF_2, TMP10);

  551. 

  552.         vis_or(REF_4, REF_6, TMP12);

  553. 

  554.         vis_alignaddr_g0((void *)off);

  555. 

  556.         vis_faligndata(TMP0, TMP2, REF_0);

  557. 

  558.         vis_faligndata(TMP2, TMP4, REF_4);

  559. 

  560.         if (off != 0x7) {

  561.                 vis_alignaddr_g0((void *)off_plus_1);

  562.                 vis_faligndata(TMP0, TMP2, REF_2);

  563.                 vis_faligndata(TMP2, TMP4, REF_6);

  564.         } else {

  565.                 vis_src1(TMP2, REF_2);

  566.                 vis_src1(TMP4, REF_6);

  567.         }

  568. 

  569.         vis_and(TMP6, MASK_7f, TMP6);

  570. 

  571.         vis_and(TMP8, MASK_7f, TMP8);

  572. 

  573.         vis_psub16(TMP10, TMP6, TMP6);

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

  575. 

  576.         vis_psub16(TMP12, TMP8, TMP8);

  577.         vis_st64_2(TMP8, dest, 8);

  578.         dest += stride;

  579. 

  580.         vis_xor(REF_0, REF_2, TMP6);

  581. 

  582.         vis_xor(REF_4, REF_6, TMP8);

  583. 

  584.         vis_and(TMP6, MASK_fe, TMP6);

  585. 

  586.         vis_mul8x16(CONST_128, TMP6, TMP6);

  587.         vis_and(TMP8, MASK_fe, TMP8);

  588. 

  589.         vis_mul8x16(CONST_128, TMP8, TMP8);

  590.         vis_or(REF_0, REF_2, TMP10);

  591. 

  592.         vis_or(REF_4, REF_6, TMP12);

  593. 

  594.         vis_and(TMP6, MASK_7f, TMP6);

  595. 

  596.         vis_and(TMP8, MASK_7f, TMP8);

  597. 

  598.         vis_psub16(TMP10, TMP6, TMP6);

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

  600. 

  601.         vis_psub16(TMP12, TMP8, TMP8);

  602.         vis_st64_2(TMP8, dest, 8);

  603. }

  604. 

  605. static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * ref,

  606.                             const ptrdiff_t stride, int height)

  607. {

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

  609.         unsigned long off_plus_1 = off + 1;

  610. 

  611.         ref = vis_alignaddr(ref);

  612. 

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

  614. 

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

  616. 

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

  618. 

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

  620. 

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

  622.         vis_faligndata(TMP0, TMP2, REF_0);

  623. 

  624.         if (off != 0x7) {

  625.                 vis_alignaddr_g0((void *)off_plus_1);

  626.                 vis_faligndata(TMP0, TMP2, REF_2);

  627.         } else {

  628.                 vis_src1(TMP2, REF_2);

  629.         }

  630. 

  631.         ref += stride;

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

  633. 

  634.         do {    /* 20 cycles */

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

  636.                 vis_xor(REF_0, REF_2, TMP4);

  637. 

  638.                 vis_ld64_2(ref, 8, TMP2);

  639.                 vis_and(TMP4, MASK_fe, TMP4);

  640.                 ref += stride;

  641. 

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

  643.                 vis_or(REF_0, REF_2, TMP6);

  644.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  645. 

  646.                 vis_alignaddr_g0((void *)off);

  647. 

  648.                 vis_ld64_2(ref, 8, TMP10);

  649.                 ref += stride;

  650.                 vis_faligndata(TMP0, TMP2, REF_0);

  651. 

  652.                 if (off != 0x7) {

  653.                         vis_alignaddr_g0((void *)off_plus_1);

  654.                         vis_faligndata(TMP0, TMP2, REF_2);

  655.                 } else {

  656.                         vis_src1(TMP2, REF_2);

  657.                 }

  658. 

  659.                 vis_and(TMP4, MASK_7f, TMP4);

  660. 

  661.                 vis_psub16(TMP6, TMP4, DST_0);

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

  663.                 dest += stride;

  664. 

  665.                 vis_xor(REF_0, REF_2, TMP12);

  666. 

  667.                 vis_and(TMP12, MASK_fe, TMP12);

  668. 

  669.                 vis_or(REF_0, REF_2, TMP14);

  670.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  671. 

  672.                 vis_alignaddr_g0((void *)off);

  673.                 vis_faligndata(TMP8, TMP10, REF_0);

  674.                 if (off != 0x7) {

  675.                         vis_alignaddr_g0((void *)off_plus_1);

  676.                         vis_faligndata(TMP8, TMP10, REF_2);

  677.                 } else {

  678.                         vis_src1(TMP10, REF_2);

  679.                 }

  680. 

  681.                 vis_and(TMP12, MASK_7f, TMP12);

  682. 

  683.                 vis_psub16(TMP14, TMP12, DST_0);

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

  685.                 dest += stride;

  686.         } while (--height);

  687. 

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

  689.         vis_xor(REF_0, REF_2, TMP4);

  690. 

  691.         vis_ld64_2(ref, 8, TMP2);

  692.         vis_and(TMP4, MASK_fe, TMP4);

  693. 

  694.         vis_or(REF_0, REF_2, TMP6);

  695.         vis_mul8x16(CONST_128, TMP4, TMP4);

  696. 

  697.         vis_alignaddr_g0((void *)off);

  698. 

  699.         vis_faligndata(TMP0, TMP2, REF_0);

  700. 

  701.         if (off != 0x7) {

  702.                 vis_alignaddr_g0((void *)off_plus_1);

  703.                 vis_faligndata(TMP0, TMP2, REF_2);

  704.         } else {

  705.                 vis_src1(TMP2, REF_2);

  706.         }

  707. 

  708.         vis_and(TMP4, MASK_7f, TMP4);

  709. 

  710.         vis_psub16(TMP6, TMP4, DST_0);

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

  712.         dest += stride;

  713. 

  714.         vis_xor(REF_0, REF_2, TMP12);

  715. 

  716.         vis_and(TMP12, MASK_fe, TMP12);

  717. 

  718.         vis_or(REF_0, REF_2, TMP14);

  719.         vis_mul8x16(CONST_128, TMP12, TMP12);

  720. 

  721.         vis_and(TMP12, MASK_7f, TMP12);

  722. 

  723.         vis_psub16(TMP14, TMP12, DST_0);

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

  725.         dest += stride;

  726. }

  727. 

  728. static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * ref,

  729.                              const ptrdiff_t stride, int height)

  730. {

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

  732.         unsigned long off_plus_1 = off + 1;

  733. 

  734.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  735. 

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

  737.         vis_fzero(ZERO);

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

  739. 

  740.         ref = vis_alignaddr(ref);

  741.         do {    /* 26 cycles */

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

  743. 

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

  745. 

  746.                 vis_alignaddr_g0((void *)off);

  747. 

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

  749. 

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

  751.                 vis_faligndata(TMP0, TMP2, REF_0);

  752. 

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

  754.                 vis_faligndata(TMP2, TMP4, REF_4);

  755. 

  756.                 if (off != 0x7) {

  757.                         vis_alignaddr_g0((void *)off_plus_1);

  758.                         vis_faligndata(TMP0, TMP2, REF_2);

  759.                         vis_faligndata(TMP2, TMP4, REF_6);

  760.                 } else {

  761.                         vis_src1(TMP2, REF_2);

  762.                         vis_src1(TMP4, REF_6);

  763.                 }

  764. 

  765.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  766. 

  767.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  768.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  769. 

  770.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  771. 

  772.                 vis_padd16(TMP0, TMP4, TMP0);

  773. 

  774.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  775.                 vis_padd16(TMP2, TMP6, TMP2);

  776. 

  777.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  778. 

  779.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  780. 

  781.                 vis_padd16(TMP0, TMP4, TMP0);

  782.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  783. 

  784.                 vis_padd16(TMP2, TMP6, TMP2);

  785.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  786. 

  787.                 vis_padd16(TMP0, CONST_3, TMP8);

  788.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  789. 

  790.                 vis_padd16(TMP2, CONST_3, TMP10);

  791.                 vis_pack16(TMP8, DST_0);

  792. 

  793.                 vis_pack16(TMP10, DST_1);

  794.                 vis_padd16(TMP16, TMP12, TMP0);

  795. 

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

  797.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  798.                 vis_padd16(TMP18, TMP14, TMP2);

  799. 

  800.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  801.                 vis_padd16(TMP0, CONST_3, TMP0);

  802. 

  803.                 vis_padd16(TMP2, CONST_3, TMP2);

  804. 

  805.                 vis_padd16(TMP0, TMP4, TMP0);

  806. 

  807.                 vis_padd16(TMP2, TMP6, TMP2);

  808.                 vis_pack16(TMP0, DST_2);

  809. 

  810.                 vis_pack16(TMP2, DST_3);

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

  812. 

  813.                 ref += stride;

  814.                 dest += stride;

  815.         } while (--height);

  816. }

  817. 

  818. static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * ref,

  819.                             const ptrdiff_t stride, int height)

  820. {

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

  822.         unsigned long off_plus_1 = off + 1;

  823.         int stride_times_2 = stride << 1;

  824. 

  825.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  826. 

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

  828.         vis_fzero(ZERO);

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

  830. 

  831.         ref = vis_alignaddr(ref);

  832.         height >>= 2;

  833.         do {    /* 47 cycles */

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

  835. 

  836.                 vis_ld64_2(ref, 8, TMP2);

  837.                 ref += stride;

  838. 

  839.                 vis_alignaddr_g0((void *)off);

  840. 

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

  842.                 vis_faligndata(TMP0, TMP2, REF_0);

  843. 

  844.                 vis_ld64_2(ref, 8, TMP6);

  845.                 ref += stride;

  846. 

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

  848. 

  849.                 vis_ld64_2(ref, 8, TMP10);

  850.                 ref += stride;

  851.                 vis_faligndata(TMP4, TMP6, REF_4);

  852. 

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

  854. 

  855.                 vis_ld64_2(ref, 8, TMP14);

  856.                 ref += stride;

  857.                 vis_faligndata(TMP8, TMP10, REF_S0);

  858. 

  859.                 vis_faligndata(TMP12, TMP14, REF_S4);

  860. 

  861.                 if (off != 0x7) {

  862.                         vis_alignaddr_g0((void *)off_plus_1);

  863. 

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

  865.                         vis_faligndata(TMP0, TMP2, REF_2);

  866. 

  867.                         vis_ld64_2(dest, stride, DST_2);

  868.                         vis_faligndata(TMP4, TMP6, REF_6);

  869. 

  870.                         vis_faligndata(TMP8, TMP10, REF_S2);

  871. 

  872.                         vis_faligndata(TMP12, TMP14, REF_S6);

  873.                 } else {

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

  875.                         vis_src1(TMP2, REF_2);

  876. 

  877.                         vis_ld64_2(dest, stride, DST_2);

  878.                         vis_src1(TMP6, REF_6);

  879. 

  880.                         vis_src1(TMP10, REF_S2);

  881. 

  882.                         vis_src1(TMP14, REF_S6);

  883.                 }

  884. 

  885.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  886.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  887. 

  888.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  889.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  890. 

  891.                 vis_padd16(TMP0, CONST_3, TMP0);

  892.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  893. 

  894.                 vis_padd16(TMP2, CONST_3, TMP2);

  895.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  896. 

  897.                 vis_padd16(TMP0, TMP4, TMP0);

  898.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  899. 

  900.                 vis_padd16(TMP2, TMP6, TMP2);

  901.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  902. 

  903.                 vis_padd16(TMP0, TMP16, TMP0);

  904.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  905. 

  906.                 vis_padd16(TMP2, TMP18, TMP2);

  907.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  908. 

  909.                 vis_padd16(TMP8, CONST_3, TMP8);

  910.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  911. 

  912.                 vis_padd16(TMP8, TMP12, TMP8);

  913.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  914. 

  915.                 vis_padd16(TMP10, TMP14, TMP10);

  916.                 vis_pack16(TMP0, DST_0);

  917. 

  918.                 vis_pack16(TMP2, DST_1);

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

  920.                 dest += stride;

  921.                 vis_padd16(TMP10, CONST_3, TMP10);

  922. 

  923.                 vis_ld64_2(dest, stride, DST_0);

  924.                 vis_padd16(TMP8, TMP16, TMP8);

  925. 

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

  927.                 vis_padd16(TMP10, TMP18, TMP10);

  928.                 vis_pack16(TMP8, DST_2);

  929. 

  930.                 vis_pack16(TMP10, DST_3);

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

  932.                 dest += stride;

  933. 

  934.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  935.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  936. 

  937.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  938.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  939. 

  940.                 vis_padd16(TMP0, CONST_3, TMP0);

  941.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  942. 

  943.                 vis_padd16(TMP2, CONST_3, TMP2);

  944.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  945. 

  946.                 vis_padd16(TMP0, TMP24, TMP0);

  947.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  948. 

  949.                 vis_padd16(TMP2, TMP6, TMP2);

  950.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  951. 

  952.                 vis_padd16(TMP8, CONST_3, TMP8);

  953.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  954. 

  955.                 vis_padd16(TMP10, CONST_3, TMP10);

  956.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  957. 

  958.                 vis_padd16(TMP8, TMP12, TMP8);

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

  960. 

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

  962.                 vis_padd16(TMP0, TMP16, TMP0);

  963. 

  964.                 vis_padd16(TMP2, TMP18, TMP2);

  965.                 vis_pack16(TMP0, DST_0);

  966. 

  967.                 vis_padd16(TMP10, TMP14, TMP10);

  968.                 vis_pack16(TMP2, DST_1);

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

  970.                 dest += stride;

  971. 

  972.                 vis_padd16(TMP8, TMP20, TMP8);

  973. 

  974.                 vis_padd16(TMP10, TMP22, TMP10);

  975.                 vis_pack16(TMP8, DST_2);

  976. 

  977.                 vis_pack16(TMP10, DST_3);

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

  979.                 dest += stride;

  980.         } while (--height);

  981. }

  982. 

  983. static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * ref,

  984.                              const ptrdiff_t stride, int height)

  985. {

  986.         ref = vis_alignaddr(ref);

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

  988. 

  989.         vis_ld64_2(ref, 8, TMP2);

  990. 

  991.         vis_ld64_2(ref, 16, TMP4);

  992.         ref += stride;

  993. 

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

  995.         vis_faligndata(TMP0, TMP2, REF_0);

  996. 

  997.         vis_ld64_2(ref, 8, TMP8);

  998.         vis_faligndata(TMP2, TMP4, REF_4);

  999. 

  1000.         vis_ld64_2(ref, 16, TMP10);

  1001.         ref += stride;

  1002. 

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

  1004.         vis_faligndata(TMP6, TMP8, REF_2);

  1005. 

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

  1007.         vis_faligndata(TMP8, TMP10, REF_6);

  1008. 

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

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

  1011.         do {    /* 24 cycles */

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

  1013.                 vis_xor(REF_0, REF_2, TMP12);

  1014. 

  1015.                 vis_ld64_2(ref, 8, TMP2);

  1016.                 vis_xor(REF_4, REF_6, TMP16);

  1017. 

  1018.                 vis_ld64_2(ref, 16, TMP4);

  1019.                 ref += stride;

  1020.                 vis_or(REF_0, REF_2, TMP14);

  1021. 

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

  1023.                 vis_or(REF_4, REF_6, TMP18);

  1024. 

  1025.                 vis_ld64_2(ref, 8, TMP8);

  1026.                 vis_faligndata(TMP0, TMP2, REF_0);

  1027. 

  1028.                 vis_ld64_2(ref, 16, TMP10);

  1029.                 ref += stride;

  1030.                 vis_faligndata(TMP2, TMP4, REF_4);

  1031. 

  1032.                 vis_and(TMP12, MASK_fe, TMP12);

  1033. 

  1034.                 vis_and(TMP16, MASK_fe, TMP16);

  1035.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1036. 

  1037.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  1038.                 vis_xor(REF_0, REF_2, TMP0);

  1039. 

  1040.                 vis_xor(REF_4, REF_6, TMP2);

  1041. 

  1042.                 vis_or(REF_0, REF_2, TMP20);

  1043. 

  1044.                 vis_and(TMP12, MASK_7f, TMP12);

  1045. 

  1046.                 vis_and(TMP16, MASK_7f, TMP16);

  1047. 

  1048.                 vis_psub16(TMP14, TMP12, TMP12);

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

  1050. 

  1051.                 vis_psub16(TMP18, TMP16, TMP16);

  1052.                 vis_st64_2(TMP16, dest, 8);

  1053.                 dest += stride;

  1054. 

  1055.                 vis_or(REF_4, REF_6, TMP18);

  1056. 

  1057.                 vis_and(TMP0, MASK_fe, TMP0);

  1058. 

  1059.                 vis_and(TMP2, MASK_fe, TMP2);

  1060.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  1061. 

  1062.                 vis_faligndata(TMP6, TMP8, REF_2);

  1063.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  1064. 

  1065.                 vis_faligndata(TMP8, TMP10, REF_6);

  1066. 

  1067.                 vis_and(TMP0, MASK_7f, TMP0);

  1068. 

  1069.                 vis_and(TMP2, MASK_7f, TMP2);

  1070. 

  1071.                 vis_psub16(TMP20, TMP0, TMP0);

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

  1073. 

  1074.                 vis_psub16(TMP18, TMP2, TMP2);

  1075.                 vis_st64_2(TMP2, dest, 8);

  1076.                 dest += stride;

  1077.         } while (--height);

  1078. 

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

  1080.         vis_xor(REF_0, REF_2, TMP12);

  1081. 

  1082.         vis_ld64_2(ref, 8, TMP2);

  1083.         vis_xor(REF_4, REF_6, TMP16);

  1084. 

  1085.         vis_ld64_2(ref, 16, TMP4);

  1086.         vis_or(REF_0, REF_2, TMP14);

  1087. 

  1088.         vis_or(REF_4, REF_6, TMP18);

  1089. 

  1090.         vis_faligndata(TMP0, TMP2, REF_0);

  1091. 

  1092.         vis_faligndata(TMP2, TMP4, REF_4);

  1093. 

  1094.         vis_and(TMP12, MASK_fe, TMP12);

  1095. 

  1096.         vis_and(TMP16, MASK_fe, TMP16);

  1097.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1098. 

  1099.         vis_mul8x16(CONST_128, TMP16, TMP16);

  1100.         vis_xor(REF_0, REF_2, TMP0);

  1101. 

  1102.         vis_xor(REF_4, REF_6, TMP2);

  1103. 

  1104.         vis_or(REF_0, REF_2, TMP20);

  1105. 

  1106.         vis_and(TMP12, MASK_7f, TMP12);

  1107. 

  1108.         vis_and(TMP16, MASK_7f, TMP16);

  1109. 

  1110.         vis_psub16(TMP14, TMP12, TMP12);

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

  1112. 

  1113.         vis_psub16(TMP18, TMP16, TMP16);

  1114.         vis_st64_2(TMP16, dest, 8);

  1115.         dest += stride;

  1116. 

  1117.         vis_or(REF_4, REF_6, TMP18);

  1118. 

  1119.         vis_and(TMP0, MASK_fe, TMP0);

  1120. 

  1121.         vis_and(TMP2, MASK_fe, TMP2);

  1122.         vis_mul8x16(CONST_128, TMP0, TMP0);

  1123. 

  1124.         vis_mul8x16(CONST_128, TMP2, TMP2);

  1125. 

  1126.         vis_and(TMP0, MASK_7f, TMP0);

  1127. 

  1128.         vis_and(TMP2, MASK_7f, TMP2);

  1129. 

  1130.         vis_psub16(TMP20, TMP0, TMP0);

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

  1132. 

  1133.         vis_psub16(TMP18, TMP2, TMP2);

  1134.         vis_st64_2(TMP2, dest, 8);

  1135. }

  1136. 

  1137. static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * ref,

  1138.                             const ptrdiff_t stride, int height)

  1139. {

  1140.         ref = vis_alignaddr(ref);

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

  1142. 

  1143.         vis_ld64_2(ref, 8, TMP2);

  1144.         ref += stride;

  1145. 

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

  1147. 

  1148.         vis_ld64_2(ref, 8, TMP6);

  1149.         ref += stride;

  1150. 

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

  1152.         vis_faligndata(TMP0, TMP2, REF_0);

  1153. 

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

  1155.         vis_faligndata(TMP4, TMP6, REF_2);

  1156. 

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

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

  1159.         do {    /* 12 cycles */

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

  1161.                 vis_xor(REF_0, REF_2, TMP4);

  1162. 

  1163.                 vis_ld64_2(ref, 8, TMP2);

  1164.                 ref += stride;

  1165.                 vis_and(TMP4, MASK_fe, TMP4);

  1166. 

  1167.                 vis_or(REF_0, REF_2, TMP6);

  1168.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  1169. 

  1170.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  1172. 

  1173.                 vis_ld64_2(ref, 8, TMP2);

  1174.                 ref += stride;

  1175.                 vis_xor(REF_0, REF_2, TMP12);

  1176. 

  1177.                 vis_and(TMP4, MASK_7f, TMP4);

  1178. 

  1179.                 vis_and(TMP12, MASK_fe, TMP12);

  1180. 

  1181.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1182.                 vis_or(REF_0, REF_2, TMP14);

  1183. 

  1184.                 vis_psub16(TMP6, TMP4, DST_0);

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

  1186.                 dest += stride;

  1187. 

  1188.                 vis_faligndata(TMP0, TMP2, REF_2);

  1189. 

  1190.                 vis_and(TMP12, MASK_7f, TMP12);

  1191. 

  1192.                 vis_psub16(TMP14, TMP12, DST_0);

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

  1194.                 dest += stride;

  1195.         } while (--height);

  1196. 

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

  1198.         vis_xor(REF_0, REF_2, TMP4);

  1199. 

  1200.         vis_ld64_2(ref, 8, TMP2);

  1201.         vis_and(TMP4, MASK_fe, TMP4);

  1202. 

  1203.         vis_or(REF_0, REF_2, TMP6);

  1204.         vis_mul8x16(CONST_128, TMP4, TMP4);

  1205. 

  1206.         vis_faligndata(TMP0, TMP2, REF_0);

  1207. 

  1208.         vis_xor(REF_0, REF_2, TMP12);

  1209. 

  1210.         vis_and(TMP4, MASK_7f, TMP4);

  1211. 

  1212.         vis_and(TMP12, MASK_fe, TMP12);

  1213. 

  1214.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1215.         vis_or(REF_0, REF_2, TMP14);

  1216. 

  1217.         vis_psub16(TMP6, TMP4, DST_0);

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

  1219.         dest += stride;

  1220. 

  1221.         vis_and(TMP12, MASK_7f, TMP12);

  1222. 

  1223.         vis_psub16(TMP14, TMP12, DST_0);

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

  1225. }

  1226. 

  1227. static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * ref,

  1228.                              const ptrdiff_t stride, int height)

  1229. {

  1230.         int stride_8 = stride + 8;

  1231.         int stride_16 = stride + 16;

  1232. 

  1233.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1234. 

  1235.         ref = vis_alignaddr(ref);

  1236. 

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

  1238.         vis_fzero(ZERO);

  1239. 

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

  1241. 

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

  1243. 

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

  1245.         vis_faligndata(TMP0, TMP2, REF_2);

  1246. 

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

  1248.         vis_faligndata(TMP2, TMP4, REF_6);

  1249.         height >>= 1;

  1250. 

  1251.         do {    /* 31 cycles */

  1252.                 vis_ld64_2(ref, stride, TMP0);

  1253.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  1254.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  1255. 

  1256.                 vis_ld64_2(ref, stride_8, TMP2);

  1257.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  1258.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  1259. 

  1260.                 vis_ld64_2(ref, stride_16, TMP4);

  1261.                 ref += stride;

  1262. 

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

  1264.                 vis_faligndata(TMP0, TMP2, REF_0);

  1265. 

  1266.                 vis_ld64_2(dest, 8, DST_2);

  1267.                 vis_faligndata(TMP2, TMP4, REF_4);

  1268. 

  1269.                 vis_ld64_2(ref, stride, TMP6);

  1270.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  1271.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  1272. 

  1273.                 vis_ld64_2(ref, stride_8, TMP8);

  1274.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  1275. 

  1276.                 vis_ld64_2(ref, stride_16, TMP10);

  1277.                 ref += stride;

  1278. 

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

  1280.                 vis_faligndata(TMP6, TMP8, REF_2);

  1281.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1282. 

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

  1284.                 vis_faligndata(TMP8, TMP10, REF_6);

  1285.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  1286. 

  1287.                 vis_padd16(TMP0, CONST_3, TMP0);

  1288.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  1289. 

  1290.                 vis_padd16(TMP2, CONST_3, TMP2);

  1291.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1292. 

  1293.                 vis_padd16(TMP4, CONST_3, TMP4);

  1294.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1295. 

  1296.                 vis_padd16(TMP6, CONST_3, TMP6);

  1297. 

  1298.                 vis_padd16(TMP12, TMP20, TMP12);

  1299.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  1300. 

  1301.                 vis_padd16(TMP14, TMP22, TMP14);

  1302.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  1303. 

  1304.                 vis_padd16(TMP16, TMP24, TMP16);

  1305.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  1306. 

  1307.                 vis_padd16(TMP18, TMP26, TMP18);

  1308.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  1309. 

  1310.                 vis_padd16(TMP12, TMP0, TMP12);

  1311.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  1312. 

  1313.                 vis_padd16(TMP14, TMP2, TMP14);

  1314.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  1315. 

  1316.                 vis_padd16(TMP16, TMP4, TMP16);

  1317.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  1318. 

  1319.                 vis_padd16(TMP18, TMP6, TMP18);

  1320.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  1321. 

  1322.                 vis_pack16(TMP12, DST_0);

  1323.                 vis_padd16(TMP28, TMP0, TMP12);

  1324. 

  1325.                 vis_pack16(TMP14, DST_1);

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

  1327.                 vis_padd16(TMP30, TMP2, TMP14);

  1328. 

  1329.                 vis_pack16(TMP16, DST_2);

  1330.                 vis_padd16(REF_S4, TMP4, TMP16);

  1331. 

  1332.                 vis_pack16(TMP18, DST_3);

  1333.                 vis_st64_2(DST_2, dest, 8);

  1334.                 dest += stride;

  1335.                 vis_padd16(REF_S6, TMP6, TMP18);

  1336. 

  1337.                 vis_padd16(TMP12, TMP20, TMP12);

  1338. 

  1339.                 vis_padd16(TMP14, TMP22, TMP14);

  1340.                 vis_pack16(TMP12, DST_0);

  1341. 

  1342.                 vis_padd16(TMP16, TMP24, TMP16);

  1343.                 vis_pack16(TMP14, DST_1);

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

  1345. 

  1346.                 vis_padd16(TMP18, TMP26, TMP18);

  1347.                 vis_pack16(TMP16, DST_2);

  1348. 

  1349.                 vis_pack16(TMP18, DST_3);

  1350.                 vis_st64_2(DST_2, dest, 8);

  1351.                 dest += stride;

  1352.         } while (--height);

  1353. }

  1354. 

  1355. static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * ref,

  1356.                             const ptrdiff_t stride, int height)

  1357. {

  1358.         int stride_8 = stride + 8;

  1359. 

  1360.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1361. 

  1362.         ref = vis_alignaddr(ref);

  1363. 

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

  1365.         vis_fzero(ZERO);

  1366. 

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

  1368. 

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

  1370.         vis_faligndata(TMP0, TMP2, REF_2);

  1371. 

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

  1373. 

  1374.         height >>= 1;

  1375.         do {    /* 20 cycles */

  1376.                 vis_ld64_2(ref, stride, TMP0);

  1377.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  1378.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  1379. 

  1380.                 vis_ld64_2(ref, stride_8, TMP2);

  1381.                 ref += stride;

  1382. 

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

  1384. 

  1385.                 vis_ld64_2(dest, stride, DST_2);

  1386.                 vis_faligndata(TMP0, TMP2, REF_0);

  1387. 

  1388.                 vis_ld64_2(ref, stride, TMP4);

  1389.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  1390.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  1391. 

  1392.                 vis_ld64_2(ref, stride_8, TMP6);

  1393.                 ref += stride;

  1394.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  1395.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  1396. 

  1397.                 vis_padd16(TMP12, CONST_3, TMP12);

  1398.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1399. 

  1400.                 vis_padd16(TMP14, CONST_3, TMP14);

  1401.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1402. 

  1403.                 vis_faligndata(TMP4, TMP6, REF_2);

  1404. 

  1405.                 vis_padd16(TMP8, TMP12, TMP8);

  1406. 

  1407.                 vis_padd16(TMP10, TMP14, TMP10);

  1408.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  1409. 

  1410.                 vis_padd16(TMP8, TMP16, TMP0);

  1411.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  1412. 

  1413.                 vis_padd16(TMP10, TMP18, TMP2);

  1414.                 vis_pack16(TMP0, DST_0);

  1415. 

  1416.                 vis_pack16(TMP2, DST_1);

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

  1418.                 dest += stride;

  1419.                 vis_padd16(TMP12, TMP20, TMP12);

  1420. 

  1421.                 vis_padd16(TMP14, TMP22, TMP14);

  1422. 

  1423.                 vis_padd16(TMP12, TMP24, TMP0);

  1424. 

  1425.                 vis_padd16(TMP14, TMP26, TMP2);

  1426.                 vis_pack16(TMP0, DST_2);

  1427. 

  1428.                 vis_pack16(TMP2, DST_3);

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

  1430.                 dest += stride;

  1431.         } while (--height);

  1432. }

  1433. 

  1434. static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * ref,

  1435.                               const ptrdiff_t stride, int height)

  1436. {

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

  1438.         unsigned long off_plus_1 = off + 1;

  1439.         int stride_8 = stride + 8;

  1440.         int stride_16 = stride + 16;

  1441. 

  1442.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1443. 

  1444.         ref = vis_alignaddr(ref);

  1445. 

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

  1447.         vis_fzero(ZERO);

  1448. 

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

  1450. 

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

  1452. 

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

  1454.         vis_faligndata(TMP0, TMP2, REF_S0);

  1455. 

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

  1457.         vis_faligndata(TMP2, TMP4, REF_S4);

  1458. 

  1459.         if (off != 0x7) {

  1460.                 vis_alignaddr_g0((void *)off_plus_1);

  1461.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1462.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1463.         } else {

  1464.                 vis_src1(TMP2, REF_S2);

  1465.                 vis_src1(TMP4, REF_S6);

  1466.         }

  1467. 

  1468.         height >>= 1;

  1469.         do {

  1470.                 vis_ld64_2(ref, stride, TMP0);

  1471.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1472.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1473. 

  1474.                 vis_alignaddr_g0((void *)off);

  1475. 

  1476.                 vis_ld64_2(ref, stride_8, TMP2);

  1477.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1478.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1479. 

  1480.                 vis_ld64_2(ref, stride_16, TMP4);

  1481.                 ref += stride;

  1482.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1483.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1484. 

  1485.                 vis_ld64_2(ref, stride, TMP6);

  1486.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1487.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1488. 

  1489.                 vis_ld64_2(ref, stride_8, TMP8);

  1490.                 vis_faligndata(TMP0, TMP2, REF_0);

  1491. 

  1492.                 vis_ld64_2(ref, stride_16, TMP10);

  1493.                 ref += stride;

  1494.                 vis_faligndata(TMP2, TMP4, REF_4);

  1495. 

  1496.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1497. 

  1498.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1499. 

  1500.                 if (off != 0x7) {

  1501.                         vis_alignaddr_g0((void *)off_plus_1);

  1502.                         vis_faligndata(TMP0, TMP2, REF_2);

  1503.                         vis_faligndata(TMP2, TMP4, REF_6);

  1504.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1505.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1506.                 } else {

  1507.                         vis_src1(TMP2, REF_2);

  1508.                         vis_src1(TMP4, REF_6);

  1509.                         vis_src1(TMP8, REF_S2);

  1510.                         vis_src1(TMP10, REF_S6);

  1511.                 }

  1512. 

  1513.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  1514.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1515. 

  1516.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1517.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1518. 

  1519.                 vis_padd16(TMP0, CONST_2, TMP8);

  1520.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  1521. 

  1522.                 vis_padd16(TMP2, CONST_2, TMP10);

  1523.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  1524. 

  1525.                 vis_padd16(TMP8, TMP4, TMP8);

  1526.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  1527. 

  1528.                 vis_padd16(TMP10, TMP6, TMP10);

  1529.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  1530. 

  1531.                 vis_padd16(TMP12, TMP8, TMP12);

  1532. 

  1533.                 vis_padd16(TMP14, TMP10, TMP14);

  1534. 

  1535.                 vis_padd16(TMP12, TMP16, TMP12);

  1536. 

  1537.                 vis_padd16(TMP14, TMP18, TMP14);

  1538.                 vis_pack16(TMP12, DST_0);

  1539. 

  1540.                 vis_pack16(TMP14, DST_1);

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

  1542.                 vis_padd16(TMP0, CONST_2, TMP12);

  1543. 

  1544.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  1545.                 vis_padd16(TMP2, CONST_2, TMP14);

  1546. 

  1547.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  1548.                 vis_padd16(TMP12, TMP4, TMP12);

  1549. 

  1550.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  1551.                 vis_padd16(TMP14, TMP6, TMP14);

  1552. 

  1553.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  1554.                 vis_padd16(TMP20, TMP12, TMP20);

  1555. 

  1556.                 vis_padd16(TMP22, TMP14, TMP22);

  1557. 

  1558.                 vis_padd16(TMP20, TMP24, TMP20);

  1559. 

  1560.                 vis_padd16(TMP22, TMP26, TMP22);

  1561.                 vis_pack16(TMP20, DST_2);

  1562. 

  1563.                 vis_pack16(TMP22, DST_3);

  1564.                 vis_st64_2(DST_2, dest, 8);

  1565.                 dest += stride;

  1566.                 vis_padd16(TMP0, TMP4, TMP24);

  1567. 

  1568.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  1569.                 vis_padd16(TMP2, TMP6, TMP26);

  1570. 

  1571.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  1572.                 vis_padd16(TMP24, TMP8, TMP24);

  1573. 

  1574.                 vis_padd16(TMP26, TMP10, TMP26);

  1575.                 vis_pack16(TMP24, DST_0);

  1576. 

  1577.                 vis_pack16(TMP26, DST_1);

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

  1579.                 vis_pmerge(ZERO, REF_S6, TMP4);

  1580. 

  1581.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  1582. 

  1583.                 vis_padd16(TMP0, TMP4, TMP0);

  1584. 

  1585.                 vis_padd16(TMP2, TMP6, TMP2);

  1586. 

  1587.                 vis_padd16(TMP0, TMP12, TMP0);

  1588. 

  1589.                 vis_padd16(TMP2, TMP14, TMP2);

  1590.                 vis_pack16(TMP0, DST_2);

  1591. 

  1592.                 vis_pack16(TMP2, DST_3);

  1593.                 vis_st64_2(DST_2, dest, 8);

  1594.                 dest += stride;

  1595.         } while (--height);

  1596. }

  1597. 

  1598. static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * ref,

  1599.                              const ptrdiff_t stride, int height)

  1600. {

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

  1602.         unsigned long off_plus_1 = off + 1;

  1603.         int stride_8 = stride + 8;

  1604. 

  1605.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1606. 

  1607.         ref = vis_alignaddr(ref);

  1608. 

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

  1610.         vis_fzero(ZERO);

  1611. 

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

  1613. 

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

  1615. 

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

  1617.         vis_faligndata(TMP0, TMP2, REF_S0);

  1618. 

  1619.         if (off != 0x7) {

  1620.                 vis_alignaddr_g0((void *)off_plus_1);

  1621.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1622.         } else {

  1623.                 vis_src1(TMP2, REF_S2);

  1624.         }

  1625. 

  1626.         height >>= 1;

  1627.         do {    /* 26 cycles */

  1628.                 vis_ld64_2(ref, stride, TMP0);

  1629.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  1630.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  1631. 

  1632.                 vis_alignaddr_g0((void *)off);

  1633. 

  1634.                 vis_ld64_2(ref, stride_8, TMP2);

  1635.                 ref += stride;

  1636.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  1637.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  1638. 

  1639.                 vis_ld64_2(ref, stride, TMP4);

  1640. 

  1641.                 vis_ld64_2(ref, stride_8, TMP6);

  1642.                 ref += stride;

  1643.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1644. 

  1645.                 vis_pmerge(ZERO, REF_S4, TMP18);

  1646. 

  1647.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  1648. 

  1649.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1650. 

  1651.                 if (off != 0x7) {

  1652.                         vis_alignaddr_g0((void *)off_plus_1);

  1653.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1654.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1655.                 } else {

  1656.                         vis_src1(TMP2, REF_S6);

  1657.                         vis_src1(TMP6, REF_S2);

  1658.                 }

  1659. 

  1660.                 vis_padd16(TMP18, CONST_2, TMP18);

  1661.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  1662. 

  1663.                 vis_padd16(TMP20, CONST_2, TMP20);

  1664.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  1665. 

  1666.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  1667.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  1668. 

  1669.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  1670.                 vis_padd16(TMP18, TMP22, TMP18);

  1671. 

  1672.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  1673.                 vis_padd16(TMP20, TMP24, TMP20);

  1674. 

  1675.                 vis_padd16(TMP8,  TMP18, TMP8);

  1676. 

  1677.                 vis_padd16(TMP10, TMP20, TMP10);

  1678. 

  1679.                 vis_padd16(TMP8,  TMP12, TMP8);

  1680. 

  1681.                 vis_padd16(TMP10, TMP14, TMP10);

  1682.                 vis_pack16(TMP8,  DST_0);

  1683. 

  1684.                 vis_pack16(TMP10, DST_1);

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

  1686.                 dest += stride;

  1687.                 vis_padd16(TMP18, TMP26, TMP18);

  1688. 

  1689.                 vis_padd16(TMP20, TMP28, TMP20);

  1690. 

  1691.                 vis_padd16(TMP18, TMP30, TMP18);

  1692. 

  1693.                 vis_padd16(TMP20, TMP32, TMP20);

  1694.                 vis_pack16(TMP18, DST_2);

  1695. 

  1696.                 vis_pack16(TMP20, DST_3);

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

  1698.                 dest += stride;

  1699.         } while (--height);

  1700. }

  1701. 

  1702. static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * ref,

  1703.                               const ptrdiff_t stride, int height)

  1704. {

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

  1706.         unsigned long off_plus_1 = off + 1;

  1707.         int stride_8 = stride + 8;

  1708.         int stride_16 = stride + 16;

  1709. 

  1710.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1711. 

  1712.         ref = vis_alignaddr(ref);

  1713. 

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

  1715.         vis_fzero(ZERO);

  1716. 

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

  1718. 

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

  1720. 

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

  1722.         vis_faligndata(TMP0, TMP2, REF_S0);

  1723. 

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

  1725.         vis_faligndata(TMP2, TMP4, REF_S4);

  1726. 

  1727.         if (off != 0x7) {

  1728.                 vis_alignaddr_g0((void *)off_plus_1);

  1729.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1730.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1731.         } else {

  1732.                 vis_src1(TMP2, REF_S2);

  1733.                 vis_src1(TMP4, REF_S6);

  1734.         }

  1735. 

  1736.         height >>= 1;

  1737.         do {    /* 55 cycles */

  1738.                 vis_ld64_2(ref, stride, TMP0);

  1739.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1740.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1741. 

  1742.                 vis_alignaddr_g0((void *)off);

  1743. 

  1744.                 vis_ld64_2(ref, stride_8, TMP2);

  1745.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1746.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1747. 

  1748.                 vis_ld64_2(ref, stride_16, TMP4);

  1749.                 ref += stride;

  1750.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1751.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1752. 

  1753.                 vis_ld64_2(ref, stride, TMP6);

  1754.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1755.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1756. 

  1757.                 vis_ld64_2(ref, stride_8, TMP8);

  1758.                 vis_faligndata(TMP0, TMP2, REF_0);

  1759. 

  1760.                 vis_ld64_2(ref, stride_16, TMP10);

  1761.                 ref += stride;

  1762.                 vis_faligndata(TMP2, TMP4, REF_4);

  1763. 

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

  1765.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1766. 

  1767.                 vis_ld64_2(dest, 8, DST_2);

  1768.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1769. 

  1770.                 if (off != 0x7) {

  1771.                         vis_alignaddr_g0((void *)off_plus_1);

  1772.                         vis_faligndata(TMP0, TMP2, REF_2);

  1773.                         vis_faligndata(TMP2, TMP4, REF_6);

  1774.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1775.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1776.                 } else {

  1777.                         vis_src1(TMP2, REF_2);

  1778.                         vis_src1(TMP4, REF_6);

  1779.                         vis_src1(TMP8, REF_S2);

  1780.                         vis_src1(TMP10, REF_S6);

  1781.                 }

  1782. 

  1783.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1784.                 vis_pmerge(ZERO, REF_0, TMP0);

  1785. 

  1786.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1787.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1788. 

  1789.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1790.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1791. 

  1792.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1793.                 vis_padd16(TMP0, CONST_6, TMP0);

  1794. 

  1795.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1796.                 vis_padd16(TMP2, CONST_6, TMP2);

  1797. 

  1798.                 vis_padd16(TMP0, TMP4, TMP0);

  1799.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  1800. 

  1801.                 vis_padd16(TMP2, TMP6, TMP2);

  1802.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1803. 

  1804.                 vis_padd16(TMP12, TMP0, TMP12);

  1805.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  1806. 

  1807.                 vis_padd16(TMP14, TMP2, TMP14);

  1808.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  1809. 

  1810.                 vis_padd16(TMP12, TMP16, TMP12);

  1811.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  1812. 

  1813.                 vis_padd16(TMP14, TMP18, TMP14);

  1814.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  1815. 

  1816.                 vis_padd16(TMP12, TMP30, TMP12);

  1817. 

  1818.                 vis_padd16(TMP14, TMP32, TMP14);

  1819.                 vis_pack16(TMP12, DST_0);

  1820. 

  1821.                 vis_pack16(TMP14, DST_1);

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

  1823.                 vis_padd16(TMP4, CONST_6, TMP4);

  1824. 

  1825.                 vis_ld64_2(dest, stride, DST_0);

  1826.                 vis_padd16(TMP6, CONST_6, TMP6);

  1827.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1828. 

  1829.                 vis_padd16(TMP4, TMP8, TMP4);

  1830.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  1831. 

  1832.                 vis_padd16(TMP6, TMP10, TMP6);

  1833. 

  1834.                 vis_padd16(TMP20, TMP4, TMP20);

  1835. 

  1836.                 vis_padd16(TMP22, TMP6, TMP22);

  1837. 

  1838.                 vis_padd16(TMP20, TMP24, TMP20);

  1839. 

  1840.                 vis_padd16(TMP22, TMP26, TMP22);

  1841. 

  1842.                 vis_padd16(TMP20, REF_0, TMP20);

  1843.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  1844. 

  1845.                 vis_padd16(TMP22, REF_2, TMP22);

  1846.                 vis_pack16(TMP20, DST_2);

  1847. 

  1848.                 vis_pack16(TMP22, DST_3);

  1849.                 vis_st64_2(DST_2, dest, 8);

  1850.                 dest += stride;

  1851. 

  1852.                 vis_ld64_2(dest, 8, DST_2);

  1853.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1854.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  1855. 

  1856.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1857.                 vis_padd16(REF_4, TMP0, TMP8);

  1858. 

  1859.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  1860.                 vis_padd16(REF_6, TMP2, TMP10);

  1861. 

  1862.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  1863.                 vis_padd16(TMP8, TMP12, TMP8);

  1864. 

  1865.                 vis_padd16(TMP10, TMP14, TMP10);

  1866. 

  1867.                 vis_padd16(TMP8, TMP30, TMP8);

  1868. 

  1869.                 vis_padd16(TMP10, TMP32, TMP10);

  1870.                 vis_pack16(TMP8, DST_0);

  1871. 

  1872.                 vis_pack16(TMP10, DST_1);

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

  1874. 

  1875.                 vis_padd16(REF_0, TMP4, REF_0);

  1876. 

  1877.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  1878.                 vis_padd16(REF_2, TMP6, REF_2);

  1879. 

  1880.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  1881.                 vis_padd16(REF_0, REF_4, REF_0);

  1882. 

  1883.                 vis_padd16(REF_2, REF_6, REF_2);

  1884. 

  1885.                 vis_padd16(REF_0, TMP30, REF_0);

  1886. 

  1887.                 /* stall */

  1888. 

  1889.                 vis_padd16(REF_2, TMP32, REF_2);

  1890.                 vis_pack16(REF_0, DST_2);

  1891. 

  1892.                 vis_pack16(REF_2, DST_3);

  1893.                 vis_st64_2(DST_2, dest, 8);

  1894.                 dest += stride;

  1895.         } while (--height);

  1896. }

  1897. 

  1898. static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * ref,

  1899.                              const ptrdiff_t stride, int height)

  1900. {

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

  1902.         unsigned long off_plus_1 = off + 1;

  1903.         int stride_8 = stride + 8;

  1904. 

  1905.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1906. 

  1907.         ref = vis_alignaddr(ref);

  1908. 

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

  1910.         vis_fzero(ZERO);

  1911. 

  1912.         vis_ld64_2(ref, 8, TMP2);

  1913. 

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

  1915. 

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

  1917.         vis_faligndata(TMP0, TMP2, REF_S0);

  1918. 

  1919.         if (off != 0x7) {

  1920.                 vis_alignaddr_g0((void *)off_plus_1);

  1921.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1922.         } else {

  1923.                 vis_src1(TMP2, REF_S2);

  1924.         }

  1925. 

  1926.         height >>= 1;

  1927.         do {    /* 31 cycles */

  1928.                 vis_ld64_2(ref, stride, TMP0);

  1929.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  1930.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  1931. 

  1932.                 vis_ld64_2(ref, stride_8, TMP2);

  1933.                 ref += stride;

  1934.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1935.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  1936. 

  1937.                 vis_alignaddr_g0((void *)off);

  1938. 

  1939.                 vis_ld64_2(ref, stride, TMP4);

  1940.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1941. 

  1942.                 vis_ld64_2(ref, stride_8, TMP6);

  1943.                 ref += stride;

  1944. 

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

  1946.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1947. 

  1948.                 vis_ld64_2(dest, stride, DST_2);

  1949. 

  1950.                 if (off != 0x7) {

  1951.                         vis_alignaddr_g0((void *)off_plus_1);

  1952.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1953.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1954.                 } else {

  1955.                         vis_src1(TMP2, REF_S6);

  1956.                         vis_src1(TMP6, REF_S2);

  1957.                 }

  1958. 

  1959.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1960.                 vis_pmerge(ZERO, REF_S4, TMP22);

  1961. 

  1962.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1963.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  1964. 

  1965.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  1966.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  1967. 

  1968.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  1969.                 vis_padd16(TMP22, CONST_6, TMP22);

  1970. 

  1971.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  1972.                 vis_padd16(TMP24, CONST_6, TMP24);

  1973. 

  1974.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1975.                 vis_padd16(TMP22, TMP26, TMP22);

  1976. 

  1977.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1978.                 vis_padd16(TMP24, TMP28, TMP24);

  1979. 

  1980.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  1981.                 vis_padd16(TMP8, TMP22, TMP8);

  1982. 

  1983.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  1984.                 vis_padd16(TMP10, TMP24, TMP10);

  1985. 

  1986.                 vis_padd16(TMP8, TMP12, TMP8);

  1987. 

  1988.                 vis_padd16(TMP10, TMP14, TMP10);

  1989. 

  1990.                 vis_padd16(TMP8, TMP30, TMP8);

  1991. 

  1992.                 vis_padd16(TMP10, TMP32, TMP10);

  1993.                 vis_pack16(TMP8, DST_0);

  1994. 

  1995.                 vis_pack16(TMP10, DST_1);

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

  1997.                 dest += stride;

  1998. 

  1999.                 vis_padd16(REF_S4, TMP22, TMP12);

  2000. 

  2001.                 vis_padd16(REF_S6, TMP24, TMP14);

  2002. 

  2003.                 vis_padd16(TMP12, TMP26, TMP12);

  2004. 

  2005.                 vis_padd16(TMP14, TMP28, TMP14);

  2006. 

  2007.                 vis_padd16(TMP12, REF_0, TMP12);

  2008. 

  2009.                 vis_padd16(TMP14, REF_2, TMP14);

  2010.                 vis_pack16(TMP12, DST_2);

  2011. 

  2012.                 vis_pack16(TMP14, DST_3);

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

  2014.                 dest += stride;

  2015.         } while (--height);

  2016. }

  2017. 

  2018. /* End of rounding code */

  2019. 

  2020. /* Start of no rounding code */

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

  2022.  * motion comp code, which is:

  2023.  *

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

  2025.  *

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

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

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

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

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

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

  2032.  *

  2033.  *      fxor            f0,   f2, f10

  2034.  *      fand            f10,  f4, f10

  2035.  *      fmul8x16        f8,  f10, f10

  2036.  *      fand            f10,  f6, f10

  2037.  *      fand            f0,   f2, f12

  2038.  *      fpadd16         f12, f10, f10

  2039.  */

  2040. 

  2041. static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref,

  2042.                                       const ptrdiff_t stride, int height)

  2043. {

  2044.         ref = vis_alignaddr(ref);

  2045.         do {    /* 5 cycles */

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

  2047. 

  2048.                 vis_ld64_2(ref, 8, TMP2);

  2049. 

  2050.                 vis_ld64_2(ref, 16, TMP4);

  2051.                 ref += stride;

  2052. 

  2053.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2055. 

  2056.                 vis_faligndata(TMP2, TMP4, REF_2);

  2057.                 vis_st64_2(REF_2, dest, 8);

  2058.                 dest += stride;

  2059.         } while (--height);

  2060. }

  2061. 

  2062. static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref,

  2063.                                      const ptrdiff_t stride, int height)

  2064. {

  2065.         ref = vis_alignaddr(ref);

  2066.         do {    /* 4 cycles */

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

  2068. 

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

  2070.                 ref += stride;

  2071. 

  2072.                 /* stall */

  2073. 

  2074.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2076.                 dest += stride;

  2077.         } while (--height);

  2078. }

  2079. 

  2080. 

  2081. static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * ref,

  2082.                                       const ptrdiff_t stride, int height)

  2083. {

  2084.         int stride_8 = stride + 8;

  2085. 

  2086.         ref = vis_alignaddr(ref);

  2087. 

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

  2089. 

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

  2091. 

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

  2093. 

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

  2095. 

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

  2097. 

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

  2099.         vis_faligndata(TMP0, TMP2, REF_0);

  2100. 

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

  2102.         vis_faligndata(TMP2, TMP4, REF_2);

  2103. 

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

  2105. 

  2106.         ref += stride;

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

  2108. 

  2109.         do {    /* 24 cycles */

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

  2111.                 vis_xor(DST_0, REF_0, TMP6);

  2112. 

  2113.                 vis_ld64_2(ref, 8, TMP2);

  2114.                 vis_and(TMP6, MASK_fe, TMP6);

  2115. 

  2116.                 vis_ld64_2(ref, 16, TMP4);

  2117.                 ref += stride;

  2118.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2119.                 vis_xor(DST_2, REF_2, TMP8);

  2120. 

  2121.                 vis_and(TMP8, MASK_fe, TMP8);

  2122. 

  2123.                 vis_and(DST_0, REF_0, TMP10);

  2124.                 vis_ld64_2(dest, stride, DST_0);

  2125.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2126. 

  2127.                 vis_and(DST_2, REF_2, TMP12);

  2128.                 vis_ld64_2(dest, stride_8, DST_2);

  2129. 

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

  2131.                 vis_and(TMP6, MASK_7f, TMP6);

  2132. 

  2133.                 vis_and(TMP8, MASK_7f, TMP8);

  2134. 

  2135.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2137. 

  2138.                 vis_padd16(TMP12, TMP8, TMP8);

  2139.                 vis_st64_2(TMP8, dest, 8);

  2140. 

  2141.                 dest += stride;

  2142.                 vis_ld64_2(ref, 8, TMP16);

  2143.                 vis_faligndata(TMP0, TMP2, REF_0);

  2144. 

  2145.                 vis_ld64_2(ref, 16, TMP18);

  2146.                 vis_faligndata(TMP2, TMP4, REF_2);

  2147.                 ref += stride;

  2148. 

  2149.                 vis_xor(DST_0, REF_0, TMP20);

  2150. 

  2151.                 vis_and(TMP20, MASK_fe, TMP20);

  2152. 

  2153.                 vis_xor(DST_2, REF_2, TMP22);

  2154.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  2155. 

  2156.                 vis_and(TMP22, MASK_fe, TMP22);

  2157. 

  2158.                 vis_and(DST_0, REF_0, TMP24);

  2159.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  2160. 

  2161.                 vis_and(DST_2, REF_2, TMP26);

  2162. 

  2163.                 vis_ld64_2(dest, stride, DST_0);

  2164.                 vis_faligndata(TMP14, TMP16, REF_0);

  2165. 

  2166.                 vis_ld64_2(dest, stride_8, DST_2);

  2167.                 vis_faligndata(TMP16, TMP18, REF_2);

  2168. 

  2169.                 vis_and(TMP20, MASK_7f, TMP20);

  2170. 

  2171.                 vis_and(TMP22, MASK_7f, TMP22);

  2172. 

  2173.                 vis_padd16(TMP24, TMP20, TMP20);

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

  2175. 

  2176.                 vis_padd16(TMP26, TMP22, TMP22);

  2177.                 vis_st64_2(TMP22, dest, 8);

  2178.                 dest += stride;

  2179.         } while (--height);

  2180. 

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

  2182.         vis_xor(DST_0, REF_0, TMP6);

  2183. 

  2184.         vis_ld64_2(ref, 8, TMP2);

  2185.         vis_and(TMP6, MASK_fe, TMP6);

  2186. 

  2187.         vis_ld64_2(ref, 16, TMP4);

  2188.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2189.         vis_xor(DST_2, REF_2, TMP8);

  2190. 

  2191.         vis_and(TMP8, MASK_fe, TMP8);

  2192. 

  2193.         vis_and(DST_0, REF_0, TMP10);

  2194.         vis_ld64_2(dest, stride, DST_0);

  2195.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2196. 

  2197.         vis_and(DST_2, REF_2, TMP12);

  2198.         vis_ld64_2(dest, stride_8, DST_2);

  2199. 

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

  2201.         vis_and(TMP6, MASK_7f, TMP6);

  2202. 

  2203.         vis_and(TMP8, MASK_7f, TMP8);

  2204. 

  2205.         vis_padd16(TMP10, TMP6, TMP6);

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

  2207. 

  2208.         vis_padd16(TMP12, TMP8, TMP8);

  2209.         vis_st64_2(TMP8, dest, 8);

  2210. 

  2211.         dest += stride;

  2212.         vis_faligndata(TMP0, TMP2, REF_0);

  2213. 

  2214.         vis_faligndata(TMP2, TMP4, REF_2);

  2215. 

  2216.         vis_xor(DST_0, REF_0, TMP20);

  2217. 

  2218.         vis_and(TMP20, MASK_fe, TMP20);

  2219. 

  2220.         vis_xor(DST_2, REF_2, TMP22);

  2221.         vis_mul8x16(CONST_128, TMP20, TMP20);

  2222. 

  2223.         vis_and(TMP22, MASK_fe, TMP22);

  2224. 

  2225.         vis_and(DST_0, REF_0, TMP24);

  2226.         vis_mul8x16(CONST_128, TMP22, TMP22);

  2227. 

  2228.         vis_and(DST_2, REF_2, TMP26);

  2229. 

  2230.         vis_and(TMP20, MASK_7f, TMP20);

  2231. 

  2232.         vis_and(TMP22, MASK_7f, TMP22);

  2233. 

  2234.         vis_padd16(TMP24, TMP20, TMP20);

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

  2236. 

  2237.         vis_padd16(TMP26, TMP22, TMP22);

  2238.         vis_st64_2(TMP22, dest, 8);

  2239. }

  2240. 

  2241. static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref,

  2242.                                       const ptrdiff_t stride, int height)

  2243. {

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

  2245.         unsigned long off_plus_1 = off + 1;

  2246. 

  2247.         ref = vis_alignaddr(ref);

  2248. 

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

  2250. 

  2251.         vis_ld64_2(ref, 8,  TMP2);

  2252. 

  2253.         vis_ld64_2(ref, 16, TMP4);

  2254. 

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

  2256. 

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

  2258.         vis_faligndata(TMP0, TMP2, REF_0);

  2259. 

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

  2261.         vis_faligndata(TMP2, TMP4, REF_4);

  2262. 

  2263.         if (off != 0x7) {

  2264.                 vis_alignaddr_g0((void *)off_plus_1);

  2265.                 vis_faligndata(TMP0, TMP2, REF_2);

  2266.                 vis_faligndata(TMP2, TMP4, REF_6);

  2267.         } else {

  2268.                 vis_src1(TMP2, REF_2);

  2269.                 vis_src1(TMP4, REF_6);

  2270.         }

  2271. 

  2272.         ref += stride;

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

  2274. 

  2275.         do {    /* 34 cycles */

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

  2277.                 vis_xor(REF_0, REF_2, TMP6);

  2278. 

  2279.                 vis_ld64_2(ref, 8,  TMP2);

  2280.                 vis_xor(REF_4, REF_6, TMP8);

  2281. 

  2282.                 vis_ld64_2(ref, 16, TMP4);

  2283.                 vis_and(TMP6, MASK_fe, TMP6);

  2284.                 ref += stride;

  2285. 

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

  2287.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2288.                 vis_and(TMP8, MASK_fe, TMP8);

  2289. 

  2290.                 vis_ld64_2(ref, 8,  TMP16);

  2291.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2292.                 vis_and(REF_0, REF_2, TMP10);

  2293. 

  2294.                 vis_ld64_2(ref, 16, TMP18);

  2295.                 ref += stride;

  2296.                 vis_and(REF_4, REF_6, TMP12);

  2297. 

  2298.                 vis_alignaddr_g0((void *)off);

  2299. 

  2300.                 vis_faligndata(TMP0, TMP2, REF_0);

  2301. 

  2302.                 vis_faligndata(TMP2, TMP4, REF_4);

  2303. 

  2304.                 if (off != 0x7) {

  2305.                         vis_alignaddr_g0((void *)off_plus_1);

  2306.                         vis_faligndata(TMP0, TMP2, REF_2);

  2307.                         vis_faligndata(TMP2, TMP4, REF_6);

  2308.                 } else {

  2309.                         vis_src1(TMP2, REF_2);

  2310.                         vis_src1(TMP4, REF_6);

  2311.                 }

  2312. 

  2313.                 vis_and(TMP6, MASK_7f, TMP6);

  2314. 

  2315.                 vis_and(TMP8, MASK_7f, TMP8);

  2316. 

  2317.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2319. 

  2320.                 vis_padd16(TMP12, TMP8, TMP8);

  2321.                 vis_st64_2(TMP8, dest, 8);

  2322.                 dest += stride;

  2323. 

  2324.                 vis_xor(REF_0, REF_2, TMP6);

  2325. 

  2326.                 vis_xor(REF_4, REF_6, TMP8);

  2327. 

  2328.                 vis_and(TMP6, MASK_fe, TMP6);

  2329. 

  2330.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2331.                 vis_and(TMP8, MASK_fe, TMP8);

  2332. 

  2333.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2334.                 vis_and(REF_0, REF_2, TMP10);

  2335. 

  2336.                 vis_and(REF_4, REF_6, TMP12);

  2337. 

  2338.                 vis_alignaddr_g0((void *)off);

  2339. 

  2340.                 vis_faligndata(TMP14, TMP16, REF_0);

  2341. 

  2342.                 vis_faligndata(TMP16, TMP18, REF_4);

  2343. 

  2344.                 if (off != 0x7) {

  2345.                         vis_alignaddr_g0((void *)off_plus_1);

  2346.                         vis_faligndata(TMP14, TMP16, REF_2);

  2347.                         vis_faligndata(TMP16, TMP18, REF_6);

  2348.                 } else {

  2349.                         vis_src1(TMP16, REF_2);

  2350.                         vis_src1(TMP18, REF_6);

  2351.                 }

  2352. 

  2353.                 vis_and(TMP6, MASK_7f, TMP6);

  2354. 

  2355.                 vis_and(TMP8, MASK_7f, TMP8);

  2356. 

  2357.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2359. 

  2360.                 vis_padd16(TMP12, TMP8, TMP8);

  2361.                 vis_st64_2(TMP8, dest, 8);

  2362.                 dest += stride;

  2363.         } while (--height);

  2364. 

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

  2366.         vis_xor(REF_0, REF_2, TMP6);

  2367. 

  2368.         vis_ld64_2(ref, 8,  TMP2);

  2369.         vis_xor(REF_4, REF_6, TMP8);

  2370. 

  2371.         vis_ld64_2(ref, 16, TMP4);

  2372.         vis_and(TMP6, MASK_fe, TMP6);

  2373. 

  2374.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2375.         vis_and(TMP8, MASK_fe, TMP8);

  2376. 

  2377.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2378.         vis_and(REF_0, REF_2, TMP10);

  2379. 

  2380.         vis_and(REF_4, REF_6, TMP12);

  2381. 

  2382.         vis_alignaddr_g0((void *)off);

  2383. 

  2384.         vis_faligndata(TMP0, TMP2, REF_0);

  2385. 

  2386.         vis_faligndata(TMP2, TMP4, REF_4);

  2387. 

  2388.         if (off != 0x7) {

  2389.                 vis_alignaddr_g0((void *)off_plus_1);

  2390.                 vis_faligndata(TMP0, TMP2, REF_2);

  2391.                 vis_faligndata(TMP2, TMP4, REF_6);

  2392.         } else {

  2393.                 vis_src1(TMP2, REF_2);

  2394.                 vis_src1(TMP4, REF_6);

  2395.         }

  2396. 

  2397.         vis_and(TMP6, MASK_7f, TMP6);

  2398. 

  2399.         vis_and(TMP8, MASK_7f, TMP8);

  2400. 

  2401.         vis_padd16(TMP10, TMP6, TMP6);

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

  2403. 

  2404.         vis_padd16(TMP12, TMP8, TMP8);

  2405.         vis_st64_2(TMP8, dest, 8);

  2406.         dest += stride;

  2407. 

  2408.         vis_xor(REF_0, REF_2, TMP6);

  2409. 

  2410.         vis_xor(REF_4, REF_6, TMP8);

  2411. 

  2412.         vis_and(TMP6, MASK_fe, TMP6);

  2413. 

  2414.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2415.         vis_and(TMP8, MASK_fe, TMP8);

  2416. 

  2417.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2418.         vis_and(REF_0, REF_2, TMP10);

  2419. 

  2420.         vis_and(REF_4, REF_6, TMP12);

  2421. 

  2422.         vis_and(TMP6, MASK_7f, TMP6);

  2423. 

  2424.         vis_and(TMP8, MASK_7f, TMP8);

  2425. 

  2426.         vis_padd16(TMP10, TMP6, TMP6);

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

  2428. 

  2429.         vis_padd16(TMP12, TMP8, TMP8);

  2430.         vis_st64_2(TMP8, dest, 8);

  2431. }

  2432. 

  2433. static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref,

  2434.                                      const ptrdiff_t stride, int height)

  2435. {

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

  2437.         unsigned long off_plus_1 = off + 1;

  2438. 

  2439.         ref = vis_alignaddr(ref);

  2440. 

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

  2442. 

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

  2444. 

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

  2446. 

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

  2448. 

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

  2450.         vis_faligndata(TMP0, TMP2, REF_0);

  2451. 

  2452.         if (off != 0x7) {

  2453.                 vis_alignaddr_g0((void *)off_plus_1);

  2454.                 vis_faligndata(TMP0, TMP2, REF_2);

  2455.         } else {

  2456.                 vis_src1(TMP2, REF_2);

  2457.         }

  2458. 

  2459.         ref += stride;

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

  2461. 

  2462.         do {    /* 20 cycles */

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

  2464.                 vis_xor(REF_0, REF_2, TMP4);

  2465. 

  2466.                 vis_ld64_2(ref, 8, TMP2);

  2467.                 vis_and(TMP4, MASK_fe, TMP4);

  2468.                 ref += stride;

  2469. 

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

  2471.                 vis_and(REF_0, REF_2, TMP6);

  2472.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2473. 

  2474.                 vis_alignaddr_g0((void *)off);

  2475. 

  2476.                 vis_ld64_2(ref, 8, TMP10);

  2477.                 ref += stride;

  2478.                 vis_faligndata(TMP0, TMP2, REF_0);

  2479. 

  2480.                 if (off != 0x7) {

  2481.                         vis_alignaddr_g0((void *)off_plus_1);

  2482.                         vis_faligndata(TMP0, TMP2, REF_2);

  2483.                 } else {

  2484.                         vis_src1(TMP2, REF_2);

  2485.                 }

  2486. 

  2487.                 vis_and(TMP4, MASK_7f, TMP4);

  2488. 

  2489.                 vis_padd16(TMP6, TMP4, DST_0);

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

  2491.                 dest += stride;

  2492. 

  2493.                 vis_xor(REF_0, REF_2, TMP12);

  2494. 

  2495.                 vis_and(TMP12, MASK_fe, TMP12);

  2496. 

  2497.                 vis_and(REF_0, REF_2, TMP14);

  2498.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2499. 

  2500.                 vis_alignaddr_g0((void *)off);

  2501.                 vis_faligndata(TMP8, TMP10, REF_0);

  2502.                 if (off != 0x7) {

  2503.                         vis_alignaddr_g0((void *)off_plus_1);

  2504.                         vis_faligndata(TMP8, TMP10, REF_2);

  2505.                 } else {

  2506.                         vis_src1(TMP10, REF_2);

  2507.                 }

  2508. 

  2509.                 vis_and(TMP12, MASK_7f, TMP12);

  2510. 

  2511.                 vis_padd16(TMP14, TMP12, DST_0);

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

  2513.                 dest += stride;

  2514.         } while (--height);

  2515. 

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

  2517.         vis_xor(REF_0, REF_2, TMP4);

  2518. 

  2519.         vis_ld64_2(ref, 8, TMP2);

  2520.         vis_and(TMP4, MASK_fe, TMP4);

  2521. 

  2522.         vis_and(REF_0, REF_2, TMP6);

  2523.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2524. 

  2525.         vis_alignaddr_g0((void *)off);

  2526. 

  2527.         vis_faligndata(TMP0, TMP2, REF_0);

  2528. 

  2529.         if (off != 0x7) {

  2530.                 vis_alignaddr_g0((void *)off_plus_1);

  2531.                 vis_faligndata(TMP0, TMP2, REF_2);

  2532.         } else {

  2533.                 vis_src1(TMP2, REF_2);

  2534.         }

  2535. 

  2536.         vis_and(TMP4, MASK_7f, TMP4);

  2537. 

  2538.         vis_padd16(TMP6, TMP4, DST_0);

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

  2540.         dest += stride;

  2541. 

  2542.         vis_xor(REF_0, REF_2, TMP12);

  2543. 

  2544.         vis_and(TMP12, MASK_fe, TMP12);

  2545. 

  2546.         vis_and(REF_0, REF_2, TMP14);

  2547.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2548. 

  2549.         vis_and(TMP12, MASK_7f, TMP12);

  2550. 

  2551.         vis_padd16(TMP14, TMP12, DST_0);

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

  2553.         dest += stride;

  2554. }

  2555. 

  2556. static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * ref,

  2557.                                       const ptrdiff_t stride, int height)

  2558. {

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

  2560.         unsigned long off_plus_1 = off + 1;

  2561. 

  2562.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2563. 

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

  2565.         vis_fzero(ZERO);

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

  2567. 

  2568.         ref = vis_alignaddr(ref);

  2569.         do {    /* 26 cycles */

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

  2571. 

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

  2573. 

  2574.                 vis_alignaddr_g0((void *)off);

  2575. 

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

  2577. 

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

  2579.                 vis_faligndata(TMP0, TMP2, REF_0);

  2580. 

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

  2582.                 vis_faligndata(TMP2, TMP4, REF_4);

  2583. 

  2584.                 if (off != 0x7) {

  2585.                         vis_alignaddr_g0((void *)off_plus_1);

  2586.                         vis_faligndata(TMP0, TMP2, REF_2);

  2587.                         vis_faligndata(TMP2, TMP4, REF_6);

  2588.                 } else {

  2589.                         vis_src1(TMP2, REF_2);

  2590.                         vis_src1(TMP4, REF_6);

  2591.                 }

  2592. 

  2593.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  2594. 

  2595.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2596.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2597. 

  2598.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  2599. 

  2600.                 vis_padd16(TMP0, TMP4, TMP0);

  2601. 

  2602.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  2603.                 vis_padd16(TMP2, TMP6, TMP2);

  2604. 

  2605.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  2606. 

  2607.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  2608. 

  2609.                 vis_padd16(TMP0, TMP4, TMP0);

  2610.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2611. 

  2612.                 vis_padd16(TMP2, TMP6, TMP2);

  2613.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  2614. 

  2615.                 vis_padd16(TMP0, CONST_3, TMP8);

  2616.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  2617. 

  2618.                 vis_padd16(TMP2, CONST_3, TMP10);

  2619.                 vis_pack16(TMP8, DST_0);

  2620. 

  2621.                 vis_pack16(TMP10, DST_1);

  2622.                 vis_padd16(TMP16, TMP12, TMP0);

  2623. 

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

  2625.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  2626.                 vis_padd16(TMP18, TMP14, TMP2);

  2627. 

  2628.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  2629.                 vis_padd16(TMP0, CONST_3, TMP0);

  2630. 

  2631.                 vis_padd16(TMP2, CONST_3, TMP2);

  2632. 

  2633.                 vis_padd16(TMP0, TMP4, TMP0);

  2634. 

  2635.                 vis_padd16(TMP2, TMP6, TMP2);

  2636.                 vis_pack16(TMP0, DST_2);

  2637. 

  2638.                 vis_pack16(TMP2, DST_3);

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

  2640. 

  2641.                 ref += stride;

  2642.                 dest += stride;

  2643.         } while (--height);

  2644. }

  2645. 

  2646. static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref,

  2647.                                       const ptrdiff_t stride, int height)

  2648. {

  2649.         ref = vis_alignaddr(ref);

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

  2651. 

  2652.         vis_ld64_2(ref, 8, TMP2);

  2653. 

  2654.         vis_ld64_2(ref, 16, TMP4);

  2655.         ref += stride;

  2656. 

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

  2658.         vis_faligndata(TMP0, TMP2, REF_0);

  2659. 

  2660.         vis_ld64_2(ref, 8, TMP8);

  2661.         vis_faligndata(TMP2, TMP4, REF_4);

  2662. 

  2663.         vis_ld64_2(ref, 16, TMP10);

  2664.         ref += stride;

  2665. 

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

  2667.         vis_faligndata(TMP6, TMP8, REF_2);

  2668. 

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

  2670.         vis_faligndata(TMP8, TMP10, REF_6);

  2671. 

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

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

  2674.         do {    /* 24 cycles */

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

  2676.                 vis_xor(REF_0, REF_2, TMP12);

  2677. 

  2678.                 vis_ld64_2(ref, 8, TMP2);

  2679.                 vis_xor(REF_4, REF_6, TMP16);

  2680. 

  2681.                 vis_ld64_2(ref, 16, TMP4);

  2682.                 ref += stride;

  2683.                 vis_and(REF_0, REF_2, TMP14);

  2684. 

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

  2686.                 vis_and(REF_4, REF_6, TMP18);

  2687. 

  2688.                 vis_ld64_2(ref, 8, TMP8);

  2689.                 vis_faligndata(TMP0, TMP2, REF_0);

  2690. 

  2691.                 vis_ld64_2(ref, 16, TMP10);

  2692.                 ref += stride;

  2693.                 vis_faligndata(TMP2, TMP4, REF_4);

  2694. 

  2695.                 vis_and(TMP12, MASK_fe, TMP12);

  2696. 

  2697.                 vis_and(TMP16, MASK_fe, TMP16);

  2698.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2699. 

  2700.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  2701.                 vis_xor(REF_0, REF_2, TMP0);

  2702. 

  2703.                 vis_xor(REF_4, REF_6, TMP2);

  2704. 

  2705.                 vis_and(REF_0, REF_2, TMP20);

  2706. 

  2707.                 vis_and(TMP12, MASK_7f, TMP12);

  2708. 

  2709.                 vis_and(TMP16, MASK_7f, TMP16);

  2710. 

  2711.                 vis_padd16(TMP14, TMP12, TMP12);

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

  2713. 

  2714.                 vis_padd16(TMP18, TMP16, TMP16);

  2715.                 vis_st64_2(TMP16, dest, 8);

  2716.                 dest += stride;

  2717. 

  2718.                 vis_and(REF_4, REF_6, TMP18);

  2719. 

  2720.                 vis_and(TMP0, MASK_fe, TMP0);

  2721. 

  2722.                 vis_and(TMP2, MASK_fe, TMP2);

  2723.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  2724. 

  2725.                 vis_faligndata(TMP6, TMP8, REF_2);

  2726.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  2727. 

  2728.                 vis_faligndata(TMP8, TMP10, REF_6);

  2729. 

  2730.                 vis_and(TMP0, MASK_7f, TMP0);

  2731. 

  2732.                 vis_and(TMP2, MASK_7f, TMP2);

  2733. 

  2734.                 vis_padd16(TMP20, TMP0, TMP0);

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

  2736. 

  2737.                 vis_padd16(TMP18, TMP2, TMP2);

  2738.                 vis_st64_2(TMP2, dest, 8);

  2739.                 dest += stride;

  2740.         } while (--height);

  2741. 

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

  2743.         vis_xor(REF_0, REF_2, TMP12);

  2744. 

  2745.         vis_ld64_2(ref, 8, TMP2);

  2746.         vis_xor(REF_4, REF_6, TMP16);

  2747. 

  2748.         vis_ld64_2(ref, 16, TMP4);

  2749.         vis_and(REF_0, REF_2, TMP14);

  2750. 

  2751.         vis_and(REF_4, REF_6, TMP18);

  2752. 

  2753.         vis_faligndata(TMP0, TMP2, REF_0);

  2754. 

  2755.         vis_faligndata(TMP2, TMP4, REF_4);

  2756. 

  2757.         vis_and(TMP12, MASK_fe, TMP12);

  2758. 

  2759.         vis_and(TMP16, MASK_fe, TMP16);

  2760.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2761. 

  2762.         vis_mul8x16(CONST_128, TMP16, TMP16);

  2763.         vis_xor(REF_0, REF_2, TMP0);

  2764. 

  2765.         vis_xor(REF_4, REF_6, TMP2);

  2766. 

  2767.         vis_and(REF_0, REF_2, TMP20);

  2768. 

  2769.         vis_and(TMP12, MASK_7f, TMP12);

  2770. 

  2771.         vis_and(TMP16, MASK_7f, TMP16);

  2772. 

  2773.         vis_padd16(TMP14, TMP12, TMP12);

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

  2775. 

  2776.         vis_padd16(TMP18, TMP16, TMP16);

  2777.         vis_st64_2(TMP16, dest, 8);

  2778.         dest += stride;

  2779. 

  2780.         vis_and(REF_4, REF_6, TMP18);

  2781. 

  2782.         vis_and(TMP0, MASK_fe, TMP0);

  2783. 

  2784.         vis_and(TMP2, MASK_fe, TMP2);

  2785.         vis_mul8x16(CONST_128, TMP0, TMP0);

  2786. 

  2787.         vis_mul8x16(CONST_128, TMP2, TMP2);

  2788. 

  2789.         vis_and(TMP0, MASK_7f, TMP0);

  2790. 

  2791.         vis_and(TMP2, MASK_7f, TMP2);

  2792. 

  2793.         vis_padd16(TMP20, TMP0, TMP0);

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

  2795. 

  2796.         vis_padd16(TMP18, TMP2, TMP2);

  2797.         vis_st64_2(TMP2, dest, 8);

  2798. }

  2799. 

  2800. static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref,

  2801.                                      const ptrdiff_t stride, int height)

  2802. {

  2803.         ref = vis_alignaddr(ref);

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

  2805. 

  2806.         vis_ld64_2(ref, 8, TMP2);

  2807.         ref += stride;

  2808. 

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

  2810. 

  2811.         vis_ld64_2(ref, 8, TMP6);

  2812.         ref += stride;

  2813. 

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

  2815.         vis_faligndata(TMP0, TMP2, REF_0);

  2816. 

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

  2818.         vis_faligndata(TMP4, TMP6, REF_2);

  2819. 

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

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

  2822.         do {    /* 12 cycles */

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

  2824.                 vis_xor(REF_0, REF_2, TMP4);

  2825. 

  2826.                 vis_ld64_2(ref, 8, TMP2);

  2827.                 ref += stride;

  2828.                 vis_and(TMP4, MASK_fe, TMP4);

  2829. 

  2830.                 vis_and(REF_0, REF_2, TMP6);

  2831.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2832. 

  2833.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2835. 

  2836.                 vis_ld64_2(ref, 8, TMP2);

  2837.                 ref += stride;

  2838.                 vis_xor(REF_0, REF_2, TMP12);

  2839. 

  2840.                 vis_and(TMP4, MASK_7f, TMP4);

  2841. 

  2842.                 vis_and(TMP12, MASK_fe, TMP12);

  2843. 

  2844.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2845.                 vis_and(REF_0, REF_2, TMP14);

  2846. 

  2847.                 vis_padd16(TMP6, TMP4, DST_0);

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

  2849.                 dest += stride;

  2850. 

  2851.                 vis_faligndata(TMP0, TMP2, REF_2);

  2852. 

  2853.                 vis_and(TMP12, MASK_7f, TMP12);

  2854. 

  2855.                 vis_padd16(TMP14, TMP12, DST_0);

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

  2857.                 dest += stride;

  2858.         } while (--height);

  2859. 

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

  2861.         vis_xor(REF_0, REF_2, TMP4);

  2862. 

  2863.         vis_ld64_2(ref, 8, TMP2);

  2864.         vis_and(TMP4, MASK_fe, TMP4);

  2865. 

  2866.         vis_and(REF_0, REF_2, TMP6);

  2867.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2868. 

  2869.         vis_faligndata(TMP0, TMP2, REF_0);

  2870. 

  2871.         vis_xor(REF_0, REF_2, TMP12);

  2872. 

  2873.         vis_and(TMP4, MASK_7f, TMP4);

  2874. 

  2875.         vis_and(TMP12, MASK_fe, TMP12);

  2876. 

  2877.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2878.         vis_and(REF_0, REF_2, TMP14);

  2879. 

  2880.         vis_padd16(TMP6, TMP4, DST_0);

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

  2882.         dest += stride;

  2883. 

  2884.         vis_and(TMP12, MASK_7f, TMP12);

  2885. 

  2886.         vis_padd16(TMP14, TMP12, DST_0);

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

  2888. }

  2889. 

  2890. static void MC_avg_no_round_y_16_vis (uint8_t * dest, const uint8_t * ref,

  2891.                                       const ptrdiff_t stride, int height)

  2892. {

  2893.         int stride_8 = stride + 8;

  2894.         int stride_16 = stride + 16;

  2895. 

  2896.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2897. 

  2898.         ref = vis_alignaddr(ref);

  2899. 

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

  2901.         vis_fzero(ZERO);

  2902. 

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

  2904. 

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

  2906. 

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

  2908.         vis_faligndata(TMP0, TMP2, REF_2);

  2909. 

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

  2911.         vis_faligndata(TMP2, TMP4, REF_6);

  2912.         height >>= 1;

  2913. 

  2914.         do {    /* 31 cycles */

  2915.                 vis_ld64_2(ref, stride, TMP0);

  2916.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  2917.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  2918. 

  2919.                 vis_ld64_2(ref, stride_8, TMP2);

  2920.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  2921.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  2922. 

  2923.                 vis_ld64_2(ref, stride_16, TMP4);

  2924.                 ref += stride;

  2925. 

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

  2927.                 vis_faligndata(TMP0, TMP2, REF_0);

  2928. 

  2929.                 vis_ld64_2(dest, 8, DST_2);

  2930.                 vis_faligndata(TMP2, TMP4, REF_4);

  2931. 

  2932.                 vis_ld64_2(ref, stride, TMP6);

  2933.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  2934.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2935. 

  2936.                 vis_ld64_2(ref, stride_8, TMP8);

  2937.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  2938. 

  2939.                 vis_ld64_2(ref, stride_16, TMP10);

  2940.                 ref += stride;

  2941. 

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

  2943.                 vis_faligndata(TMP6, TMP8, REF_2);

  2944.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  2945. 

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

  2947.                 vis_faligndata(TMP8, TMP10, REF_6);

  2948.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  2949. 

  2950.                 vis_padd16(TMP0, CONST_3, TMP0);

  2951.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  2952. 

  2953.                 vis_padd16(TMP2, CONST_3, TMP2);

  2954.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  2955. 

  2956.                 vis_padd16(TMP4, CONST_3, TMP4);

  2957.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  2958. 

  2959.                 vis_padd16(TMP6, CONST_3, TMP6);

  2960. 

  2961.                 vis_padd16(TMP12, TMP20, TMP12);

  2962.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  2963. 

  2964.                 vis_padd16(TMP14, TMP22, TMP14);

  2965.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  2966. 

  2967.                 vis_padd16(TMP16, TMP24, TMP16);

  2968.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  2969. 

  2970.                 vis_padd16(TMP18, TMP26, TMP18);

  2971.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  2972. 

  2973.                 vis_padd16(TMP12, TMP0, TMP12);

  2974.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  2975. 

  2976.                 vis_padd16(TMP14, TMP2, TMP14);

  2977.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  2978. 

  2979.                 vis_padd16(TMP16, TMP4, TMP16);

  2980.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  2981. 

  2982.                 vis_padd16(TMP18, TMP6, TMP18);

  2983.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  2984. 

  2985.                 vis_pack16(TMP12, DST_0);

  2986.                 vis_padd16(TMP28, TMP0, TMP12);

  2987. 

  2988.                 vis_pack16(TMP14, DST_1);

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

  2990.                 vis_padd16(TMP30, TMP2, TMP14);

  2991. 

  2992.                 vis_pack16(TMP16, DST_2);

  2993.                 vis_padd16(REF_S4, TMP4, TMP16);

  2994. 

  2995.                 vis_pack16(TMP18, DST_3);

  2996.                 vis_st64_2(DST_2, dest, 8);

  2997.                 dest += stride;

  2998.                 vis_padd16(REF_S6, TMP6, TMP18);

  2999. 

  3000.                 vis_padd16(TMP12, TMP20, TMP12);

  3001. 

  3002.                 vis_padd16(TMP14, TMP22, TMP14);

  3003.                 vis_pack16(TMP12, DST_0);

  3004. 

  3005.                 vis_padd16(TMP16, TMP24, TMP16);

  3006.                 vis_pack16(TMP14, DST_1);

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

  3008. 

  3009.                 vis_padd16(TMP18, TMP26, TMP18);

  3010.                 vis_pack16(TMP16, DST_2);

  3011. 

  3012.                 vis_pack16(TMP18, DST_3);

  3013.                 vis_st64_2(DST_2, dest, 8);

  3014.                 dest += stride;

  3015.         } while (--height);

  3016. }

  3017. 

  3018. static void MC_put_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref,

  3019.                                        const ptrdiff_t stride, int height)

  3020. {

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

  3022.         unsigned long off_plus_1 = off + 1;

  3023.         int stride_8 = stride + 8;

  3024.         int stride_16 = stride + 16;

  3025. 

  3026.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3027. 

  3028.         ref = vis_alignaddr(ref);

  3029. 

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

  3031.         vis_fzero(ZERO);

  3032. 

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

  3034. 

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

  3036. 

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

  3038.         vis_faligndata(TMP0, TMP2, REF_S0);

  3039. 

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

  3041.         vis_faligndata(TMP2, TMP4, REF_S4);

  3042. 

  3043.         if (off != 0x7) {

  3044.                 vis_alignaddr_g0((void *)off_plus_1);

  3045.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3046.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3047.         } else {

  3048.                 vis_src1(TMP2, REF_S2);

  3049.                 vis_src1(TMP4, REF_S6);

  3050.         }

  3051. 

  3052.         height >>= 1;

  3053.         do {

  3054.                 vis_ld64_2(ref, stride, TMP0);

  3055.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3056.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3057. 

  3058.                 vis_alignaddr_g0((void *)off);

  3059. 

  3060.                 vis_ld64_2(ref, stride_8, TMP2);

  3061.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3062.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3063. 

  3064.                 vis_ld64_2(ref, stride_16, TMP4);

  3065.                 ref += stride;

  3066.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3067.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3068. 

  3069.                 vis_ld64_2(ref, stride, TMP6);

  3070.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3071.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3072. 

  3073.                 vis_ld64_2(ref, stride_8, TMP8);

  3074.                 vis_faligndata(TMP0, TMP2, REF_0);

  3075. 

  3076.                 vis_ld64_2(ref, stride_16, TMP10);

  3077.                 ref += stride;

  3078.                 vis_faligndata(TMP2, TMP4, REF_4);

  3079. 

  3080.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3081. 

  3082.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3083. 

  3084.                 if (off != 0x7) {

  3085.                         vis_alignaddr_g0((void *)off_plus_1);

  3086.                         vis_faligndata(TMP0, TMP2, REF_2);

  3087.                         vis_faligndata(TMP2, TMP4, REF_6);

  3088.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3089.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3090.                 } else {

  3091.                         vis_src1(TMP2, REF_2);

  3092.                         vis_src1(TMP4, REF_6);

  3093.                         vis_src1(TMP8, REF_S2);

  3094.                         vis_src1(TMP10, REF_S6);

  3095.                 }

  3096. 

  3097.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  3098.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3099. 

  3100.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3101.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3102. 

  3103.                 vis_padd16(TMP0, CONST_2, TMP8);

  3104.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  3105. 

  3106.                 vis_padd16(TMP2, CONST_1, TMP10);

  3107.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  3108. 

  3109.                 vis_padd16(TMP8, TMP4, TMP8);

  3110.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  3111. 

  3112.                 vis_padd16(TMP10, TMP6, TMP10);

  3113.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  3114. 

  3115.                 vis_padd16(TMP12, TMP8, TMP12);

  3116. 

  3117.                 vis_padd16(TMP14, TMP10, TMP14);

  3118. 

  3119.                 vis_padd16(TMP12, TMP16, TMP12);

  3120. 

  3121.                 vis_padd16(TMP14, TMP18, TMP14);

  3122.                 vis_pack16(TMP12, DST_0);

  3123. 

  3124.                 vis_pack16(TMP14, DST_1);

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

  3126.                 vis_padd16(TMP0, CONST_1, TMP12);

  3127. 

  3128.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  3129.                 vis_padd16(TMP2, CONST_1, TMP14);

  3130. 

  3131.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  3132.                 vis_padd16(TMP12, TMP4, TMP12);

  3133. 

  3134.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  3135.                 vis_padd16(TMP14, TMP6, TMP14);

  3136. 

  3137.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  3138.                 vis_padd16(TMP20, TMP12, TMP20);

  3139. 

  3140.                 vis_padd16(TMP22, TMP14, TMP22);

  3141. 

  3142.                 vis_padd16(TMP20, TMP24, TMP20);

  3143. 

  3144.                 vis_padd16(TMP22, TMP26, TMP22);

  3145.                 vis_pack16(TMP20, DST_2);

  3146. 

  3147.                 vis_pack16(TMP22, DST_3);

  3148.                 vis_st64_2(DST_2, dest, 8);

  3149.                 dest += stride;

  3150.                 vis_padd16(TMP0, TMP4, TMP24);

  3151. 

  3152.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  3153.                 vis_padd16(TMP2, TMP6, TMP26);

  3154. 

  3155.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  3156.                 vis_padd16(TMP24, TMP8, TMP24);

  3157. 

  3158.                 vis_padd16(TMP26, TMP10, TMP26);

  3159.                 vis_pack16(TMP24, DST_0);

  3160. 

  3161.                 vis_pack16(TMP26, DST_1);

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

  3163.                 vis_pmerge(ZERO, REF_S6, TMP4);

  3164. 

  3165.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  3166. 

  3167.                 vis_padd16(TMP0, TMP4, TMP0);

  3168. 

  3169.                 vis_padd16(TMP2, TMP6, TMP2);

  3170. 

  3171.                 vis_padd16(TMP0, TMP12, TMP0);

  3172. 

  3173.                 vis_padd16(TMP2, TMP14, TMP2);

  3174.                 vis_pack16(TMP0, DST_2);

  3175. 

  3176.                 vis_pack16(TMP2, DST_3);

  3177.                 vis_st64_2(DST_2, dest, 8);

  3178.                 dest += stride;

  3179.         } while (--height);

  3180. }

  3181. 

  3182. static void MC_put_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref,

  3183.                                       const ptrdiff_t stride, int height)

  3184. {

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

  3186.         unsigned long off_plus_1 = off + 1;

  3187.         int stride_8 = stride + 8;

  3188. 

  3189.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3190. 

  3191.         ref = vis_alignaddr(ref);

  3192. 

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

  3194.         vis_fzero(ZERO);

  3195. 

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

  3197. 

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

  3199. 

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

  3201.         vis_faligndata(TMP0, TMP2, REF_S0);

  3202. 

  3203.         if (off != 0x7) {

  3204.                 vis_alignaddr_g0((void *)off_plus_1);

  3205.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3206.         } else {

  3207.                 vis_src1(TMP2, REF_S2);

  3208.         }

  3209. 

  3210.         height >>= 1;

  3211.         do {    /* 26 cycles */

  3212.                 vis_ld64_2(ref, stride, TMP0);

  3213.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  3214.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  3215. 

  3216.                 vis_alignaddr_g0((void *)off);

  3217. 

  3218.                 vis_ld64_2(ref, stride_8, TMP2);

  3219.                 ref += stride;

  3220.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  3221.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  3222. 

  3223.                 vis_ld64_2(ref, stride, TMP4);

  3224. 

  3225.                 vis_ld64_2(ref, stride_8, TMP6);

  3226.                 ref += stride;

  3227.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3228. 

  3229.                 vis_pmerge(ZERO, REF_S4, TMP18);

  3230. 

  3231.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  3232. 

  3233.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3234. 

  3235.                 if (off != 0x7) {

  3236.                         vis_alignaddr_g0((void *)off_plus_1);

  3237.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3238.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3239.                 } else {

  3240.                         vis_src1(TMP2, REF_S6);

  3241.                         vis_src1(TMP6, REF_S2);

  3242.                 }

  3243. 

  3244.                 vis_padd16(TMP18, CONST_1, TMP18);

  3245.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  3246. 

  3247.                 vis_padd16(TMP20, CONST_1, TMP20);

  3248.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  3249. 

  3250.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  3251.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  3252. 

  3253.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  3254.                 vis_padd16(TMP18, TMP22, TMP18);

  3255. 

  3256.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  3257.                 vis_padd16(TMP20, TMP24, TMP20);

  3258. 

  3259.                 vis_padd16(TMP8,  TMP18, TMP8);

  3260. 

  3261.                 vis_padd16(TMP10, TMP20, TMP10);

  3262. 

  3263.                 vis_padd16(TMP8,  TMP12, TMP8);

  3264. 

  3265.                 vis_padd16(TMP10, TMP14, TMP10);

  3266.                 vis_pack16(TMP8,  DST_0);

  3267. 

  3268.                 vis_pack16(TMP10, DST_1);

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

  3270.                 dest += stride;

  3271.                 vis_padd16(TMP18, TMP26, TMP18);

  3272. 

  3273.                 vis_padd16(TMP20, TMP28, TMP20);

  3274. 

  3275.                 vis_padd16(TMP18, TMP30, TMP18);

  3276. 

  3277.                 vis_padd16(TMP20, TMP32, TMP20);

  3278.                 vis_pack16(TMP18, DST_2);

  3279. 

  3280.                 vis_pack16(TMP20, DST_3);

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

  3282.                 dest += stride;

  3283.         } while (--height);

  3284. }

  3285. 

  3286. static void MC_avg_no_round_xy_16_vis (uint8_t * dest, const uint8_t * ref,

  3287.                                        const ptrdiff_t stride, int height)

  3288. {

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

  3290.         unsigned long off_plus_1 = off + 1;

  3291.         int stride_8 = stride + 8;

  3292.         int stride_16 = stride + 16;

  3293. 

  3294.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3295. 

  3296.         ref = vis_alignaddr(ref);

  3297. 

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

  3299.         vis_fzero(ZERO);

  3300. 

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

  3302. 

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

  3304. 

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

  3306.         vis_faligndata(TMP0, TMP2, REF_S0);

  3307. 

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

  3309.         vis_faligndata(TMP2, TMP4, REF_S4);

  3310. 

  3311.         if (off != 0x7) {

  3312.                 vis_alignaddr_g0((void *)off_plus_1);

  3313.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3314.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3315.         } else {

  3316.                 vis_src1(TMP2, REF_S2);

  3317.                 vis_src1(TMP4, REF_S6);

  3318.         }

  3319. 

  3320.         height >>= 1;

  3321.         do {    /* 55 cycles */

  3322.                 vis_ld64_2(ref, stride, TMP0);

  3323.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3324.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3325. 

  3326.                 vis_alignaddr_g0((void *)off);

  3327. 

  3328.                 vis_ld64_2(ref, stride_8, TMP2);

  3329.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3330.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3331. 

  3332.                 vis_ld64_2(ref, stride_16, TMP4);

  3333.                 ref += stride;

  3334.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3335.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3336. 

  3337.                 vis_ld64_2(ref, stride, TMP6);

  3338.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3339.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3340. 

  3341.                 vis_ld64_2(ref, stride_8, TMP8);

  3342.                 vis_faligndata(TMP0, TMP2, REF_0);

  3343. 

  3344.                 vis_ld64_2(ref, stride_16, TMP10);

  3345.                 ref += stride;

  3346.                 vis_faligndata(TMP2, TMP4, REF_4);

  3347. 

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

  3349.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3350. 

  3351.                 vis_ld64_2(dest, 8, DST_2);

  3352.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3353. 

  3354.                 if (off != 0x7) {

  3355.                         vis_alignaddr_g0((void *)off_plus_1);

  3356.                         vis_faligndata(TMP0, TMP2, REF_2);

  3357.                         vis_faligndata(TMP2, TMP4, REF_6);

  3358.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3359.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3360.                 } else {

  3361.                         vis_src1(TMP2, REF_2);

  3362.                         vis_src1(TMP4, REF_6);

  3363.                         vis_src1(TMP8, REF_S2);

  3364.                         vis_src1(TMP10, REF_S6);

  3365.                 }

  3366. 

  3367.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3368.                 vis_pmerge(ZERO, REF_0, TMP0);

  3369. 

  3370.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3371.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3372. 

  3373.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3374.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3375. 

  3376.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3377.                 vis_padd16(TMP0, CONST_6, TMP0);

  3378. 

  3379.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3380.                 vis_padd16(TMP2, CONST_6, TMP2);

  3381. 

  3382.                 vis_padd16(TMP0, TMP4, TMP0);

  3383.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  3384. 

  3385.                 vis_padd16(TMP2, TMP6, TMP2);

  3386.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3387. 

  3388.                 vis_padd16(TMP12, TMP0, TMP12);

  3389.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  3390. 

  3391.                 vis_padd16(TMP14, TMP2, TMP14);

  3392.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  3393. 

  3394.                 vis_padd16(TMP12, TMP16, TMP12);

  3395.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  3396. 

  3397.                 vis_padd16(TMP14, TMP18, TMP14);

  3398.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  3399. 

  3400.                 vis_padd16(TMP12, TMP30, TMP12);

  3401. 

  3402.                 vis_padd16(TMP14, TMP32, TMP14);

  3403.                 vis_pack16(TMP12, DST_0);

  3404. 

  3405.                 vis_pack16(TMP14, DST_1);

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

  3407.                 vis_padd16(TMP4, CONST_6, TMP4);

  3408. 

  3409.                 vis_ld64_2(dest, stride, DST_0);

  3410.                 vis_padd16(TMP6, CONST_6, TMP6);

  3411.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3412. 

  3413.                 vis_padd16(TMP4, TMP8, TMP4);

  3414.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  3415. 

  3416.                 vis_padd16(TMP6, TMP10, TMP6);

  3417. 

  3418.                 vis_padd16(TMP20, TMP4, TMP20);

  3419. 

  3420.                 vis_padd16(TMP22, TMP6, TMP22);

  3421. 

  3422.                 vis_padd16(TMP20, TMP24, TMP20);

  3423. 

  3424.                 vis_padd16(TMP22, TMP26, TMP22);

  3425. 

  3426.                 vis_padd16(TMP20, REF_0, TMP20);

  3427.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  3428. 

  3429.                 vis_padd16(TMP22, REF_2, TMP22);

  3430.                 vis_pack16(TMP20, DST_2);

  3431. 

  3432.                 vis_pack16(TMP22, DST_3);

  3433.                 vis_st64_2(DST_2, dest, 8);

  3434.                 dest += stride;

  3435. 

  3436.                 vis_ld64_2(dest, 8, DST_2);

  3437.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3438.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  3439. 

  3440.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3441.                 vis_padd16(REF_4, TMP0, TMP8);

  3442. 

  3443.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  3444.                 vis_padd16(REF_6, TMP2, TMP10);

  3445. 

  3446.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  3447.                 vis_padd16(TMP8, TMP12, TMP8);

  3448. 

  3449.                 vis_padd16(TMP10, TMP14, TMP10);

  3450. 

  3451.                 vis_padd16(TMP8, TMP30, TMP8);

  3452. 

  3453.                 vis_padd16(TMP10, TMP32, TMP10);

  3454.                 vis_pack16(TMP8, DST_0);

  3455. 

  3456.                 vis_pack16(TMP10, DST_1);

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

  3458. 

  3459.                 vis_padd16(REF_0, TMP4, REF_0);

  3460. 

  3461.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  3462.                 vis_padd16(REF_2, TMP6, REF_2);

  3463. 

  3464.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  3465.                 vis_padd16(REF_0, REF_4, REF_0);

  3466. 

  3467.                 vis_padd16(REF_2, REF_6, REF_2);

  3468. 

  3469.                 vis_padd16(REF_0, TMP30, REF_0);

  3470. 

  3471.                 /* stall */

  3472. 

  3473.                 vis_padd16(REF_2, TMP32, REF_2);

  3474.                 vis_pack16(REF_0, DST_2);

  3475. 

  3476.                 vis_pack16(REF_2, DST_3);

  3477.                 vis_st64_2(DST_2, dest, 8);

  3478.                 dest += stride;

  3479.         } while (--height);

  3480. }

  3481. 

  3482. /* End of no rounding code */

  3483. 

  3484. #define ACCEL_SPARC_VIS 1

  3485. #define ACCEL_SPARC_VIS2 2

  3486. 

  3487. static int vis_level(void)

  3488. {

  3489.     int accel = 0;

  3490.     accel |= ACCEL_SPARC_VIS;

  3491.     accel |= ACCEL_SPARC_VIS2;

  3492.     return accel;

  3493. }

  3494. 

  3495. /* libavcodec initialization code */

  3496. void ff_hpeldsp_init_vis(HpelDSPContext* c, int flags)

  3497. {

  3498.   /* VIS-specific optimizations */

  3499.   int accel = vis_level ();

  3500. 

  3501.   if (accel & ACCEL_SPARC_VIS) {

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

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

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

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

  3506. 

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

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

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

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

  3511. 

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

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

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

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

  3516. 

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

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

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

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

  3521. 

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

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

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

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

  3526. 

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

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

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

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

  3531. 

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

  3533.       c->avg_no_rnd_pixels_tab[1] = MC_avg_no_round_x_16_vis;

  3534.       c->avg_no_rnd_pixels_tab[2] = MC_avg_no_round_y_16_vis;

  3535.       c->avg_no_rnd_pixels_tab[3] = MC_avg_no_round_xy_16_vis;

  3536.   }

  3537. }