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

3551 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 "libavutil/attributes.h"

  30. #include "libavcodec/dsputil.h"

  31. #include "libavutil/mem.h"

  32. #include "dsputil_vis.h"

  33. 

  34. #include "vis.h"

  35. 

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

  37.  * motion comp code, which is:

  38.  *

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

  40.  *

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

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

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

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

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

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

  47.  *

  48.  *      fxor            f0,   f2, f10

  49.  *      fand            f10,  f4, f10

  50.  *      fmul8x16        f8,  f10, f10

  51.  *      fand            f10,  f6, f10

  52.  *      for             f0,   f2, f12

  53.  *      fpsub16         f12, f10, f10

  54.  */

  55. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  69. 

  70. #define REF_0           0

  71. #define REF_0_1         1

  72. #define REF_2           2

  73. #define REF_2_1         3

  74. #define REF_4           4

  75. #define REF_4_1         5

  76. #define REF_6           6

  77. #define REF_6_1         7

  78. #define REF_S0          8

  79. #define REF_S0_1        9

  80. #define REF_S2          10

  81. #define REF_S2_1        11

  82. #define REF_S4          12

  83. #define REF_S4_1        13

  84. #define REF_S6          14

  85. #define REF_S6_1        15

  86. #define DST_0           16

  87. #define DST_1           17

  88. #define DST_2           18

  89. #define DST_3           19

  90. #define CONST_1         20

  91. #define CONST_2         20

  92. #define CONST_3         20

  93. #define CONST_6         20

  94. #define MASK_fe         20

  95. #define CONST_128       22

  96. #define CONST_256       22

  97. #define CONST_512       22

  98. #define CONST_1024      22

  99. #define TMP0            24

  100. #define TMP1            25

  101. #define TMP2            26

  102. #define TMP3            27

  103. #define TMP4            28

  104. #define TMP5            29

  105. #define ZERO            30

  106. #define MASK_7f         30

  107. 

  108. #define TMP6            32

  109. #define TMP8            34

  110. #define TMP10           36

  111. #define TMP12           38

  112. #define TMP14           40

  113. #define TMP16           42

  114. #define TMP18           44

  115. #define TMP20           46

  116. #define TMP22           48

  117. #define TMP24           50

  118. #define TMP26           52

  119. #define TMP28           54

  120. #define TMP30           56

  121. #define TMP32           58

  122. 

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

  124.                              const ptrdiff_t line_size, int height)

  125. {

  126.         ref = vis_alignaddr(ref);

  127.         do {    /* 5 cycles */

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

  129. 

  130.                 vis_ld64_2(ref, 8, TMP2);

  131. 

  132.                 vis_ld64_2(ref, 16, TMP4);

  133.                 ref += stride;

  134. 

  135.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  137. 

  138.                 vis_faligndata(TMP2, TMP4, REF_2);

  139.                 vis_st64_2(REF_2, dest, 8);

  140.                 dest += stride;

  141.         } while (--height);

  142. }

  143. 

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

  145.                             const ptrdiff_t line_size, int height)

  146. {

  147.         ref = vis_alignaddr(ref);

  148.         do {    /* 4 cycles */

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

  150. 

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

  152.                 ref += stride;

  153. 

  154.                 /* stall */

  155. 

  156.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  158.                 dest += stride;

  159.         } while (--height);

  160. }

  161. 

  162. 

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

  164.                              const ptrdiff_t line_size, int height)

  165. {

  166.         int stride_8 = stride + 8;

  167. 

  168.         ref = vis_alignaddr(ref);

  169. 

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

  171. 

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

  173. 

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

  175. 

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

  177. 

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

  179. 

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

  181.         vis_faligndata(TMP0, TMP2, REF_0);

  182. 

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

  184.         vis_faligndata(TMP2, TMP4, REF_2);

  185. 

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

  187. 

  188.         ref += stride;

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

  190. 

  191.         do {    /* 24 cycles */

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

  193.                 vis_xor(DST_0, REF_0, TMP6);

  194. 

  195.                 vis_ld64_2(ref, 8, TMP2);

  196.                 vis_and(TMP6, MASK_fe, TMP6);

  197. 

  198.                 vis_ld64_2(ref, 16, TMP4);

  199.                 ref += stride;

  200.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  201.                 vis_xor(DST_2, REF_2, TMP8);

  202. 

  203.                 vis_and(TMP8, MASK_fe, TMP8);

  204. 

  205.                 vis_or(DST_0, REF_0, TMP10);

  206.                 vis_ld64_2(dest, stride, DST_0);

  207.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  208. 

  209.                 vis_or(DST_2, REF_2, TMP12);

  210.                 vis_ld64_2(dest, stride_8, DST_2);

  211. 

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

  213.                 vis_and(TMP6, MASK_7f, TMP6);

  214. 

  215.                 vis_and(TMP8, MASK_7f, TMP8);

  216. 

  217.                 vis_psub16(TMP10, TMP6, TMP6);

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

  219. 

  220.                 vis_psub16(TMP12, TMP8, TMP8);

  221.                 vis_st64_2(TMP8, dest, 8);

  222. 

  223.                 dest += stride;

  224.                 vis_ld64_2(ref, 8, TMP16);

  225.                 vis_faligndata(TMP0, TMP2, REF_0);

  226. 

  227.                 vis_ld64_2(ref, 16, TMP18);

  228.                 vis_faligndata(TMP2, TMP4, REF_2);

  229.                 ref += stride;

  230. 

  231.                 vis_xor(DST_0, REF_0, TMP20);

  232. 

  233.                 vis_and(TMP20, MASK_fe, TMP20);

  234. 

  235.                 vis_xor(DST_2, REF_2, TMP22);

  236.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  237. 

  238.                 vis_and(TMP22, MASK_fe, TMP22);

  239. 

  240.                 vis_or(DST_0, REF_0, TMP24);

  241.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  242. 

  243.                 vis_or(DST_2, REF_2, TMP26);

  244. 

  245.                 vis_ld64_2(dest, stride, DST_0);

  246.                 vis_faligndata(TMP14, TMP16, REF_0);

  247. 

  248.                 vis_ld64_2(dest, stride_8, DST_2);

  249.                 vis_faligndata(TMP16, TMP18, REF_2);

  250. 

  251.                 vis_and(TMP20, MASK_7f, TMP20);

  252. 

  253.                 vis_and(TMP22, MASK_7f, TMP22);

  254. 

  255.                 vis_psub16(TMP24, TMP20, TMP20);

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

  257. 

  258.                 vis_psub16(TMP26, TMP22, TMP22);

  259.                 vis_st64_2(TMP22, dest, 8);

  260.                 dest += stride;

  261.         } while (--height);

  262. 

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

  264.         vis_xor(DST_0, REF_0, TMP6);

  265. 

  266.         vis_ld64_2(ref, 8, TMP2);

  267.         vis_and(TMP6, MASK_fe, TMP6);

  268. 

  269.         vis_ld64_2(ref, 16, TMP4);

  270.         vis_mul8x16(CONST_128, TMP6, TMP6);

  271.         vis_xor(DST_2, REF_2, TMP8);

  272. 

  273.         vis_and(TMP8, MASK_fe, TMP8);

  274. 

  275.         vis_or(DST_0, REF_0, TMP10);

  276.         vis_ld64_2(dest, stride, DST_0);

  277.         vis_mul8x16(CONST_128, TMP8, TMP8);

  278. 

  279.         vis_or(DST_2, REF_2, TMP12);

  280.         vis_ld64_2(dest, stride_8, DST_2);

  281. 

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

  283.         vis_and(TMP6, MASK_7f, TMP6);

  284. 

  285.         vis_and(TMP8, MASK_7f, TMP8);

  286. 

  287.         vis_psub16(TMP10, TMP6, TMP6);

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

  289. 

  290.         vis_psub16(TMP12, TMP8, TMP8);

  291.         vis_st64_2(TMP8, dest, 8);

  292. 

  293.         dest += stride;

  294.         vis_faligndata(TMP0, TMP2, REF_0);

  295. 

  296.         vis_faligndata(TMP2, TMP4, REF_2);

  297. 

  298.         vis_xor(DST_0, REF_0, TMP20);

  299. 

  300.         vis_and(TMP20, MASK_fe, TMP20);

  301. 

  302.         vis_xor(DST_2, REF_2, TMP22);

  303.         vis_mul8x16(CONST_128, TMP20, TMP20);

  304. 

  305.         vis_and(TMP22, MASK_fe, TMP22);

  306. 

  307.         vis_or(DST_0, REF_0, TMP24);

  308.         vis_mul8x16(CONST_128, TMP22, TMP22);

  309. 

  310.         vis_or(DST_2, REF_2, TMP26);

  311. 

  312.         vis_and(TMP20, MASK_7f, TMP20);

  313. 

  314.         vis_and(TMP22, MASK_7f, TMP22);

  315. 

  316.         vis_psub16(TMP24, TMP20, TMP20);

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

  318. 

  319.         vis_psub16(TMP26, TMP22, TMP22);

  320.         vis_st64_2(TMP22, dest, 8);

  321. }

  322. 

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

  324.                             const ptrdiff_t line_size, int height)

  325. {

  326.         ref = vis_alignaddr(ref);

  327. 

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

  329. 

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

  331. 

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

  333. 

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

  335. 

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

  337.         vis_faligndata(TMP0, TMP2, REF_0);

  338. 

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

  340. 

  341.         ref += stride;

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

  343. 

  344.         do {    /* 12 cycles */

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

  346.                 vis_xor(DST_0, REF_0, TMP4);

  347. 

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

  349.                 vis_and(TMP4, MASK_fe, TMP4);

  350. 

  351.                 vis_or(DST_0, REF_0, TMP6);

  352.                 vis_ld64_2(dest, stride, DST_0);

  353.                 ref += stride;

  354.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  355. 

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

  357.                 vis_faligndata(TMP0, TMP2, REF_0);

  358. 

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

  360.                 vis_xor(DST_0, REF_0, TMP0);

  361.                 ref += stride;

  362. 

  363.                 vis_and(TMP0, MASK_fe, TMP0);

  364. 

  365.                 vis_and(TMP4, MASK_7f, TMP4);

  366. 

  367.                 vis_psub16(TMP6, TMP4, TMP4);

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

  369.                 dest += stride;

  370.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  371. 

  372.                 vis_or(DST_0, REF_0, TMP6);

  373.                 vis_ld64_2(dest, stride, DST_0);

  374. 

  375.                 vis_faligndata(TMP12, TMP2, REF_0);

  376. 

  377.                 vis_and(TMP0, MASK_7f, TMP0);

  378. 

  379.                 vis_psub16(TMP6, TMP0, TMP4);

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

  381.                 dest += stride;

  382.         } while (--height);

  383. 

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

  385.         vis_xor(DST_0, REF_0, TMP4);

  386. 

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

  388.         vis_and(TMP4, MASK_fe, TMP4);

  389. 

  390.         vis_or(DST_0, REF_0, TMP6);

  391.         vis_ld64_2(dest, stride, DST_0);

  392.         vis_mul8x16(CONST_128, TMP4, TMP4);

  393. 

  394.         vis_faligndata(TMP0, TMP2, REF_0);

  395. 

  396.         vis_xor(DST_0, REF_0, TMP0);

  397. 

  398.         vis_and(TMP0, MASK_fe, TMP0);

  399. 

  400.         vis_and(TMP4, MASK_7f, TMP4);

  401. 

  402.         vis_psub16(TMP6, TMP4, TMP4);

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

  404.         dest += stride;

  405.         vis_mul8x16(CONST_128, TMP0, TMP0);

  406. 

  407.         vis_or(DST_0, REF_0, TMP6);

  408. 

  409.         vis_and(TMP0, MASK_7f, TMP0);

  410. 

  411.         vis_psub16(TMP6, TMP0, TMP4);

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

  413. }

  414. 

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

  416.                              const ptrdiff_t line_size, int height)

  417. {

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

  419.         unsigned long off_plus_1 = off + 1;

  420. 

  421.         ref = vis_alignaddr(ref);

  422. 

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

  424. 

  425.         vis_ld64_2(ref, 8,  TMP2);

  426. 

  427.         vis_ld64_2(ref, 16, TMP4);

  428. 

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

  430. 

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

  432.         vis_faligndata(TMP0, TMP2, REF_0);

  433. 

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

  435.         vis_faligndata(TMP2, TMP4, REF_4);

  436. 

  437.         if (off != 0x7) {

  438.                 vis_alignaddr_g0((void *)off_plus_1);

  439.                 vis_faligndata(TMP0, TMP2, REF_2);

  440.                 vis_faligndata(TMP2, TMP4, REF_6);

  441.         } else {

  442.                 vis_src1(TMP2, REF_2);

  443.                 vis_src1(TMP4, REF_6);

  444.         }

  445. 

  446.         ref += stride;

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

  448. 

  449.         do {    /* 34 cycles */

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

  451.                 vis_xor(REF_0, REF_2, TMP6);

  452. 

  453.                 vis_ld64_2(ref, 8,  TMP2);

  454.                 vis_xor(REF_4, REF_6, TMP8);

  455. 

  456.                 vis_ld64_2(ref, 16, TMP4);

  457.                 vis_and(TMP6, MASK_fe, TMP6);

  458.                 ref += stride;

  459. 

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

  461.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  462.                 vis_and(TMP8, MASK_fe, TMP8);

  463. 

  464.                 vis_ld64_2(ref, 8,  TMP16);

  465.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  466.                 vis_or(REF_0, REF_2, TMP10);

  467. 

  468.                 vis_ld64_2(ref, 16, TMP18);

  469.                 ref += stride;

  470.                 vis_or(REF_4, REF_6, TMP12);

  471. 

  472.                 vis_alignaddr_g0((void *)off);

  473. 

  474.                 vis_faligndata(TMP0, TMP2, REF_0);

  475. 

  476.                 vis_faligndata(TMP2, TMP4, REF_4);

  477. 

  478.                 if (off != 0x7) {

  479.                         vis_alignaddr_g0((void *)off_plus_1);

  480.                         vis_faligndata(TMP0, TMP2, REF_2);

  481.                         vis_faligndata(TMP2, TMP4, REF_6);

  482.                 } else {

  483.                         vis_src1(TMP2, REF_2);

  484.                         vis_src1(TMP4, REF_6);

  485.                 }

  486. 

  487.                 vis_and(TMP6, MASK_7f, TMP6);

  488. 

  489.                 vis_and(TMP8, MASK_7f, TMP8);

  490. 

  491.                 vis_psub16(TMP10, TMP6, TMP6);

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

  493. 

  494.                 vis_psub16(TMP12, TMP8, TMP8);

  495.                 vis_st64_2(TMP8, dest, 8);

  496.                 dest += stride;

  497. 

  498.                 vis_xor(REF_0, REF_2, TMP6);

  499. 

  500.                 vis_xor(REF_4, REF_6, TMP8);

  501. 

  502.                 vis_and(TMP6, MASK_fe, TMP6);

  503. 

  504.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  505.                 vis_and(TMP8, MASK_fe, TMP8);

  506. 

  507.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  508.                 vis_or(REF_0, REF_2, TMP10);

  509. 

  510.                 vis_or(REF_4, REF_6, TMP12);

  511. 

  512.                 vis_alignaddr_g0((void *)off);

  513. 

  514.                 vis_faligndata(TMP14, TMP16, REF_0);

  515. 

  516.                 vis_faligndata(TMP16, TMP18, REF_4);

  517. 

  518.                 if (off != 0x7) {

  519.                         vis_alignaddr_g0((void *)off_plus_1);

  520.                         vis_faligndata(TMP14, TMP16, REF_2);

  521.                         vis_faligndata(TMP16, TMP18, REF_6);

  522.                 } else {

  523.                         vis_src1(TMP16, REF_2);

  524.                         vis_src1(TMP18, REF_6);

  525.                 }

  526. 

  527.                 vis_and(TMP6, MASK_7f, TMP6);

  528. 

  529.                 vis_and(TMP8, MASK_7f, TMP8);

  530. 

  531.                 vis_psub16(TMP10, TMP6, TMP6);

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

  533. 

  534.                 vis_psub16(TMP12, TMP8, TMP8);

  535.                 vis_st64_2(TMP8, dest, 8);

  536.                 dest += stride;

  537.         } while (--height);

  538. 

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

  540.         vis_xor(REF_0, REF_2, TMP6);

  541. 

  542.         vis_ld64_2(ref, 8,  TMP2);

  543.         vis_xor(REF_4, REF_6, TMP8);

  544. 

  545.         vis_ld64_2(ref, 16, TMP4);

  546.         vis_and(TMP6, MASK_fe, TMP6);

  547. 

  548.         vis_mul8x16(CONST_128, TMP6, TMP6);

  549.         vis_and(TMP8, MASK_fe, TMP8);

  550. 

  551.         vis_mul8x16(CONST_128, TMP8, TMP8);

  552.         vis_or(REF_0, REF_2, TMP10);

  553. 

  554.         vis_or(REF_4, REF_6, TMP12);

  555. 

  556.         vis_alignaddr_g0((void *)off);

  557. 

  558.         vis_faligndata(TMP0, TMP2, REF_0);

  559. 

  560.         vis_faligndata(TMP2, TMP4, REF_4);

  561. 

  562.         if (off != 0x7) {

  563.                 vis_alignaddr_g0((void *)off_plus_1);

  564.                 vis_faligndata(TMP0, TMP2, REF_2);

  565.                 vis_faligndata(TMP2, TMP4, REF_6);

  566.         } else {

  567.                 vis_src1(TMP2, REF_2);

  568.                 vis_src1(TMP4, REF_6);

  569.         }

  570. 

  571.         vis_and(TMP6, MASK_7f, TMP6);

  572. 

  573.         vis_and(TMP8, MASK_7f, TMP8);

  574. 

  575.         vis_psub16(TMP10, TMP6, TMP6);

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

  577. 

  578.         vis_psub16(TMP12, TMP8, TMP8);

  579.         vis_st64_2(TMP8, dest, 8);

  580.         dest += stride;

  581. 

  582.         vis_xor(REF_0, REF_2, TMP6);

  583. 

  584.         vis_xor(REF_4, REF_6, TMP8);

  585. 

  586.         vis_and(TMP6, MASK_fe, TMP6);

  587. 

  588.         vis_mul8x16(CONST_128, TMP6, TMP6);

  589.         vis_and(TMP8, MASK_fe, TMP8);

  590. 

  591.         vis_mul8x16(CONST_128, TMP8, TMP8);

  592.         vis_or(REF_0, REF_2, TMP10);

  593. 

  594.         vis_or(REF_4, REF_6, TMP12);

  595. 

  596.         vis_and(TMP6, MASK_7f, TMP6);

  597. 

  598.         vis_and(TMP8, MASK_7f, TMP8);

  599. 

  600.         vis_psub16(TMP10, TMP6, TMP6);

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

  602. 

  603.         vis_psub16(TMP12, TMP8, TMP8);

  604.         vis_st64_2(TMP8, dest, 8);

  605. }

  606. 

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

  608.                             const ptrdiff_t line_size, int height)

  609. {

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

  611.         unsigned long off_plus_1 = off + 1;

  612. 

  613.         ref = vis_alignaddr(ref);

  614. 

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

  616. 

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

  618. 

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

  620. 

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

  622. 

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

  624.         vis_faligndata(TMP0, TMP2, REF_0);

  625. 

  626.         if (off != 0x7) {

  627.                 vis_alignaddr_g0((void *)off_plus_1);

  628.                 vis_faligndata(TMP0, TMP2, REF_2);

  629.         } else {

  630.                 vis_src1(TMP2, REF_2);

  631.         }

  632. 

  633.         ref += stride;

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

  635. 

  636.         do {    /* 20 cycles */

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

  638.                 vis_xor(REF_0, REF_2, TMP4);

  639. 

  640.                 vis_ld64_2(ref, 8, TMP2);

  641.                 vis_and(TMP4, MASK_fe, TMP4);

  642.                 ref += stride;

  643. 

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

  645.                 vis_or(REF_0, REF_2, TMP6);

  646.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  647. 

  648.                 vis_alignaddr_g0((void *)off);

  649. 

  650.                 vis_ld64_2(ref, 8, TMP10);

  651.                 ref += stride;

  652.                 vis_faligndata(TMP0, TMP2, REF_0);

  653. 

  654.                 if (off != 0x7) {

  655.                         vis_alignaddr_g0((void *)off_plus_1);

  656.                         vis_faligndata(TMP0, TMP2, REF_2);

  657.                 } else {

  658.                         vis_src1(TMP2, REF_2);

  659.                 }

  660. 

  661.                 vis_and(TMP4, MASK_7f, TMP4);

  662. 

  663.                 vis_psub16(TMP6, TMP4, DST_0);

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

  665.                 dest += stride;

  666. 

  667.                 vis_xor(REF_0, REF_2, TMP12);

  668. 

  669.                 vis_and(TMP12, MASK_fe, TMP12);

  670. 

  671.                 vis_or(REF_0, REF_2, TMP14);

  672.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  673. 

  674.                 vis_alignaddr_g0((void *)off);

  675.                 vis_faligndata(TMP8, TMP10, REF_0);

  676.                 if (off != 0x7) {

  677.                         vis_alignaddr_g0((void *)off_plus_1);

  678.                         vis_faligndata(TMP8, TMP10, REF_2);

  679.                 } else {

  680.                         vis_src1(TMP10, REF_2);

  681.                 }

  682. 

  683.                 vis_and(TMP12, MASK_7f, TMP12);

  684. 

  685.                 vis_psub16(TMP14, TMP12, DST_0);

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

  687.                 dest += stride;

  688.         } while (--height);

  689. 

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

  691.         vis_xor(REF_0, REF_2, TMP4);

  692. 

  693.         vis_ld64_2(ref, 8, TMP2);

  694.         vis_and(TMP4, MASK_fe, TMP4);

  695. 

  696.         vis_or(REF_0, REF_2, TMP6);

  697.         vis_mul8x16(CONST_128, TMP4, TMP4);

  698. 

  699.         vis_alignaddr_g0((void *)off);

  700. 

  701.         vis_faligndata(TMP0, TMP2, REF_0);

  702. 

  703.         if (off != 0x7) {

  704.                 vis_alignaddr_g0((void *)off_plus_1);

  705.                 vis_faligndata(TMP0, TMP2, REF_2);

  706.         } else {

  707.                 vis_src1(TMP2, REF_2);

  708.         }

  709. 

  710.         vis_and(TMP4, MASK_7f, TMP4);

  711. 

  712.         vis_psub16(TMP6, TMP4, DST_0);

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

  714.         dest += stride;

  715. 

  716.         vis_xor(REF_0, REF_2, TMP12);

  717. 

  718.         vis_and(TMP12, MASK_fe, TMP12);

  719. 

  720.         vis_or(REF_0, REF_2, TMP14);

  721.         vis_mul8x16(CONST_128, TMP12, TMP12);

  722. 

  723.         vis_and(TMP12, MASK_7f, TMP12);

  724. 

  725.         vis_psub16(TMP14, TMP12, DST_0);

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

  727.         dest += stride;

  728. }

  729. 

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

  731.                              const ptrdiff_t line_size, int height)

  732. {

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

  734.         unsigned long off_plus_1 = off + 1;

  735. 

  736.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  737. 

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

  739.         vis_fzero(ZERO);

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

  741. 

  742.         ref = vis_alignaddr(ref);

  743.         do {    /* 26 cycles */

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

  745. 

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

  747. 

  748.                 vis_alignaddr_g0((void *)off);

  749. 

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

  751. 

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

  753.                 vis_faligndata(TMP0, TMP2, REF_0);

  754. 

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

  756.                 vis_faligndata(TMP2, TMP4, REF_4);

  757. 

  758.                 if (off != 0x7) {

  759.                         vis_alignaddr_g0((void *)off_plus_1);

  760.                         vis_faligndata(TMP0, TMP2, REF_2);

  761.                         vis_faligndata(TMP2, TMP4, REF_6);

  762.                 } else {

  763.                         vis_src1(TMP2, REF_2);

  764.                         vis_src1(TMP4, REF_6);

  765.                 }

  766. 

  767.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  768. 

  769.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  770.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  771. 

  772.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  773. 

  774.                 vis_padd16(TMP0, TMP4, TMP0);

  775. 

  776.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  777.                 vis_padd16(TMP2, TMP6, TMP2);

  778. 

  779.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  780. 

  781.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  782. 

  783.                 vis_padd16(TMP0, TMP4, TMP0);

  784.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  785. 

  786.                 vis_padd16(TMP2, TMP6, TMP2);

  787.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  788. 

  789.                 vis_padd16(TMP0, CONST_3, TMP8);

  790.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  791. 

  792.                 vis_padd16(TMP2, CONST_3, TMP10);

  793.                 vis_pack16(TMP8, DST_0);

  794. 

  795.                 vis_pack16(TMP10, DST_1);

  796.                 vis_padd16(TMP16, TMP12, TMP0);

  797. 

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

  799.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  800.                 vis_padd16(TMP18, TMP14, TMP2);

  801. 

  802.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  803.                 vis_padd16(TMP0, CONST_3, TMP0);

  804. 

  805.                 vis_padd16(TMP2, CONST_3, TMP2);

  806. 

  807.                 vis_padd16(TMP0, TMP4, TMP0);

  808. 

  809.                 vis_padd16(TMP2, TMP6, TMP2);

  810.                 vis_pack16(TMP0, DST_2);

  811. 

  812.                 vis_pack16(TMP2, DST_3);

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

  814. 

  815.                 ref += stride;

  816.                 dest += stride;

  817.         } while (--height);

  818. }

  819. 

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

  821.                             const ptrdiff_t line_size, int height)

  822. {

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

  824.         unsigned long off_plus_1 = off + 1;

  825.         int stride_times_2 = stride << 1;

  826. 

  827.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  828. 

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

  830.         vis_fzero(ZERO);

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

  832. 

  833.         ref = vis_alignaddr(ref);

  834.         height >>= 2;

  835.         do {    /* 47 cycles */

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

  837. 

  838.                 vis_ld64_2(ref, 8, TMP2);

  839.                 ref += stride;

  840. 

  841.                 vis_alignaddr_g0((void *)off);

  842. 

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

  844.                 vis_faligndata(TMP0, TMP2, REF_0);

  845. 

  846.                 vis_ld64_2(ref, 8, TMP6);

  847.                 ref += stride;

  848. 

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

  850. 

  851.                 vis_ld64_2(ref, 8, TMP10);

  852.                 ref += stride;

  853.                 vis_faligndata(TMP4, TMP6, REF_4);

  854. 

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

  856. 

  857.                 vis_ld64_2(ref, 8, TMP14);

  858.                 ref += stride;

  859.                 vis_faligndata(TMP8, TMP10, REF_S0);

  860. 

  861.                 vis_faligndata(TMP12, TMP14, REF_S4);

  862. 

  863.                 if (off != 0x7) {

  864.                         vis_alignaddr_g0((void *)off_plus_1);

  865. 

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

  867.                         vis_faligndata(TMP0, TMP2, REF_2);

  868. 

  869.                         vis_ld64_2(dest, stride, DST_2);

  870.                         vis_faligndata(TMP4, TMP6, REF_6);

  871. 

  872.                         vis_faligndata(TMP8, TMP10, REF_S2);

  873. 

  874.                         vis_faligndata(TMP12, TMP14, REF_S6);

  875.                 } else {

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

  877.                         vis_src1(TMP2, REF_2);

  878. 

  879.                         vis_ld64_2(dest, stride, DST_2);

  880.                         vis_src1(TMP6, REF_6);

  881. 

  882.                         vis_src1(TMP10, REF_S2);

  883. 

  884.                         vis_src1(TMP14, REF_S6);

  885.                 }

  886. 

  887.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  888.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  889. 

  890.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  891.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  892. 

  893.                 vis_padd16(TMP0, CONST_3, TMP0);

  894.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  895. 

  896.                 vis_padd16(TMP2, CONST_3, TMP2);

  897.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  898. 

  899.                 vis_padd16(TMP0, TMP4, TMP0);

  900.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  901. 

  902.                 vis_padd16(TMP2, TMP6, TMP2);

  903.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  904. 

  905.                 vis_padd16(TMP0, TMP16, TMP0);

  906.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  907. 

  908.                 vis_padd16(TMP2, TMP18, TMP2);

  909.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  910. 

  911.                 vis_padd16(TMP8, CONST_3, TMP8);

  912.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  913. 

  914.                 vis_padd16(TMP8, TMP12, TMP8);

  915.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  916. 

  917.                 vis_padd16(TMP10, TMP14, TMP10);

  918.                 vis_pack16(TMP0, DST_0);

  919. 

  920.                 vis_pack16(TMP2, DST_1);

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

  922.                 dest += stride;

  923.                 vis_padd16(TMP10, CONST_3, TMP10);

  924. 

  925.                 vis_ld64_2(dest, stride, DST_0);

  926.                 vis_padd16(TMP8, TMP16, TMP8);

  927. 

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

  929.                 vis_padd16(TMP10, TMP18, TMP10);

  930.                 vis_pack16(TMP8, DST_2);

  931. 

  932.                 vis_pack16(TMP10, DST_3);

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

  934.                 dest += stride;

  935. 

  936.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  937.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  938. 

  939.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  940.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  941. 

  942.                 vis_padd16(TMP0, CONST_3, TMP0);

  943.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  944. 

  945.                 vis_padd16(TMP2, CONST_3, TMP2);

  946.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  947. 

  948.                 vis_padd16(TMP0, TMP24, TMP0);

  949.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  950. 

  951.                 vis_padd16(TMP2, TMP6, TMP2);

  952.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  953. 

  954.                 vis_padd16(TMP8, CONST_3, TMP8);

  955.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  956. 

  957.                 vis_padd16(TMP10, CONST_3, TMP10);

  958.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  959. 

  960.                 vis_padd16(TMP8, TMP12, TMP8);

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

  962. 

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

  964.                 vis_padd16(TMP0, TMP16, TMP0);

  965. 

  966.                 vis_padd16(TMP2, TMP18, TMP2);

  967.                 vis_pack16(TMP0, DST_0);

  968. 

  969.                 vis_padd16(TMP10, TMP14, TMP10);

  970.                 vis_pack16(TMP2, DST_1);

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

  972.                 dest += stride;

  973. 

  974.                 vis_padd16(TMP8, TMP20, TMP8);

  975. 

  976.                 vis_padd16(TMP10, TMP22, TMP10);

  977.                 vis_pack16(TMP8, DST_2);

  978. 

  979.                 vis_pack16(TMP10, DST_3);

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

  981.                 dest += stride;

  982.         } while (--height);

  983. }

  984. 

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

  986.                              const ptrdiff_t line_size, int height)

  987. {

  988.         ref = vis_alignaddr(ref);

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

  990. 

  991.         vis_ld64_2(ref, 8, TMP2);

  992. 

  993.         vis_ld64_2(ref, 16, TMP4);

  994.         ref += stride;

  995. 

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

  997.         vis_faligndata(TMP0, TMP2, REF_0);

  998. 

  999.         vis_ld64_2(ref, 8, TMP8);

  1000.         vis_faligndata(TMP2, TMP4, REF_4);

  1001. 

  1002.         vis_ld64_2(ref, 16, TMP10);

  1003.         ref += stride;

  1004. 

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

  1006.         vis_faligndata(TMP6, TMP8, REF_2);

  1007. 

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

  1009.         vis_faligndata(TMP8, TMP10, REF_6);

  1010. 

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

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

  1013.         do {    /* 24 cycles */

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

  1015.                 vis_xor(REF_0, REF_2, TMP12);

  1016. 

  1017.                 vis_ld64_2(ref, 8, TMP2);

  1018.                 vis_xor(REF_4, REF_6, TMP16);

  1019. 

  1020.                 vis_ld64_2(ref, 16, TMP4);

  1021.                 ref += stride;

  1022.                 vis_or(REF_0, REF_2, TMP14);

  1023. 

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

  1025.                 vis_or(REF_4, REF_6, TMP18);

  1026. 

  1027.                 vis_ld64_2(ref, 8, TMP8);

  1028.                 vis_faligndata(TMP0, TMP2, REF_0);

  1029. 

  1030.                 vis_ld64_2(ref, 16, TMP10);

  1031.                 ref += stride;

  1032.                 vis_faligndata(TMP2, TMP4, REF_4);

  1033. 

  1034.                 vis_and(TMP12, MASK_fe, TMP12);

  1035. 

  1036.                 vis_and(TMP16, MASK_fe, TMP16);

  1037.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1038. 

  1039.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  1040.                 vis_xor(REF_0, REF_2, TMP0);

  1041. 

  1042.                 vis_xor(REF_4, REF_6, TMP2);

  1043. 

  1044.                 vis_or(REF_0, REF_2, TMP20);

  1045. 

  1046.                 vis_and(TMP12, MASK_7f, TMP12);

  1047. 

  1048.                 vis_and(TMP16, MASK_7f, TMP16);

  1049. 

  1050.                 vis_psub16(TMP14, TMP12, TMP12);

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

  1052. 

  1053.                 vis_psub16(TMP18, TMP16, TMP16);

  1054.                 vis_st64_2(TMP16, dest, 8);

  1055.                 dest += stride;

  1056. 

  1057.                 vis_or(REF_4, REF_6, TMP18);

  1058. 

  1059.                 vis_and(TMP0, MASK_fe, TMP0);

  1060. 

  1061.                 vis_and(TMP2, MASK_fe, TMP2);

  1062.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  1063. 

  1064.                 vis_faligndata(TMP6, TMP8, REF_2);

  1065.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  1066. 

  1067.                 vis_faligndata(TMP8, TMP10, REF_6);

  1068. 

  1069.                 vis_and(TMP0, MASK_7f, TMP0);

  1070. 

  1071.                 vis_and(TMP2, MASK_7f, TMP2);

  1072. 

  1073.                 vis_psub16(TMP20, TMP0, TMP0);

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

  1075. 

  1076.                 vis_psub16(TMP18, TMP2, TMP2);

  1077.                 vis_st64_2(TMP2, dest, 8);

  1078.                 dest += stride;

  1079.         } while (--height);

  1080. 

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

  1082.         vis_xor(REF_0, REF_2, TMP12);

  1083. 

  1084.         vis_ld64_2(ref, 8, TMP2);

  1085.         vis_xor(REF_4, REF_6, TMP16);

  1086. 

  1087.         vis_ld64_2(ref, 16, TMP4);

  1088.         vis_or(REF_0, REF_2, TMP14);

  1089. 

  1090.         vis_or(REF_4, REF_6, TMP18);

  1091. 

  1092.         vis_faligndata(TMP0, TMP2, REF_0);

  1093. 

  1094.         vis_faligndata(TMP2, TMP4, REF_4);

  1095. 

  1096.         vis_and(TMP12, MASK_fe, TMP12);

  1097. 

  1098.         vis_and(TMP16, MASK_fe, TMP16);

  1099.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1100. 

  1101.         vis_mul8x16(CONST_128, TMP16, TMP16);

  1102.         vis_xor(REF_0, REF_2, TMP0);

  1103. 

  1104.         vis_xor(REF_4, REF_6, TMP2);

  1105. 

  1106.         vis_or(REF_0, REF_2, TMP20);

  1107. 

  1108.         vis_and(TMP12, MASK_7f, TMP12);

  1109. 

  1110.         vis_and(TMP16, MASK_7f, TMP16);

  1111. 

  1112.         vis_psub16(TMP14, TMP12, TMP12);

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

  1114. 

  1115.         vis_psub16(TMP18, TMP16, TMP16);

  1116.         vis_st64_2(TMP16, dest, 8);

  1117.         dest += stride;

  1118. 

  1119.         vis_or(REF_4, REF_6, TMP18);

  1120. 

  1121.         vis_and(TMP0, MASK_fe, TMP0);

  1122. 

  1123.         vis_and(TMP2, MASK_fe, TMP2);

  1124.         vis_mul8x16(CONST_128, TMP0, TMP0);

  1125. 

  1126.         vis_mul8x16(CONST_128, TMP2, TMP2);

  1127. 

  1128.         vis_and(TMP0, MASK_7f, TMP0);

  1129. 

  1130.         vis_and(TMP2, MASK_7f, TMP2);

  1131. 

  1132.         vis_psub16(TMP20, TMP0, TMP0);

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

  1134. 

  1135.         vis_psub16(TMP18, TMP2, TMP2);

  1136.         vis_st64_2(TMP2, dest, 8);

  1137. }

  1138. 

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

  1140.                             const ptrdiff_t line_size, int height)

  1141. {

  1142.         ref = vis_alignaddr(ref);

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

  1144. 

  1145.         vis_ld64_2(ref, 8, TMP2);

  1146.         ref += stride;

  1147. 

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

  1149. 

  1150.         vis_ld64_2(ref, 8, TMP6);

  1151.         ref += stride;

  1152. 

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

  1154.         vis_faligndata(TMP0, TMP2, REF_0);

  1155. 

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

  1157.         vis_faligndata(TMP4, TMP6, REF_2);

  1158. 

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

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

  1161.         do {    /* 12 cycles */

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

  1163.                 vis_xor(REF_0, REF_2, TMP4);

  1164. 

  1165.                 vis_ld64_2(ref, 8, TMP2);

  1166.                 ref += stride;

  1167.                 vis_and(TMP4, MASK_fe, TMP4);

  1168. 

  1169.                 vis_or(REF_0, REF_2, TMP6);

  1170.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  1171. 

  1172.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  1174. 

  1175.                 vis_ld64_2(ref, 8, TMP2);

  1176.                 ref += stride;

  1177.                 vis_xor(REF_0, REF_2, TMP12);

  1178. 

  1179.                 vis_and(TMP4, MASK_7f, TMP4);

  1180. 

  1181.                 vis_and(TMP12, MASK_fe, TMP12);

  1182. 

  1183.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1184.                 vis_or(REF_0, REF_2, TMP14);

  1185. 

  1186.                 vis_psub16(TMP6, TMP4, DST_0);

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

  1188.                 dest += stride;

  1189. 

  1190.                 vis_faligndata(TMP0, TMP2, REF_2);

  1191. 

  1192.                 vis_and(TMP12, MASK_7f, TMP12);

  1193. 

  1194.                 vis_psub16(TMP14, TMP12, DST_0);

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

  1196.                 dest += stride;

  1197.         } while (--height);

  1198. 

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

  1200.         vis_xor(REF_0, REF_2, TMP4);

  1201. 

  1202.         vis_ld64_2(ref, 8, TMP2);

  1203.         vis_and(TMP4, MASK_fe, TMP4);

  1204. 

  1205.         vis_or(REF_0, REF_2, TMP6);

  1206.         vis_mul8x16(CONST_128, TMP4, TMP4);

  1207. 

  1208.         vis_faligndata(TMP0, TMP2, REF_0);

  1209. 

  1210.         vis_xor(REF_0, REF_2, TMP12);

  1211. 

  1212.         vis_and(TMP4, MASK_7f, TMP4);

  1213. 

  1214.         vis_and(TMP12, MASK_fe, TMP12);

  1215. 

  1216.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1217.         vis_or(REF_0, REF_2, TMP14);

  1218. 

  1219.         vis_psub16(TMP6, TMP4, DST_0);

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

  1221.         dest += stride;

  1222. 

  1223.         vis_and(TMP12, MASK_7f, TMP12);

  1224. 

  1225.         vis_psub16(TMP14, TMP12, DST_0);

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

  1227. }

  1228. 

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

  1230.                              const ptrdiff_t line_size, int height)

  1231. {

  1232.         int stride_8 = stride + 8;

  1233.         int stride_16 = stride + 16;

  1234. 

  1235.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1236. 

  1237.         ref = vis_alignaddr(ref);

  1238. 

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

  1240.         vis_fzero(ZERO);

  1241. 

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

  1243. 

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

  1245. 

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

  1247.         vis_faligndata(TMP0, TMP2, REF_2);

  1248. 

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

  1250.         vis_faligndata(TMP2, TMP4, REF_6);

  1251.         height >>= 1;

  1252. 

  1253.         do {    /* 31 cycles */

  1254.                 vis_ld64_2(ref, stride, TMP0);

  1255.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  1256.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  1257. 

  1258.                 vis_ld64_2(ref, stride_8, TMP2);

  1259.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  1260.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  1261. 

  1262.                 vis_ld64_2(ref, stride_16, TMP4);

  1263.                 ref += stride;

  1264. 

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

  1266.                 vis_faligndata(TMP0, TMP2, REF_0);

  1267. 

  1268.                 vis_ld64_2(dest, 8, DST_2);

  1269.                 vis_faligndata(TMP2, TMP4, REF_4);

  1270. 

  1271.                 vis_ld64_2(ref, stride, TMP6);

  1272.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  1273.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  1274. 

  1275.                 vis_ld64_2(ref, stride_8, TMP8);

  1276.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  1277. 

  1278.                 vis_ld64_2(ref, stride_16, TMP10);

  1279.                 ref += stride;

  1280. 

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

  1282.                 vis_faligndata(TMP6, TMP8, REF_2);

  1283.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1284. 

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

  1286.                 vis_faligndata(TMP8, TMP10, REF_6);

  1287.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  1288. 

  1289.                 vis_padd16(TMP0, CONST_3, TMP0);

  1290.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  1291. 

  1292.                 vis_padd16(TMP2, CONST_3, TMP2);

  1293.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1294. 

  1295.                 vis_padd16(TMP4, CONST_3, TMP4);

  1296.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1297. 

  1298.                 vis_padd16(TMP6, CONST_3, TMP6);

  1299. 

  1300.                 vis_padd16(TMP12, TMP20, TMP12);

  1301.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  1302. 

  1303.                 vis_padd16(TMP14, TMP22, TMP14);

  1304.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  1305. 

  1306.                 vis_padd16(TMP16, TMP24, TMP16);

  1307.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  1308. 

  1309.                 vis_padd16(TMP18, TMP26, TMP18);

  1310.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  1311. 

  1312.                 vis_padd16(TMP12, TMP0, TMP12);

  1313.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  1314. 

  1315.                 vis_padd16(TMP14, TMP2, TMP14);

  1316.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  1317. 

  1318.                 vis_padd16(TMP16, TMP4, TMP16);

  1319.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  1320. 

  1321.                 vis_padd16(TMP18, TMP6, TMP18);

  1322.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  1323. 

  1324.                 vis_pack16(TMP12, DST_0);

  1325.                 vis_padd16(TMP28, TMP0, TMP12);

  1326. 

  1327.                 vis_pack16(TMP14, DST_1);

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

  1329.                 vis_padd16(TMP30, TMP2, TMP14);

  1330. 

  1331.                 vis_pack16(TMP16, DST_2);

  1332.                 vis_padd16(REF_S4, TMP4, TMP16);

  1333. 

  1334.                 vis_pack16(TMP18, DST_3);

  1335.                 vis_st64_2(DST_2, dest, 8);

  1336.                 dest += stride;

  1337.                 vis_padd16(REF_S6, TMP6, TMP18);

  1338. 

  1339.                 vis_padd16(TMP12, TMP20, TMP12);

  1340. 

  1341.                 vis_padd16(TMP14, TMP22, TMP14);

  1342.                 vis_pack16(TMP12, DST_0);

  1343. 

  1344.                 vis_padd16(TMP16, TMP24, TMP16);

  1345.                 vis_pack16(TMP14, DST_1);

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

  1347. 

  1348.                 vis_padd16(TMP18, TMP26, TMP18);

  1349.                 vis_pack16(TMP16, DST_2);

  1350. 

  1351.                 vis_pack16(TMP18, DST_3);

  1352.                 vis_st64_2(DST_2, dest, 8);

  1353.                 dest += stride;

  1354.         } while (--height);

  1355. }

  1356. 

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

  1358.                             const ptrdiff_t line_size, int height)

  1359. {

  1360.         int stride_8 = stride + 8;

  1361. 

  1362.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1363. 

  1364.         ref = vis_alignaddr(ref);

  1365. 

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

  1367.         vis_fzero(ZERO);

  1368. 

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

  1370. 

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

  1372.         vis_faligndata(TMP0, TMP2, REF_2);

  1373. 

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

  1375. 

  1376.         height >>= 1;

  1377.         do {    /* 20 cycles */

  1378.                 vis_ld64_2(ref, stride, TMP0);

  1379.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  1380.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  1381. 

  1382.                 vis_ld64_2(ref, stride_8, TMP2);

  1383.                 ref += stride;

  1384. 

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

  1386. 

  1387.                 vis_ld64_2(dest, stride, DST_2);

  1388.                 vis_faligndata(TMP0, TMP2, REF_0);

  1389. 

  1390.                 vis_ld64_2(ref, stride, TMP4);

  1391.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  1392.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  1393. 

  1394.                 vis_ld64_2(ref, stride_8, TMP6);

  1395.                 ref += stride;

  1396.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  1397.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  1398. 

  1399.                 vis_padd16(TMP12, CONST_3, TMP12);

  1400.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1401. 

  1402.                 vis_padd16(TMP14, CONST_3, TMP14);

  1403.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1404. 

  1405.                 vis_faligndata(TMP4, TMP6, REF_2);

  1406. 

  1407.                 vis_padd16(TMP8, TMP12, TMP8);

  1408. 

  1409.                 vis_padd16(TMP10, TMP14, TMP10);

  1410.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  1411. 

  1412.                 vis_padd16(TMP8, TMP16, TMP0);

  1413.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  1414. 

  1415.                 vis_padd16(TMP10, TMP18, TMP2);

  1416.                 vis_pack16(TMP0, DST_0);

  1417. 

  1418.                 vis_pack16(TMP2, DST_1);

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

  1420.                 dest += stride;

  1421.                 vis_padd16(TMP12, TMP20, TMP12);

  1422. 

  1423.                 vis_padd16(TMP14, TMP22, TMP14);

  1424. 

  1425.                 vis_padd16(TMP12, TMP24, TMP0);

  1426. 

  1427.                 vis_padd16(TMP14, TMP26, TMP2);

  1428.                 vis_pack16(TMP0, DST_2);

  1429. 

  1430.                 vis_pack16(TMP2, DST_3);

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

  1432.                 dest += stride;

  1433.         } while (--height);

  1434. }

  1435. 

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

  1437.                               const ptrdiff_t line_size, int height)

  1438. {

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

  1440.         unsigned long off_plus_1 = off + 1;

  1441.         int stride_8 = stride + 8;

  1442.         int stride_16 = stride + 16;

  1443. 

  1444.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1445. 

  1446.         ref = vis_alignaddr(ref);

  1447. 

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

  1449.         vis_fzero(ZERO);

  1450. 

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

  1452. 

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

  1454. 

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

  1456.         vis_faligndata(TMP0, TMP2, REF_S0);

  1457. 

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

  1459.         vis_faligndata(TMP2, TMP4, REF_S4);

  1460. 

  1461.         if (off != 0x7) {

  1462.                 vis_alignaddr_g0((void *)off_plus_1);

  1463.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1464.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1465.         } else {

  1466.                 vis_src1(TMP2, REF_S2);

  1467.                 vis_src1(TMP4, REF_S6);

  1468.         }

  1469. 

  1470.         height >>= 1;

  1471.         do {

  1472.                 vis_ld64_2(ref, stride, TMP0);

  1473.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1474.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1475. 

  1476.                 vis_alignaddr_g0((void *)off);

  1477. 

  1478.                 vis_ld64_2(ref, stride_8, TMP2);

  1479.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1480.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1481. 

  1482.                 vis_ld64_2(ref, stride_16, TMP4);

  1483.                 ref += stride;

  1484.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1485.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1486. 

  1487.                 vis_ld64_2(ref, stride, TMP6);

  1488.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1489.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1490. 

  1491.                 vis_ld64_2(ref, stride_8, TMP8);

  1492.                 vis_faligndata(TMP0, TMP2, REF_0);

  1493. 

  1494.                 vis_ld64_2(ref, stride_16, TMP10);

  1495.                 ref += stride;

  1496.                 vis_faligndata(TMP2, TMP4, REF_4);

  1497. 

  1498.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1499. 

  1500.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1501. 

  1502.                 if (off != 0x7) {

  1503.                         vis_alignaddr_g0((void *)off_plus_1);

  1504.                         vis_faligndata(TMP0, TMP2, REF_2);

  1505.                         vis_faligndata(TMP2, TMP4, REF_6);

  1506.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1507.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1508.                 } else {

  1509.                         vis_src1(TMP2, REF_2);

  1510.                         vis_src1(TMP4, REF_6);

  1511.                         vis_src1(TMP8, REF_S2);

  1512.                         vis_src1(TMP10, REF_S6);

  1513.                 }

  1514. 

  1515.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  1516.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1517. 

  1518.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1519.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1520. 

  1521.                 vis_padd16(TMP0, CONST_2, TMP8);

  1522.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  1523. 

  1524.                 vis_padd16(TMP2, CONST_2, TMP10);

  1525.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  1526. 

  1527.                 vis_padd16(TMP8, TMP4, TMP8);

  1528.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  1529. 

  1530.                 vis_padd16(TMP10, TMP6, TMP10);

  1531.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  1532. 

  1533.                 vis_padd16(TMP12, TMP8, TMP12);

  1534. 

  1535.                 vis_padd16(TMP14, TMP10, TMP14);

  1536. 

  1537.                 vis_padd16(TMP12, TMP16, TMP12);

  1538. 

  1539.                 vis_padd16(TMP14, TMP18, TMP14);

  1540.                 vis_pack16(TMP12, DST_0);

  1541. 

  1542.                 vis_pack16(TMP14, DST_1);

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

  1544.                 vis_padd16(TMP0, CONST_2, TMP12);

  1545. 

  1546.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  1547.                 vis_padd16(TMP2, CONST_2, TMP14);

  1548. 

  1549.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  1550.                 vis_padd16(TMP12, TMP4, TMP12);

  1551. 

  1552.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  1553.                 vis_padd16(TMP14, TMP6, TMP14);

  1554. 

  1555.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  1556.                 vis_padd16(TMP20, TMP12, TMP20);

  1557. 

  1558.                 vis_padd16(TMP22, TMP14, TMP22);

  1559. 

  1560.                 vis_padd16(TMP20, TMP24, TMP20);

  1561. 

  1562.                 vis_padd16(TMP22, TMP26, TMP22);

  1563.                 vis_pack16(TMP20, DST_2);

  1564. 

  1565.                 vis_pack16(TMP22, DST_3);

  1566.                 vis_st64_2(DST_2, dest, 8);

  1567.                 dest += stride;

  1568.                 vis_padd16(TMP0, TMP4, TMP24);

  1569. 

  1570.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  1571.                 vis_padd16(TMP2, TMP6, TMP26);

  1572. 

  1573.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  1574.                 vis_padd16(TMP24, TMP8, TMP24);

  1575. 

  1576.                 vis_padd16(TMP26, TMP10, TMP26);

  1577.                 vis_pack16(TMP24, DST_0);

  1578. 

  1579.                 vis_pack16(TMP26, DST_1);

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

  1581.                 vis_pmerge(ZERO, REF_S6, TMP4);

  1582. 

  1583.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  1584. 

  1585.                 vis_padd16(TMP0, TMP4, TMP0);

  1586. 

  1587.                 vis_padd16(TMP2, TMP6, TMP2);

  1588. 

  1589.                 vis_padd16(TMP0, TMP12, TMP0);

  1590. 

  1591.                 vis_padd16(TMP2, TMP14, TMP2);

  1592.                 vis_pack16(TMP0, DST_2);

  1593. 

  1594.                 vis_pack16(TMP2, DST_3);

  1595.                 vis_st64_2(DST_2, dest, 8);

  1596.                 dest += stride;

  1597.         } while (--height);

  1598. }

  1599. 

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

  1601.                              const ptrdiff_t line_size, int height)

  1602. {

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

  1604.         unsigned long off_plus_1 = off + 1;

  1605.         int stride_8 = stride + 8;

  1606. 

  1607.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1608. 

  1609.         ref = vis_alignaddr(ref);

  1610. 

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

  1612.         vis_fzero(ZERO);

  1613. 

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

  1615. 

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

  1617. 

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

  1619.         vis_faligndata(TMP0, TMP2, REF_S0);

  1620. 

  1621.         if (off != 0x7) {

  1622.                 vis_alignaddr_g0((void *)off_plus_1);

  1623.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1624.         } else {

  1625.                 vis_src1(TMP2, REF_S2);

  1626.         }

  1627. 

  1628.         height >>= 1;

  1629.         do {    /* 26 cycles */

  1630.                 vis_ld64_2(ref, stride, TMP0);

  1631.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  1632.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  1633. 

  1634.                 vis_alignaddr_g0((void *)off);

  1635. 

  1636.                 vis_ld64_2(ref, stride_8, TMP2);

  1637.                 ref += stride;

  1638.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  1639.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  1640. 

  1641.                 vis_ld64_2(ref, stride, TMP4);

  1642. 

  1643.                 vis_ld64_2(ref, stride_8, TMP6);

  1644.                 ref += stride;

  1645.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1646. 

  1647.                 vis_pmerge(ZERO, REF_S4, TMP18);

  1648. 

  1649.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  1650. 

  1651.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1652. 

  1653.                 if (off != 0x7) {

  1654.                         vis_alignaddr_g0((void *)off_plus_1);

  1655.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1656.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1657.                 } else {

  1658.                         vis_src1(TMP2, REF_S6);

  1659.                         vis_src1(TMP6, REF_S2);

  1660.                 }

  1661. 

  1662.                 vis_padd16(TMP18, CONST_2, TMP18);

  1663.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  1664. 

  1665.                 vis_padd16(TMP20, CONST_2, TMP20);

  1666.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  1667. 

  1668.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  1669.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  1670. 

  1671.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  1672.                 vis_padd16(TMP18, TMP22, TMP18);

  1673. 

  1674.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  1675.                 vis_padd16(TMP20, TMP24, TMP20);

  1676. 

  1677.                 vis_padd16(TMP8,  TMP18, TMP8);

  1678. 

  1679.                 vis_padd16(TMP10, TMP20, TMP10);

  1680. 

  1681.                 vis_padd16(TMP8,  TMP12, TMP8);

  1682. 

  1683.                 vis_padd16(TMP10, TMP14, TMP10);

  1684.                 vis_pack16(TMP8,  DST_0);

  1685. 

  1686.                 vis_pack16(TMP10, DST_1);

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

  1688.                 dest += stride;

  1689.                 vis_padd16(TMP18, TMP26, TMP18);

  1690. 

  1691.                 vis_padd16(TMP20, TMP28, TMP20);

  1692. 

  1693.                 vis_padd16(TMP18, TMP30, TMP18);

  1694. 

  1695.                 vis_padd16(TMP20, TMP32, TMP20);

  1696.                 vis_pack16(TMP18, DST_2);

  1697. 

  1698.                 vis_pack16(TMP20, DST_3);

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

  1700.                 dest += stride;

  1701.         } while (--height);

  1702. }

  1703. 

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

  1705.                               const ptrdiff_t line_size, int height)

  1706. {

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

  1708.         unsigned long off_plus_1 = off + 1;

  1709.         int stride_8 = stride + 8;

  1710.         int stride_16 = stride + 16;

  1711. 

  1712.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1713. 

  1714.         ref = vis_alignaddr(ref);

  1715. 

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

  1717.         vis_fzero(ZERO);

  1718. 

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

  1720. 

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

  1722. 

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

  1724.         vis_faligndata(TMP0, TMP2, REF_S0);

  1725. 

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

  1727.         vis_faligndata(TMP2, TMP4, REF_S4);

  1728. 

  1729.         if (off != 0x7) {

  1730.                 vis_alignaddr_g0((void *)off_plus_1);

  1731.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1732.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1733.         } else {

  1734.                 vis_src1(TMP2, REF_S2);

  1735.                 vis_src1(TMP4, REF_S6);

  1736.         }

  1737. 

  1738.         height >>= 1;

  1739.         do {    /* 55 cycles */

  1740.                 vis_ld64_2(ref, stride, TMP0);

  1741.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1742.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1743. 

  1744.                 vis_alignaddr_g0((void *)off);

  1745. 

  1746.                 vis_ld64_2(ref, stride_8, TMP2);

  1747.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1748.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1749. 

  1750.                 vis_ld64_2(ref, stride_16, TMP4);

  1751.                 ref += stride;

  1752.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1753.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1754. 

  1755.                 vis_ld64_2(ref, stride, TMP6);

  1756.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1757.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1758. 

  1759.                 vis_ld64_2(ref, stride_8, TMP8);

  1760.                 vis_faligndata(TMP0, TMP2, REF_0);

  1761. 

  1762.                 vis_ld64_2(ref, stride_16, TMP10);

  1763.                 ref += stride;

  1764.                 vis_faligndata(TMP2, TMP4, REF_4);

  1765. 

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

  1767.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1768. 

  1769.                 vis_ld64_2(dest, 8, DST_2);

  1770.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1771. 

  1772.                 if (off != 0x7) {

  1773.                         vis_alignaddr_g0((void *)off_plus_1);

  1774.                         vis_faligndata(TMP0, TMP2, REF_2);

  1775.                         vis_faligndata(TMP2, TMP4, REF_6);

  1776.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1777.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1778.                 } else {

  1779.                         vis_src1(TMP2, REF_2);

  1780.                         vis_src1(TMP4, REF_6);

  1781.                         vis_src1(TMP8, REF_S2);

  1782.                         vis_src1(TMP10, REF_S6);

  1783.                 }

  1784. 

  1785.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1786.                 vis_pmerge(ZERO, REF_0, TMP0);

  1787. 

  1788.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1789.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1790. 

  1791.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1792.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1793. 

  1794.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1795.                 vis_padd16(TMP0, CONST_6, TMP0);

  1796. 

  1797.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1798.                 vis_padd16(TMP2, CONST_6, TMP2);

  1799. 

  1800.                 vis_padd16(TMP0, TMP4, TMP0);

  1801.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  1802. 

  1803.                 vis_padd16(TMP2, TMP6, TMP2);

  1804.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1805. 

  1806.                 vis_padd16(TMP12, TMP0, TMP12);

  1807.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  1808. 

  1809.                 vis_padd16(TMP14, TMP2, TMP14);

  1810.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  1811. 

  1812.                 vis_padd16(TMP12, TMP16, TMP12);

  1813.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  1814. 

  1815.                 vis_padd16(TMP14, TMP18, TMP14);

  1816.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  1817. 

  1818.                 vis_padd16(TMP12, TMP30, TMP12);

  1819. 

  1820.                 vis_padd16(TMP14, TMP32, TMP14);

  1821.                 vis_pack16(TMP12, DST_0);

  1822. 

  1823.                 vis_pack16(TMP14, DST_1);

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

  1825.                 vis_padd16(TMP4, CONST_6, TMP4);

  1826. 

  1827.                 vis_ld64_2(dest, stride, DST_0);

  1828.                 vis_padd16(TMP6, CONST_6, TMP6);

  1829.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1830. 

  1831.                 vis_padd16(TMP4, TMP8, TMP4);

  1832.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  1833. 

  1834.                 vis_padd16(TMP6, TMP10, TMP6);

  1835. 

  1836.                 vis_padd16(TMP20, TMP4, TMP20);

  1837. 

  1838.                 vis_padd16(TMP22, TMP6, TMP22);

  1839. 

  1840.                 vis_padd16(TMP20, TMP24, TMP20);

  1841. 

  1842.                 vis_padd16(TMP22, TMP26, TMP22);

  1843. 

  1844.                 vis_padd16(TMP20, REF_0, TMP20);

  1845.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  1846. 

  1847.                 vis_padd16(TMP22, REF_2, TMP22);

  1848.                 vis_pack16(TMP20, DST_2);

  1849. 

  1850.                 vis_pack16(TMP22, DST_3);

  1851.                 vis_st64_2(DST_2, dest, 8);

  1852.                 dest += stride;

  1853. 

  1854.                 vis_ld64_2(dest, 8, DST_2);

  1855.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1856.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  1857. 

  1858.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1859.                 vis_padd16(REF_4, TMP0, TMP8);

  1860. 

  1861.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  1862.                 vis_padd16(REF_6, TMP2, TMP10);

  1863. 

  1864.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  1865.                 vis_padd16(TMP8, TMP12, TMP8);

  1866. 

  1867.                 vis_padd16(TMP10, TMP14, TMP10);

  1868. 

  1869.                 vis_padd16(TMP8, TMP30, TMP8);

  1870. 

  1871.                 vis_padd16(TMP10, TMP32, TMP10);

  1872.                 vis_pack16(TMP8, DST_0);

  1873. 

  1874.                 vis_pack16(TMP10, DST_1);

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

  1876. 

  1877.                 vis_padd16(REF_0, TMP4, REF_0);

  1878. 

  1879.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  1880.                 vis_padd16(REF_2, TMP6, REF_2);

  1881. 

  1882.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  1883.                 vis_padd16(REF_0, REF_4, REF_0);

  1884. 

  1885.                 vis_padd16(REF_2, REF_6, REF_2);

  1886. 

  1887.                 vis_padd16(REF_0, TMP30, REF_0);

  1888. 

  1889.                 /* stall */

  1890. 

  1891.                 vis_padd16(REF_2, TMP32, REF_2);

  1892.                 vis_pack16(REF_0, DST_2);

  1893. 

  1894.                 vis_pack16(REF_2, DST_3);

  1895.                 vis_st64_2(DST_2, dest, 8);

  1896.                 dest += stride;

  1897.         } while (--height);

  1898. }

  1899. 

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

  1901.                              const ptrdiff_t line_size, int height)

  1902. {

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

  1904.         unsigned long off_plus_1 = off + 1;

  1905.         int stride_8 = stride + 8;

  1906. 

  1907.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1908. 

  1909.         ref = vis_alignaddr(ref);

  1910. 

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

  1912.         vis_fzero(ZERO);

  1913. 

  1914.         vis_ld64_2(ref, 8, TMP2);

  1915. 

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

  1917. 

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

  1919.         vis_faligndata(TMP0, TMP2, REF_S0);

  1920. 

  1921.         if (off != 0x7) {

  1922.                 vis_alignaddr_g0((void *)off_plus_1);

  1923.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1924.         } else {

  1925.                 vis_src1(TMP2, REF_S2);

  1926.         }

  1927. 

  1928.         height >>= 1;

  1929.         do {    /* 31 cycles */

  1930.                 vis_ld64_2(ref, stride, TMP0);

  1931.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  1932.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  1933. 

  1934.                 vis_ld64_2(ref, stride_8, TMP2);

  1935.                 ref += stride;

  1936.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1937.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  1938. 

  1939.                 vis_alignaddr_g0((void *)off);

  1940. 

  1941.                 vis_ld64_2(ref, stride, TMP4);

  1942.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1943. 

  1944.                 vis_ld64_2(ref, stride_8, TMP6);

  1945.                 ref += stride;

  1946. 

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

  1948.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1949. 

  1950.                 vis_ld64_2(dest, stride, DST_2);

  1951. 

  1952.                 if (off != 0x7) {

  1953.                         vis_alignaddr_g0((void *)off_plus_1);

  1954.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1955.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1956.                 } else {

  1957.                         vis_src1(TMP2, REF_S6);

  1958.                         vis_src1(TMP6, REF_S2);

  1959.                 }

  1960. 

  1961.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1962.                 vis_pmerge(ZERO, REF_S4, TMP22);

  1963. 

  1964.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1965.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  1966. 

  1967.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  1968.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  1969. 

  1970.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  1971.                 vis_padd16(TMP22, CONST_6, TMP22);

  1972. 

  1973.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  1974.                 vis_padd16(TMP24, CONST_6, TMP24);

  1975. 

  1976.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1977.                 vis_padd16(TMP22, TMP26, TMP22);

  1978. 

  1979.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1980.                 vis_padd16(TMP24, TMP28, TMP24);

  1981. 

  1982.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  1983.                 vis_padd16(TMP8, TMP22, TMP8);

  1984. 

  1985.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  1986.                 vis_padd16(TMP10, TMP24, TMP10);

  1987. 

  1988.                 vis_padd16(TMP8, TMP12, TMP8);

  1989. 

  1990.                 vis_padd16(TMP10, TMP14, TMP10);

  1991. 

  1992.                 vis_padd16(TMP8, TMP30, TMP8);

  1993. 

  1994.                 vis_padd16(TMP10, TMP32, TMP10);

  1995.                 vis_pack16(TMP8, DST_0);

  1996. 

  1997.                 vis_pack16(TMP10, DST_1);

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

  1999.                 dest += stride;

  2000. 

  2001.                 vis_padd16(REF_S4, TMP22, TMP12);

  2002. 

  2003.                 vis_padd16(REF_S6, TMP24, TMP14);

  2004. 

  2005.                 vis_padd16(TMP12, TMP26, TMP12);

  2006. 

  2007.                 vis_padd16(TMP14, TMP28, TMP14);

  2008. 

  2009.                 vis_padd16(TMP12, REF_0, TMP12);

  2010. 

  2011.                 vis_padd16(TMP14, REF_2, TMP14);

  2012.                 vis_pack16(TMP12, DST_2);

  2013. 

  2014.                 vis_pack16(TMP14, DST_3);

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

  2016.                 dest += stride;

  2017.         } while (--height);

  2018. }

  2019. 

  2020. /* End of rounding code */

  2021. 

  2022. /* Start of no rounding code */

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

  2024.  * motion comp code, which is:

  2025.  *

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

  2027.  *

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

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

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

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

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

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

  2034.  *

  2035.  *      fxor            f0,   f2, f10

  2036.  *      fand            f10,  f4, f10

  2037.  *      fmul8x16        f8,  f10, f10

  2038.  *      fand            f10,  f6, f10

  2039.  *      fand            f0,   f2, f12

  2040.  *      fpadd16         f12, f10, f10

  2041.  */

  2042. 

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

  2044.                                       const ptrdiff_t line_size, int height)

  2045. {

  2046.         ref = vis_alignaddr(ref);

  2047.         do {    /* 5 cycles */

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

  2049. 

  2050.                 vis_ld64_2(ref, 8, TMP2);

  2051. 

  2052.                 vis_ld64_2(ref, 16, TMP4);

  2053.                 ref += stride;

  2054. 

  2055.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2057. 

  2058.                 vis_faligndata(TMP2, TMP4, REF_2);

  2059.                 vis_st64_2(REF_2, dest, 8);

  2060.                 dest += stride;

  2061.         } while (--height);

  2062. }

  2063. 

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

  2065.                             const ptrdiff_t line_size, int height)

  2066. {

  2067.         ref = vis_alignaddr(ref);

  2068.         do {    /* 4 cycles */

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

  2070. 

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

  2072.                 ref += stride;

  2073. 

  2074.                 /* stall */

  2075. 

  2076.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2078.                 dest += stride;

  2079.         } while (--height);

  2080. }

  2081. 

  2082. 

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

  2084.                              const ptrdiff_t line_size, int height)

  2085. {

  2086.         int stride_8 = stride + 8;

  2087. 

  2088.         ref = vis_alignaddr(ref);

  2089. 

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

  2091. 

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

  2093. 

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

  2095. 

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

  2097. 

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

  2099. 

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

  2101.         vis_faligndata(TMP0, TMP2, REF_0);

  2102. 

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

  2104.         vis_faligndata(TMP2, TMP4, REF_2);

  2105. 

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

  2107. 

  2108.         ref += stride;

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

  2110. 

  2111.         do {    /* 24 cycles */

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

  2113.                 vis_xor(DST_0, REF_0, TMP6);

  2114. 

  2115.                 vis_ld64_2(ref, 8, TMP2);

  2116.                 vis_and(TMP6, MASK_fe, TMP6);

  2117. 

  2118.                 vis_ld64_2(ref, 16, TMP4);

  2119.                 ref += stride;

  2120.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2121.                 vis_xor(DST_2, REF_2, TMP8);

  2122. 

  2123.                 vis_and(TMP8, MASK_fe, TMP8);

  2124. 

  2125.                 vis_and(DST_0, REF_0, TMP10);

  2126.                 vis_ld64_2(dest, stride, DST_0);

  2127.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2128. 

  2129.                 vis_and(DST_2, REF_2, TMP12);

  2130.                 vis_ld64_2(dest, stride_8, DST_2);

  2131. 

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

  2133.                 vis_and(TMP6, MASK_7f, TMP6);

  2134. 

  2135.                 vis_and(TMP8, MASK_7f, TMP8);

  2136. 

  2137.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2139. 

  2140.                 vis_padd16(TMP12, TMP8, TMP8);

  2141.                 vis_st64_2(TMP8, dest, 8);

  2142. 

  2143.                 dest += stride;

  2144.                 vis_ld64_2(ref, 8, TMP16);

  2145.                 vis_faligndata(TMP0, TMP2, REF_0);

  2146. 

  2147.                 vis_ld64_2(ref, 16, TMP18);

  2148.                 vis_faligndata(TMP2, TMP4, REF_2);

  2149.                 ref += stride;

  2150. 

  2151.                 vis_xor(DST_0, REF_0, TMP20);

  2152. 

  2153.                 vis_and(TMP20, MASK_fe, TMP20);

  2154. 

  2155.                 vis_xor(DST_2, REF_2, TMP22);

  2156.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  2157. 

  2158.                 vis_and(TMP22, MASK_fe, TMP22);

  2159. 

  2160.                 vis_and(DST_0, REF_0, TMP24);

  2161.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  2162. 

  2163.                 vis_and(DST_2, REF_2, TMP26);

  2164. 

  2165.                 vis_ld64_2(dest, stride, DST_0);

  2166.                 vis_faligndata(TMP14, TMP16, REF_0);

  2167. 

  2168.                 vis_ld64_2(dest, stride_8, DST_2);

  2169.                 vis_faligndata(TMP16, TMP18, REF_2);

  2170. 

  2171.                 vis_and(TMP20, MASK_7f, TMP20);

  2172. 

  2173.                 vis_and(TMP22, MASK_7f, TMP22);

  2174. 

  2175.                 vis_padd16(TMP24, TMP20, TMP20);

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

  2177. 

  2178.                 vis_padd16(TMP26, TMP22, TMP22);

  2179.                 vis_st64_2(TMP22, dest, 8);

  2180.                 dest += stride;

  2181.         } while (--height);

  2182. 

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

  2184.         vis_xor(DST_0, REF_0, TMP6);

  2185. 

  2186.         vis_ld64_2(ref, 8, TMP2);

  2187.         vis_and(TMP6, MASK_fe, TMP6);

  2188. 

  2189.         vis_ld64_2(ref, 16, TMP4);

  2190.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2191.         vis_xor(DST_2, REF_2, TMP8);

  2192. 

  2193.         vis_and(TMP8, MASK_fe, TMP8);

  2194. 

  2195.         vis_and(DST_0, REF_0, TMP10);

  2196.         vis_ld64_2(dest, stride, DST_0);

  2197.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2198. 

  2199.         vis_and(DST_2, REF_2, TMP12);

  2200.         vis_ld64_2(dest, stride_8, DST_2);

  2201. 

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

  2203.         vis_and(TMP6, MASK_7f, TMP6);

  2204. 

  2205.         vis_and(TMP8, MASK_7f, TMP8);

  2206. 

  2207.         vis_padd16(TMP10, TMP6, TMP6);

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

  2209. 

  2210.         vis_padd16(TMP12, TMP8, TMP8);

  2211.         vis_st64_2(TMP8, dest, 8);

  2212. 

  2213.         dest += stride;

  2214.         vis_faligndata(TMP0, TMP2, REF_0);

  2215. 

  2216.         vis_faligndata(TMP2, TMP4, REF_2);

  2217. 

  2218.         vis_xor(DST_0, REF_0, TMP20);

  2219. 

  2220.         vis_and(TMP20, MASK_fe, TMP20);

  2221. 

  2222.         vis_xor(DST_2, REF_2, TMP22);

  2223.         vis_mul8x16(CONST_128, TMP20, TMP20);

  2224. 

  2225.         vis_and(TMP22, MASK_fe, TMP22);

  2226. 

  2227.         vis_and(DST_0, REF_0, TMP24);

  2228.         vis_mul8x16(CONST_128, TMP22, TMP22);

  2229. 

  2230.         vis_and(DST_2, REF_2, TMP26);

  2231. 

  2232.         vis_and(TMP20, MASK_7f, TMP20);

  2233. 

  2234.         vis_and(TMP22, MASK_7f, TMP22);

  2235. 

  2236.         vis_padd16(TMP24, TMP20, TMP20);

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

  2238. 

  2239.         vis_padd16(TMP26, TMP22, TMP22);

  2240.         vis_st64_2(TMP22, dest, 8);

  2241. }

  2242. 

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

  2244.                              const ptrdiff_t line_size, int height)

  2245. {

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

  2247.         unsigned long off_plus_1 = off + 1;

  2248. 

  2249.         ref = vis_alignaddr(ref);

  2250. 

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

  2252. 

  2253.         vis_ld64_2(ref, 8,  TMP2);

  2254. 

  2255.         vis_ld64_2(ref, 16, TMP4);

  2256. 

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

  2258. 

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

  2260.         vis_faligndata(TMP0, TMP2, REF_0);

  2261. 

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

  2263.         vis_faligndata(TMP2, TMP4, REF_4);

  2264. 

  2265.         if (off != 0x7) {

  2266.                 vis_alignaddr_g0((void *)off_plus_1);

  2267.                 vis_faligndata(TMP0, TMP2, REF_2);

  2268.                 vis_faligndata(TMP2, TMP4, REF_6);

  2269.         } else {

  2270.                 vis_src1(TMP2, REF_2);

  2271.                 vis_src1(TMP4, REF_6);

  2272.         }

  2273. 

  2274.         ref += stride;

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

  2276. 

  2277.         do {    /* 34 cycles */

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

  2279.                 vis_xor(REF_0, REF_2, TMP6);

  2280. 

  2281.                 vis_ld64_2(ref, 8,  TMP2);

  2282.                 vis_xor(REF_4, REF_6, TMP8);

  2283. 

  2284.                 vis_ld64_2(ref, 16, TMP4);

  2285.                 vis_and(TMP6, MASK_fe, TMP6);

  2286.                 ref += stride;

  2287. 

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

  2289.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2290.                 vis_and(TMP8, MASK_fe, TMP8);

  2291. 

  2292.                 vis_ld64_2(ref, 8,  TMP16);

  2293.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2294.                 vis_and(REF_0, REF_2, TMP10);

  2295. 

  2296.                 vis_ld64_2(ref, 16, TMP18);

  2297.                 ref += stride;

  2298.                 vis_and(REF_4, REF_6, TMP12);

  2299. 

  2300.                 vis_alignaddr_g0((void *)off);

  2301. 

  2302.                 vis_faligndata(TMP0, TMP2, REF_0);

  2303. 

  2304.                 vis_faligndata(TMP2, TMP4, REF_4);

  2305. 

  2306.                 if (off != 0x7) {

  2307.                         vis_alignaddr_g0((void *)off_plus_1);

  2308.                         vis_faligndata(TMP0, TMP2, REF_2);

  2309.                         vis_faligndata(TMP2, TMP4, REF_6);

  2310.                 } else {

  2311.                         vis_src1(TMP2, REF_2);

  2312.                         vis_src1(TMP4, REF_6);

  2313.                 }

  2314. 

  2315.                 vis_and(TMP6, MASK_7f, TMP6);

  2316. 

  2317.                 vis_and(TMP8, MASK_7f, TMP8);

  2318. 

  2319.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2321. 

  2322.                 vis_padd16(TMP12, TMP8, TMP8);

  2323.                 vis_st64_2(TMP8, dest, 8);

  2324.                 dest += stride;

  2325. 

  2326.                 vis_xor(REF_0, REF_2, TMP6);

  2327. 

  2328.                 vis_xor(REF_4, REF_6, TMP8);

  2329. 

  2330.                 vis_and(TMP6, MASK_fe, TMP6);

  2331. 

  2332.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2333.                 vis_and(TMP8, MASK_fe, TMP8);

  2334. 

  2335.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2336.                 vis_and(REF_0, REF_2, TMP10);

  2337. 

  2338.                 vis_and(REF_4, REF_6, TMP12);

  2339. 

  2340.                 vis_alignaddr_g0((void *)off);

  2341. 

  2342.                 vis_faligndata(TMP14, TMP16, REF_0);

  2343. 

  2344.                 vis_faligndata(TMP16, TMP18, REF_4);

  2345. 

  2346.                 if (off != 0x7) {

  2347.                         vis_alignaddr_g0((void *)off_plus_1);

  2348.                         vis_faligndata(TMP14, TMP16, REF_2);

  2349.                         vis_faligndata(TMP16, TMP18, REF_6);

  2350.                 } else {

  2351.                         vis_src1(TMP16, REF_2);

  2352.                         vis_src1(TMP18, REF_6);

  2353.                 }

  2354. 

  2355.                 vis_and(TMP6, MASK_7f, TMP6);

  2356. 

  2357.                 vis_and(TMP8, MASK_7f, TMP8);

  2358. 

  2359.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2361. 

  2362.                 vis_padd16(TMP12, TMP8, TMP8);

  2363.                 vis_st64_2(TMP8, dest, 8);

  2364.                 dest += stride;

  2365.         } while (--height);

  2366. 

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

  2368.         vis_xor(REF_0, REF_2, TMP6);

  2369. 

  2370.         vis_ld64_2(ref, 8,  TMP2);

  2371.         vis_xor(REF_4, REF_6, TMP8);

  2372. 

  2373.         vis_ld64_2(ref, 16, TMP4);

  2374.         vis_and(TMP6, MASK_fe, TMP6);

  2375. 

  2376.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2377.         vis_and(TMP8, MASK_fe, TMP8);

  2378. 

  2379.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2380.         vis_and(REF_0, REF_2, TMP10);

  2381. 

  2382.         vis_and(REF_4, REF_6, TMP12);

  2383. 

  2384.         vis_alignaddr_g0((void *)off);

  2385. 

  2386.         vis_faligndata(TMP0, TMP2, REF_0);

  2387. 

  2388.         vis_faligndata(TMP2, TMP4, REF_4);

  2389. 

  2390.         if (off != 0x7) {

  2391.                 vis_alignaddr_g0((void *)off_plus_1);

  2392.                 vis_faligndata(TMP0, TMP2, REF_2);

  2393.                 vis_faligndata(TMP2, TMP4, REF_6);

  2394.         } else {

  2395.                 vis_src1(TMP2, REF_2);

  2396.                 vis_src1(TMP4, REF_6);

  2397.         }

  2398. 

  2399.         vis_and(TMP6, MASK_7f, TMP6);

  2400. 

  2401.         vis_and(TMP8, MASK_7f, TMP8);

  2402. 

  2403.         vis_padd16(TMP10, TMP6, TMP6);

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

  2405. 

  2406.         vis_padd16(TMP12, TMP8, TMP8);

  2407.         vis_st64_2(TMP8, dest, 8);

  2408.         dest += stride;

  2409. 

  2410.         vis_xor(REF_0, REF_2, TMP6);

  2411. 

  2412.         vis_xor(REF_4, REF_6, TMP8);

  2413. 

  2414.         vis_and(TMP6, MASK_fe, TMP6);

  2415. 

  2416.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2417.         vis_and(TMP8, MASK_fe, TMP8);

  2418. 

  2419.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2420.         vis_and(REF_0, REF_2, TMP10);

  2421. 

  2422.         vis_and(REF_4, REF_6, TMP12);

  2423. 

  2424.         vis_and(TMP6, MASK_7f, TMP6);

  2425. 

  2426.         vis_and(TMP8, MASK_7f, TMP8);

  2427. 

  2428.         vis_padd16(TMP10, TMP6, TMP6);

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

  2430. 

  2431.         vis_padd16(TMP12, TMP8, TMP8);

  2432.         vis_st64_2(TMP8, dest, 8);

  2433. }

  2434. 

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

  2436.                             const ptrdiff_t line_size, int height)

  2437. {

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

  2439.         unsigned long off_plus_1 = off + 1;

  2440. 

  2441.         ref = vis_alignaddr(ref);

  2442. 

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

  2444. 

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

  2446. 

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

  2448. 

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

  2450. 

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

  2452.         vis_faligndata(TMP0, TMP2, REF_0);

  2453. 

  2454.         if (off != 0x7) {

  2455.                 vis_alignaddr_g0((void *)off_plus_1);

  2456.                 vis_faligndata(TMP0, TMP2, REF_2);

  2457.         } else {

  2458.                 vis_src1(TMP2, REF_2);

  2459.         }

  2460. 

  2461.         ref += stride;

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

  2463. 

  2464.         do {    /* 20 cycles */

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

  2466.                 vis_xor(REF_0, REF_2, TMP4);

  2467. 

  2468.                 vis_ld64_2(ref, 8, TMP2);

  2469.                 vis_and(TMP4, MASK_fe, TMP4);

  2470.                 ref += stride;

  2471. 

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

  2473.                 vis_and(REF_0, REF_2, TMP6);

  2474.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2475. 

  2476.                 vis_alignaddr_g0((void *)off);

  2477. 

  2478.                 vis_ld64_2(ref, 8, TMP10);

  2479.                 ref += stride;

  2480.                 vis_faligndata(TMP0, TMP2, REF_0);

  2481. 

  2482.                 if (off != 0x7) {

  2483.                         vis_alignaddr_g0((void *)off_plus_1);

  2484.                         vis_faligndata(TMP0, TMP2, REF_2);

  2485.                 } else {

  2486.                         vis_src1(TMP2, REF_2);

  2487.                 }

  2488. 

  2489.                 vis_and(TMP4, MASK_7f, TMP4);

  2490. 

  2491.                 vis_padd16(TMP6, TMP4, DST_0);

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

  2493.                 dest += stride;

  2494. 

  2495.                 vis_xor(REF_0, REF_2, TMP12);

  2496. 

  2497.                 vis_and(TMP12, MASK_fe, TMP12);

  2498. 

  2499.                 vis_and(REF_0, REF_2, TMP14);

  2500.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2501. 

  2502.                 vis_alignaddr_g0((void *)off);

  2503.                 vis_faligndata(TMP8, TMP10, REF_0);

  2504.                 if (off != 0x7) {

  2505.                         vis_alignaddr_g0((void *)off_plus_1);

  2506.                         vis_faligndata(TMP8, TMP10, REF_2);

  2507.                 } else {

  2508.                         vis_src1(TMP10, REF_2);

  2509.                 }

  2510. 

  2511.                 vis_and(TMP12, MASK_7f, TMP12);

  2512. 

  2513.                 vis_padd16(TMP14, TMP12, DST_0);

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

  2515.                 dest += stride;

  2516.         } while (--height);

  2517. 

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

  2519.         vis_xor(REF_0, REF_2, TMP4);

  2520. 

  2521.         vis_ld64_2(ref, 8, TMP2);

  2522.         vis_and(TMP4, MASK_fe, TMP4);

  2523. 

  2524.         vis_and(REF_0, REF_2, TMP6);

  2525.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2526. 

  2527.         vis_alignaddr_g0((void *)off);

  2528. 

  2529.         vis_faligndata(TMP0, TMP2, REF_0);

  2530. 

  2531.         if (off != 0x7) {

  2532.                 vis_alignaddr_g0((void *)off_plus_1);

  2533.                 vis_faligndata(TMP0, TMP2, REF_2);

  2534.         } else {

  2535.                 vis_src1(TMP2, REF_2);

  2536.         }

  2537. 

  2538.         vis_and(TMP4, MASK_7f, TMP4);

  2539. 

  2540.         vis_padd16(TMP6, TMP4, DST_0);

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

  2542.         dest += stride;

  2543. 

  2544.         vis_xor(REF_0, REF_2, TMP12);

  2545. 

  2546.         vis_and(TMP12, MASK_fe, TMP12);

  2547. 

  2548.         vis_and(REF_0, REF_2, TMP14);

  2549.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2550. 

  2551.         vis_and(TMP12, MASK_7f, TMP12);

  2552. 

  2553.         vis_padd16(TMP14, TMP12, DST_0);

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

  2555.         dest += stride;

  2556. }

  2557. 

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

  2559.                              const ptrdiff_t line_size, int height)

  2560. {

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

  2562.         unsigned long off_plus_1 = off + 1;

  2563. 

  2564.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2565. 

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

  2567.         vis_fzero(ZERO);

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

  2569. 

  2570.         ref = vis_alignaddr(ref);

  2571.         do {    /* 26 cycles */

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

  2573. 

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

  2575. 

  2576.                 vis_alignaddr_g0((void *)off);

  2577. 

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

  2579. 

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

  2581.                 vis_faligndata(TMP0, TMP2, REF_0);

  2582. 

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

  2584.                 vis_faligndata(TMP2, TMP4, REF_4);

  2585. 

  2586.                 if (off != 0x7) {

  2587.                         vis_alignaddr_g0((void *)off_plus_1);

  2588.                         vis_faligndata(TMP0, TMP2, REF_2);

  2589.                         vis_faligndata(TMP2, TMP4, REF_6);

  2590.                 } else {

  2591.                         vis_src1(TMP2, REF_2);

  2592.                         vis_src1(TMP4, REF_6);

  2593.                 }

  2594. 

  2595.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  2596. 

  2597.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2598.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2599. 

  2600.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  2601. 

  2602.                 vis_padd16(TMP0, TMP4, TMP0);

  2603. 

  2604.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  2605.                 vis_padd16(TMP2, TMP6, TMP2);

  2606. 

  2607.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  2608. 

  2609.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  2610. 

  2611.                 vis_padd16(TMP0, TMP4, TMP0);

  2612.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2613. 

  2614.                 vis_padd16(TMP2, TMP6, TMP2);

  2615.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  2616. 

  2617.                 vis_padd16(TMP0, CONST_3, TMP8);

  2618.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  2619. 

  2620.                 vis_padd16(TMP2, CONST_3, TMP10);

  2621.                 vis_pack16(TMP8, DST_0);

  2622. 

  2623.                 vis_pack16(TMP10, DST_1);

  2624.                 vis_padd16(TMP16, TMP12, TMP0);

  2625. 

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

  2627.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  2628.                 vis_padd16(TMP18, TMP14, TMP2);

  2629. 

  2630.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  2631.                 vis_padd16(TMP0, CONST_3, TMP0);

  2632. 

  2633.                 vis_padd16(TMP2, CONST_3, TMP2);

  2634. 

  2635.                 vis_padd16(TMP0, TMP4, TMP0);

  2636. 

  2637.                 vis_padd16(TMP2, TMP6, TMP2);

  2638.                 vis_pack16(TMP0, DST_2);

  2639. 

  2640.                 vis_pack16(TMP2, DST_3);

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

  2642. 

  2643.                 ref += stride;

  2644.                 dest += stride;

  2645.         } while (--height);

  2646. }

  2647. 

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

  2649.                              const ptrdiff_t line_size, int height)

  2650. {

  2651.         ref = vis_alignaddr(ref);

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

  2653. 

  2654.         vis_ld64_2(ref, 8, TMP2);

  2655. 

  2656.         vis_ld64_2(ref, 16, TMP4);

  2657.         ref += stride;

  2658. 

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

  2660.         vis_faligndata(TMP0, TMP2, REF_0);

  2661. 

  2662.         vis_ld64_2(ref, 8, TMP8);

  2663.         vis_faligndata(TMP2, TMP4, REF_4);

  2664. 

  2665.         vis_ld64_2(ref, 16, TMP10);

  2666.         ref += stride;

  2667. 

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

  2669.         vis_faligndata(TMP6, TMP8, REF_2);

  2670. 

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

  2672.         vis_faligndata(TMP8, TMP10, REF_6);

  2673. 

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

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

  2676.         do {    /* 24 cycles */

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

  2678.                 vis_xor(REF_0, REF_2, TMP12);

  2679. 

  2680.                 vis_ld64_2(ref, 8, TMP2);

  2681.                 vis_xor(REF_4, REF_6, TMP16);

  2682. 

  2683.                 vis_ld64_2(ref, 16, TMP4);

  2684.                 ref += stride;

  2685.                 vis_and(REF_0, REF_2, TMP14);

  2686. 

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

  2688.                 vis_and(REF_4, REF_6, TMP18);

  2689. 

  2690.                 vis_ld64_2(ref, 8, TMP8);

  2691.                 vis_faligndata(TMP0, TMP2, REF_0);

  2692. 

  2693.                 vis_ld64_2(ref, 16, TMP10);

  2694.                 ref += stride;

  2695.                 vis_faligndata(TMP2, TMP4, REF_4);

  2696. 

  2697.                 vis_and(TMP12, MASK_fe, TMP12);

  2698. 

  2699.                 vis_and(TMP16, MASK_fe, TMP16);

  2700.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2701. 

  2702.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  2703.                 vis_xor(REF_0, REF_2, TMP0);

  2704. 

  2705.                 vis_xor(REF_4, REF_6, TMP2);

  2706. 

  2707.                 vis_and(REF_0, REF_2, TMP20);

  2708. 

  2709.                 vis_and(TMP12, MASK_7f, TMP12);

  2710. 

  2711.                 vis_and(TMP16, MASK_7f, TMP16);

  2712. 

  2713.                 vis_padd16(TMP14, TMP12, TMP12);

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

  2715. 

  2716.                 vis_padd16(TMP18, TMP16, TMP16);

  2717.                 vis_st64_2(TMP16, dest, 8);

  2718.                 dest += stride;

  2719. 

  2720.                 vis_and(REF_4, REF_6, TMP18);

  2721. 

  2722.                 vis_and(TMP0, MASK_fe, TMP0);

  2723. 

  2724.                 vis_and(TMP2, MASK_fe, TMP2);

  2725.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  2726. 

  2727.                 vis_faligndata(TMP6, TMP8, REF_2);

  2728.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  2729. 

  2730.                 vis_faligndata(TMP8, TMP10, REF_6);

  2731. 

  2732.                 vis_and(TMP0, MASK_7f, TMP0);

  2733. 

  2734.                 vis_and(TMP2, MASK_7f, TMP2);

  2735. 

  2736.                 vis_padd16(TMP20, TMP0, TMP0);

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

  2738. 

  2739.                 vis_padd16(TMP18, TMP2, TMP2);

  2740.                 vis_st64_2(TMP2, dest, 8);

  2741.                 dest += stride;

  2742.         } while (--height);

  2743. 

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

  2745.         vis_xor(REF_0, REF_2, TMP12);

  2746. 

  2747.         vis_ld64_2(ref, 8, TMP2);

  2748.         vis_xor(REF_4, REF_6, TMP16);

  2749. 

  2750.         vis_ld64_2(ref, 16, TMP4);

  2751.         vis_and(REF_0, REF_2, TMP14);

  2752. 

  2753.         vis_and(REF_4, REF_6, TMP18);

  2754. 

  2755.         vis_faligndata(TMP0, TMP2, REF_0);

  2756. 

  2757.         vis_faligndata(TMP2, TMP4, REF_4);

  2758. 

  2759.         vis_and(TMP12, MASK_fe, TMP12);

  2760. 

  2761.         vis_and(TMP16, MASK_fe, TMP16);

  2762.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2763. 

  2764.         vis_mul8x16(CONST_128, TMP16, TMP16);

  2765.         vis_xor(REF_0, REF_2, TMP0);

  2766. 

  2767.         vis_xor(REF_4, REF_6, TMP2);

  2768. 

  2769.         vis_and(REF_0, REF_2, TMP20);

  2770. 

  2771.         vis_and(TMP12, MASK_7f, TMP12);

  2772. 

  2773.         vis_and(TMP16, MASK_7f, TMP16);

  2774. 

  2775.         vis_padd16(TMP14, TMP12, TMP12);

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

  2777. 

  2778.         vis_padd16(TMP18, TMP16, TMP16);

  2779.         vis_st64_2(TMP16, dest, 8);

  2780.         dest += stride;

  2781. 

  2782.         vis_and(REF_4, REF_6, TMP18);

  2783. 

  2784.         vis_and(TMP0, MASK_fe, TMP0);

  2785. 

  2786.         vis_and(TMP2, MASK_fe, TMP2);

  2787.         vis_mul8x16(CONST_128, TMP0, TMP0);

  2788. 

  2789.         vis_mul8x16(CONST_128, TMP2, TMP2);

  2790. 

  2791.         vis_and(TMP0, MASK_7f, TMP0);

  2792. 

  2793.         vis_and(TMP2, MASK_7f, TMP2);

  2794. 

  2795.         vis_padd16(TMP20, TMP0, TMP0);

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

  2797. 

  2798.         vis_padd16(TMP18, TMP2, TMP2);

  2799.         vis_st64_2(TMP2, dest, 8);

  2800. }

  2801. 

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

  2803.                             const ptrdiff_t line_size, int height)

  2804. {

  2805.         ref = vis_alignaddr(ref);

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

  2807. 

  2808.         vis_ld64_2(ref, 8, TMP2);

  2809.         ref += stride;

  2810. 

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

  2812. 

  2813.         vis_ld64_2(ref, 8, TMP6);

  2814.         ref += stride;

  2815. 

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

  2817.         vis_faligndata(TMP0, TMP2, REF_0);

  2818. 

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

  2820.         vis_faligndata(TMP4, TMP6, REF_2);

  2821. 

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

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

  2824.         do {    /* 12 cycles */

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

  2826.                 vis_xor(REF_0, REF_2, TMP4);

  2827. 

  2828.                 vis_ld64_2(ref, 8, TMP2);

  2829.                 ref += stride;

  2830.                 vis_and(TMP4, MASK_fe, TMP4);

  2831. 

  2832.                 vis_and(REF_0, REF_2, TMP6);

  2833.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2834. 

  2835.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2837. 

  2838.                 vis_ld64_2(ref, 8, TMP2);

  2839.                 ref += stride;

  2840.                 vis_xor(REF_0, REF_2, TMP12);

  2841. 

  2842.                 vis_and(TMP4, MASK_7f, TMP4);

  2843. 

  2844.                 vis_and(TMP12, MASK_fe, TMP12);

  2845. 

  2846.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2847.                 vis_and(REF_0, REF_2, TMP14);

  2848. 

  2849.                 vis_padd16(TMP6, TMP4, DST_0);

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

  2851.                 dest += stride;

  2852. 

  2853.                 vis_faligndata(TMP0, TMP2, REF_2);

  2854. 

  2855.                 vis_and(TMP12, MASK_7f, TMP12);

  2856. 

  2857.                 vis_padd16(TMP14, TMP12, DST_0);

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

  2859.                 dest += stride;

  2860.         } while (--height);

  2861. 

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

  2863.         vis_xor(REF_0, REF_2, TMP4);

  2864. 

  2865.         vis_ld64_2(ref, 8, TMP2);

  2866.         vis_and(TMP4, MASK_fe, TMP4);

  2867. 

  2868.         vis_and(REF_0, REF_2, TMP6);

  2869.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2870. 

  2871.         vis_faligndata(TMP0, TMP2, REF_0);

  2872. 

  2873.         vis_xor(REF_0, REF_2, TMP12);

  2874. 

  2875.         vis_and(TMP4, MASK_7f, TMP4);

  2876. 

  2877.         vis_and(TMP12, MASK_fe, TMP12);

  2878. 

  2879.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2880.         vis_and(REF_0, REF_2, TMP14);

  2881. 

  2882.         vis_padd16(TMP6, TMP4, DST_0);

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

  2884.         dest += stride;

  2885. 

  2886.         vis_and(TMP12, MASK_7f, TMP12);

  2887. 

  2888.         vis_padd16(TMP14, TMP12, DST_0);

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

  2890. }

  2891. 

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

  2893.                              const ptrdiff_t line_size, int height)

  2894. {

  2895.         int stride_8 = stride + 8;

  2896.         int stride_16 = stride + 16;

  2897. 

  2898.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2899. 

  2900.         ref = vis_alignaddr(ref);

  2901. 

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

  2903.         vis_fzero(ZERO);

  2904. 

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

  2906. 

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

  2908. 

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

  2910.         vis_faligndata(TMP0, TMP2, REF_2);

  2911. 

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

  2913.         vis_faligndata(TMP2, TMP4, REF_6);

  2914.         height >>= 1;

  2915. 

  2916.         do {    /* 31 cycles */

  2917.                 vis_ld64_2(ref, stride, TMP0);

  2918.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  2919.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  2920. 

  2921.                 vis_ld64_2(ref, stride_8, TMP2);

  2922.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  2923.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  2924. 

  2925.                 vis_ld64_2(ref, stride_16, TMP4);

  2926.                 ref += stride;

  2927. 

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

  2929.                 vis_faligndata(TMP0, TMP2, REF_0);

  2930. 

  2931.                 vis_ld64_2(dest, 8, DST_2);

  2932.                 vis_faligndata(TMP2, TMP4, REF_4);

  2933. 

  2934.                 vis_ld64_2(ref, stride, TMP6);

  2935.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  2936.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2937. 

  2938.                 vis_ld64_2(ref, stride_8, TMP8);

  2939.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  2940. 

  2941.                 vis_ld64_2(ref, stride_16, TMP10);

  2942.                 ref += stride;

  2943. 

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

  2945.                 vis_faligndata(TMP6, TMP8, REF_2);

  2946.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  2947. 

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

  2949.                 vis_faligndata(TMP8, TMP10, REF_6);

  2950.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  2951. 

  2952.                 vis_padd16(TMP0, CONST_3, TMP0);

  2953.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  2954. 

  2955.                 vis_padd16(TMP2, CONST_3, TMP2);

  2956.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  2957. 

  2958.                 vis_padd16(TMP4, CONST_3, TMP4);

  2959.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  2960. 

  2961.                 vis_padd16(TMP6, CONST_3, TMP6);

  2962. 

  2963.                 vis_padd16(TMP12, TMP20, TMP12);

  2964.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  2965. 

  2966.                 vis_padd16(TMP14, TMP22, TMP14);

  2967.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  2968. 

  2969.                 vis_padd16(TMP16, TMP24, TMP16);

  2970.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  2971. 

  2972.                 vis_padd16(TMP18, TMP26, TMP18);

  2973.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  2974. 

  2975.                 vis_padd16(TMP12, TMP0, TMP12);

  2976.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  2977. 

  2978.                 vis_padd16(TMP14, TMP2, TMP14);

  2979.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  2980. 

  2981.                 vis_padd16(TMP16, TMP4, TMP16);

  2982.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  2983. 

  2984.                 vis_padd16(TMP18, TMP6, TMP18);

  2985.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  2986. 

  2987.                 vis_pack16(TMP12, DST_0);

  2988.                 vis_padd16(TMP28, TMP0, TMP12);

  2989. 

  2990.                 vis_pack16(TMP14, DST_1);

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

  2992.                 vis_padd16(TMP30, TMP2, TMP14);

  2993. 

  2994.                 vis_pack16(TMP16, DST_2);

  2995.                 vis_padd16(REF_S4, TMP4, TMP16);

  2996. 

  2997.                 vis_pack16(TMP18, DST_3);

  2998.                 vis_st64_2(DST_2, dest, 8);

  2999.                 dest += stride;

  3000.                 vis_padd16(REF_S6, TMP6, TMP18);

  3001. 

  3002.                 vis_padd16(TMP12, TMP20, TMP12);

  3003. 

  3004.                 vis_padd16(TMP14, TMP22, TMP14);

  3005.                 vis_pack16(TMP12, DST_0);

  3006. 

  3007.                 vis_padd16(TMP16, TMP24, TMP16);

  3008.                 vis_pack16(TMP14, DST_1);

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

  3010. 

  3011.                 vis_padd16(TMP18, TMP26, TMP18);

  3012.                 vis_pack16(TMP16, DST_2);

  3013. 

  3014.                 vis_pack16(TMP18, DST_3);

  3015.                 vis_st64_2(DST_2, dest, 8);

  3016.                 dest += stride;

  3017.         } while (--height);

  3018. }

  3019. 

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

  3021.                                        const ptrdiff_t line_size, int height)

  3022. {

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

  3024.         unsigned long off_plus_1 = off + 1;

  3025.         int stride_8 = stride + 8;

  3026.         int stride_16 = stride + 16;

  3027. 

  3028.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3029. 

  3030.         ref = vis_alignaddr(ref);

  3031. 

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

  3033.         vis_fzero(ZERO);

  3034. 

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

  3036. 

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

  3038. 

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

  3040.         vis_faligndata(TMP0, TMP2, REF_S0);

  3041. 

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

  3043.         vis_faligndata(TMP2, TMP4, REF_S4);

  3044. 

  3045.         if (off != 0x7) {

  3046.                 vis_alignaddr_g0((void *)off_plus_1);

  3047.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3048.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3049.         } else {

  3050.                 vis_src1(TMP2, REF_S2);

  3051.                 vis_src1(TMP4, REF_S6);

  3052.         }

  3053. 

  3054.         height >>= 1;

  3055.         do {

  3056.                 vis_ld64_2(ref, stride, TMP0);

  3057.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3058.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3059. 

  3060.                 vis_alignaddr_g0((void *)off);

  3061. 

  3062.                 vis_ld64_2(ref, stride_8, TMP2);

  3063.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3064.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3065. 

  3066.                 vis_ld64_2(ref, stride_16, TMP4);

  3067.                 ref += stride;

  3068.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3069.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3070. 

  3071.                 vis_ld64_2(ref, stride, TMP6);

  3072.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3073.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3074. 

  3075.                 vis_ld64_2(ref, stride_8, TMP8);

  3076.                 vis_faligndata(TMP0, TMP2, REF_0);

  3077. 

  3078.                 vis_ld64_2(ref, stride_16, TMP10);

  3079.                 ref += stride;

  3080.                 vis_faligndata(TMP2, TMP4, REF_4);

  3081. 

  3082.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3083. 

  3084.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3085. 

  3086.                 if (off != 0x7) {

  3087.                         vis_alignaddr_g0((void *)off_plus_1);

  3088.                         vis_faligndata(TMP0, TMP2, REF_2);

  3089.                         vis_faligndata(TMP2, TMP4, REF_6);

  3090.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3091.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3092.                 } else {

  3093.                         vis_src1(TMP2, REF_2);

  3094.                         vis_src1(TMP4, REF_6);

  3095.                         vis_src1(TMP8, REF_S2);

  3096.                         vis_src1(TMP10, REF_S6);

  3097.                 }

  3098. 

  3099.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  3100.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3101. 

  3102.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3103.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3104. 

  3105.                 vis_padd16(TMP0, CONST_2, TMP8);

  3106.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  3107. 

  3108.                 vis_padd16(TMP2, CONST_1, TMP10);

  3109.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  3110. 

  3111.                 vis_padd16(TMP8, TMP4, TMP8);

  3112.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  3113. 

  3114.                 vis_padd16(TMP10, TMP6, TMP10);

  3115.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  3116. 

  3117.                 vis_padd16(TMP12, TMP8, TMP12);

  3118. 

  3119.                 vis_padd16(TMP14, TMP10, TMP14);

  3120. 

  3121.                 vis_padd16(TMP12, TMP16, TMP12);

  3122. 

  3123.                 vis_padd16(TMP14, TMP18, TMP14);

  3124.                 vis_pack16(TMP12, DST_0);

  3125. 

  3126.                 vis_pack16(TMP14, DST_1);

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

  3128.                 vis_padd16(TMP0, CONST_1, TMP12);

  3129. 

  3130.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  3131.                 vis_padd16(TMP2, CONST_1, TMP14);

  3132. 

  3133.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  3134.                 vis_padd16(TMP12, TMP4, TMP12);

  3135. 

  3136.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  3137.                 vis_padd16(TMP14, TMP6, TMP14);

  3138. 

  3139.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  3140.                 vis_padd16(TMP20, TMP12, TMP20);

  3141. 

  3142.                 vis_padd16(TMP22, TMP14, TMP22);

  3143. 

  3144.                 vis_padd16(TMP20, TMP24, TMP20);

  3145. 

  3146.                 vis_padd16(TMP22, TMP26, TMP22);

  3147.                 vis_pack16(TMP20, DST_2);

  3148. 

  3149.                 vis_pack16(TMP22, DST_3);

  3150.                 vis_st64_2(DST_2, dest, 8);

  3151.                 dest += stride;

  3152.                 vis_padd16(TMP0, TMP4, TMP24);

  3153. 

  3154.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  3155.                 vis_padd16(TMP2, TMP6, TMP26);

  3156. 

  3157.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  3158.                 vis_padd16(TMP24, TMP8, TMP24);

  3159. 

  3160.                 vis_padd16(TMP26, TMP10, TMP26);

  3161.                 vis_pack16(TMP24, DST_0);

  3162. 

  3163.                 vis_pack16(TMP26, DST_1);

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

  3165.                 vis_pmerge(ZERO, REF_S6, TMP4);

  3166. 

  3167.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  3168. 

  3169.                 vis_padd16(TMP0, TMP4, TMP0);

  3170. 

  3171.                 vis_padd16(TMP2, TMP6, TMP2);

  3172. 

  3173.                 vis_padd16(TMP0, TMP12, TMP0);

  3174. 

  3175.                 vis_padd16(TMP2, TMP14, TMP2);

  3176.                 vis_pack16(TMP0, DST_2);

  3177. 

  3178.                 vis_pack16(TMP2, DST_3);

  3179.                 vis_st64_2(DST_2, dest, 8);

  3180.                 dest += stride;

  3181.         } while (--height);

  3182. }

  3183. 

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

  3185.                                       const ptrdiff_t line_size, int height)

  3186. {

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

  3188.         unsigned long off_plus_1 = off + 1;

  3189.         int stride_8 = stride + 8;

  3190. 

  3191.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3192. 

  3193.         ref = vis_alignaddr(ref);

  3194. 

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

  3196.         vis_fzero(ZERO);

  3197. 

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

  3199. 

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

  3201. 

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

  3203.         vis_faligndata(TMP0, TMP2, REF_S0);

  3204. 

  3205.         if (off != 0x7) {

  3206.                 vis_alignaddr_g0((void *)off_plus_1);

  3207.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3208.         } else {

  3209.                 vis_src1(TMP2, REF_S2);

  3210.         }

  3211. 

  3212.         height >>= 1;

  3213.         do {    /* 26 cycles */

  3214.                 vis_ld64_2(ref, stride, TMP0);

  3215.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  3216.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  3217. 

  3218.                 vis_alignaddr_g0((void *)off);

  3219. 

  3220.                 vis_ld64_2(ref, stride_8, TMP2);

  3221.                 ref += stride;

  3222.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  3223.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  3224. 

  3225.                 vis_ld64_2(ref, stride, TMP4);

  3226. 

  3227.                 vis_ld64_2(ref, stride_8, TMP6);

  3228.                 ref += stride;

  3229.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3230. 

  3231.                 vis_pmerge(ZERO, REF_S4, TMP18);

  3232. 

  3233.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  3234. 

  3235.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3236. 

  3237.                 if (off != 0x7) {

  3238.                         vis_alignaddr_g0((void *)off_plus_1);

  3239.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3240.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3241.                 } else {

  3242.                         vis_src1(TMP2, REF_S6);

  3243.                         vis_src1(TMP6, REF_S2);

  3244.                 }

  3245. 

  3246.                 vis_padd16(TMP18, CONST_1, TMP18);

  3247.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  3248. 

  3249.                 vis_padd16(TMP20, CONST_1, TMP20);

  3250.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  3251. 

  3252.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  3253.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  3254. 

  3255.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  3256.                 vis_padd16(TMP18, TMP22, TMP18);

  3257. 

  3258.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  3259.                 vis_padd16(TMP20, TMP24, TMP20);

  3260. 

  3261.                 vis_padd16(TMP8,  TMP18, TMP8);

  3262. 

  3263.                 vis_padd16(TMP10, TMP20, TMP10);

  3264. 

  3265.                 vis_padd16(TMP8,  TMP12, TMP8);

  3266. 

  3267.                 vis_padd16(TMP10, TMP14, TMP10);

  3268.                 vis_pack16(TMP8,  DST_0);

  3269. 

  3270.                 vis_pack16(TMP10, DST_1);

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

  3272.                 dest += stride;

  3273.                 vis_padd16(TMP18, TMP26, TMP18);

  3274. 

  3275.                 vis_padd16(TMP20, TMP28, TMP20);

  3276. 

  3277.                 vis_padd16(TMP18, TMP30, TMP18);

  3278. 

  3279.                 vis_padd16(TMP20, TMP32, TMP20);

  3280.                 vis_pack16(TMP18, DST_2);

  3281. 

  3282.                 vis_pack16(TMP20, DST_3);

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

  3284.                 dest += stride;

  3285.         } while (--height);

  3286. }

  3287. 

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

  3289.                                        const ptrdiff_t line_size, int height)

  3290. {

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

  3292.         unsigned long off_plus_1 = off + 1;

  3293.         int stride_8 = stride + 8;

  3294.         int stride_16 = stride + 16;

  3295. 

  3296.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3297. 

  3298.         ref = vis_alignaddr(ref);

  3299. 

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

  3301.         vis_fzero(ZERO);

  3302. 

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

  3304. 

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

  3306. 

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

  3308.         vis_faligndata(TMP0, TMP2, REF_S0);

  3309. 

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

  3311.         vis_faligndata(TMP2, TMP4, REF_S4);

  3312. 

  3313.         if (off != 0x7) {

  3314.                 vis_alignaddr_g0((void *)off_plus_1);

  3315.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3316.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3317.         } else {

  3318.                 vis_src1(TMP2, REF_S2);

  3319.                 vis_src1(TMP4, REF_S6);

  3320.         }

  3321. 

  3322.         height >>= 1;

  3323.         do {    /* 55 cycles */

  3324.                 vis_ld64_2(ref, stride, TMP0);

  3325.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3326.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3327. 

  3328.                 vis_alignaddr_g0((void *)off);

  3329. 

  3330.                 vis_ld64_2(ref, stride_8, TMP2);

  3331.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3332.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3333. 

  3334.                 vis_ld64_2(ref, stride_16, TMP4);

  3335.                 ref += stride;

  3336.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3337.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3338. 

  3339.                 vis_ld64_2(ref, stride, TMP6);

  3340.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3341.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3342. 

  3343.                 vis_ld64_2(ref, stride_8, TMP8);

  3344.                 vis_faligndata(TMP0, TMP2, REF_0);

  3345. 

  3346.                 vis_ld64_2(ref, stride_16, TMP10);

  3347.                 ref += stride;

  3348.                 vis_faligndata(TMP2, TMP4, REF_4);

  3349. 

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

  3351.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3352. 

  3353.                 vis_ld64_2(dest, 8, DST_2);

  3354.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3355. 

  3356.                 if (off != 0x7) {

  3357.                         vis_alignaddr_g0((void *)off_plus_1);

  3358.                         vis_faligndata(TMP0, TMP2, REF_2);

  3359.                         vis_faligndata(TMP2, TMP4, REF_6);

  3360.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3361.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3362.                 } else {

  3363.                         vis_src1(TMP2, REF_2);

  3364.                         vis_src1(TMP4, REF_6);

  3365.                         vis_src1(TMP8, REF_S2);

  3366.                         vis_src1(TMP10, REF_S6);

  3367.                 }

  3368. 

  3369.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3370.                 vis_pmerge(ZERO, REF_0, TMP0);

  3371. 

  3372.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3373.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3374. 

  3375.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3376.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3377. 

  3378.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3379.                 vis_padd16(TMP0, CONST_6, TMP0);

  3380. 

  3381.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3382.                 vis_padd16(TMP2, CONST_6, TMP2);

  3383. 

  3384.                 vis_padd16(TMP0, TMP4, TMP0);

  3385.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  3386. 

  3387.                 vis_padd16(TMP2, TMP6, TMP2);

  3388.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3389. 

  3390.                 vis_padd16(TMP12, TMP0, TMP12);

  3391.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  3392. 

  3393.                 vis_padd16(TMP14, TMP2, TMP14);

  3394.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  3395. 

  3396.                 vis_padd16(TMP12, TMP16, TMP12);

  3397.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  3398. 

  3399.                 vis_padd16(TMP14, TMP18, TMP14);

  3400.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  3401. 

  3402.                 vis_padd16(TMP12, TMP30, TMP12);

  3403. 

  3404.                 vis_padd16(TMP14, TMP32, TMP14);

  3405.                 vis_pack16(TMP12, DST_0);

  3406. 

  3407.                 vis_pack16(TMP14, DST_1);

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

  3409.                 vis_padd16(TMP4, CONST_6, TMP4);

  3410. 

  3411.                 vis_ld64_2(dest, stride, DST_0);

  3412.                 vis_padd16(TMP6, CONST_6, TMP6);

  3413.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3414. 

  3415.                 vis_padd16(TMP4, TMP8, TMP4);

  3416.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  3417. 

  3418.                 vis_padd16(TMP6, TMP10, TMP6);

  3419. 

  3420.                 vis_padd16(TMP20, TMP4, TMP20);

  3421. 

  3422.                 vis_padd16(TMP22, TMP6, TMP22);

  3423. 

  3424.                 vis_padd16(TMP20, TMP24, TMP20);

  3425. 

  3426.                 vis_padd16(TMP22, TMP26, TMP22);

  3427. 

  3428.                 vis_padd16(TMP20, REF_0, TMP20);

  3429.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  3430. 

  3431.                 vis_padd16(TMP22, REF_2, TMP22);

  3432.                 vis_pack16(TMP20, DST_2);

  3433. 

  3434.                 vis_pack16(TMP22, DST_3);

  3435.                 vis_st64_2(DST_2, dest, 8);

  3436.                 dest += stride;

  3437. 

  3438.                 vis_ld64_2(dest, 8, DST_2);

  3439.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3440.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  3441. 

  3442.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3443.                 vis_padd16(REF_4, TMP0, TMP8);

  3444. 

  3445.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  3446.                 vis_padd16(REF_6, TMP2, TMP10);

  3447. 

  3448.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  3449.                 vis_padd16(TMP8, TMP12, TMP8);

  3450. 

  3451.                 vis_padd16(TMP10, TMP14, TMP10);

  3452. 

  3453.                 vis_padd16(TMP8, TMP30, TMP8);

  3454. 

  3455.                 vis_padd16(TMP10, TMP32, TMP10);

  3456.                 vis_pack16(TMP8, DST_0);

  3457. 

  3458.                 vis_pack16(TMP10, DST_1);

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

  3460. 

  3461.                 vis_padd16(REF_0, TMP4, REF_0);

  3462. 

  3463.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  3464.                 vis_padd16(REF_2, TMP6, REF_2);

  3465. 

  3466.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  3467.                 vis_padd16(REF_0, REF_4, REF_0);

  3468. 

  3469.                 vis_padd16(REF_2, REF_6, REF_2);

  3470. 

  3471.                 vis_padd16(REF_0, TMP30, REF_0);

  3472. 

  3473.                 /* stall */

  3474. 

  3475.                 vis_padd16(REF_2, TMP32, REF_2);

  3476.                 vis_pack16(REF_0, DST_2);

  3477. 

  3478.                 vis_pack16(REF_2, DST_3);

  3479.                 vis_st64_2(DST_2, dest, 8);

  3480.                 dest += stride;

  3481.         } while (--height);

  3482. }

  3483. 

  3484. /* End of no rounding code */

  3485. 

  3486. #define ACCEL_SPARC_VIS 1

  3487. #define ACCEL_SPARC_VIS2 2

  3488. 

  3489. static int vis_level(void)

  3490. {

  3491.     int accel = 0;

  3492.     accel |= ACCEL_SPARC_VIS;

  3493.     accel |= ACCEL_SPARC_VIS2;

  3494.     return accel;

  3495. }

  3496. 

  3497. /* libavcodec initialization code */

  3498. av_cold void ff_dsputil_init_vis(DSPContext *c, AVCodecContext *avctx)

  3499. {

  3500.   /* VIS-specific optimizations */

  3501.   int accel = vis_level ();

  3502.   const int high_bit_depth = avctx->bits_per_raw_sample > 8;

  3503. 

  3504.   if (accel & ACCEL_SPARC_VIS) {

  3505.       if (avctx->bits_per_raw_sample <= 8 &&

  3506.           avctx->idct_algo == FF_IDCT_SIMPLEVIS) {

  3507.           c->idct_put = ff_simple_idct_put_vis;

  3508.           c->idct_add = ff_simple_idct_add_vis;

  3509.           c->idct     = ff_simple_idct_vis;

  3510.           c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;

  3511.       }

  3512. 

  3513.       if (!high_bit_depth) {

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

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

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

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

  3518. 

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

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

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

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

  3523. 

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

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

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

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

  3528. 

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

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

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

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

  3533. 

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

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

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

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

  3538. 

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

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

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

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

  3543. 

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

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

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

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

  3548.       }

  3549.   }

  3550. }