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

4011 lines
118KB
Raw Blame History 

  1. /*

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

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

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

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

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

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

  10.  *

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

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

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

  14.  * Lesser General Public License for more details.

  15.  *

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

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

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

  19.  */

  20. 

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

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

  23.  */

  24. 

  25. #include "config.h"

  26. 

  27. #include <inttypes.h>

  28. 

  29. #include "libavcodec/dsputil.h"

  30. #include "libavutil/mem.h"

  31. #include "dsputil_vis.h"

  32. 

  33. #include "vis.h"

  34. 

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

  36.  * motion comp code, which is:

  37.  *

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

  39.  *

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

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

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

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

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

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

  46.  *

  47.  *      fxor            f0,   f2, f10

  48.  *      fand            f10,  f4, f10

  49.  *      fmul8x16        f8,  f10, f10

  50.  *      fand            f10,  f6, f10

  51.  *      for             f0,   f2, f12

  52.  *      fpsub16         f12, f10, f10

  53.  */

  54. 

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

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

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

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

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

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

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

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

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

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

  65.         {256, 512, 256, 512};

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

  67.         {256, 1024, 256, 1024};

  68. 

  69. #define REF_0           0

  70. #define REF_0_1         1

  71. #define REF_2           2

  72. #define REF_2_1         3

  73. #define REF_4           4

  74. #define REF_4_1         5

  75. #define REF_6           6

  76. #define REF_6_1         7

  77. #define REF_S0          8

  78. #define REF_S0_1        9

  79. #define REF_S2          10

  80. #define REF_S2_1        11

  81. #define REF_S4          12

  82. #define REF_S4_1        13

  83. #define REF_S6          14

  84. #define REF_S6_1        15

  85. #define DST_0           16

  86. #define DST_1           17

  87. #define DST_2           18

  88. #define DST_3           19

  89. #define CONST_1         20

  90. #define CONST_2         20

  91. #define CONST_3         20

  92. #define CONST_6         20

  93. #define MASK_fe         20

  94. #define CONST_128       22

  95. #define CONST_256       22

  96. #define CONST_512       22

  97. #define CONST_1024      22

  98. #define TMP0            24

  99. #define TMP1            25

  100. #define TMP2            26

  101. #define TMP3            27

  102. #define TMP4            28

  103. #define TMP5            29

  104. #define ZERO            30

  105. #define MASK_7f         30

  106. 

  107. #define TMP6            32

  108. #define TMP8            34

  109. #define TMP10           36

  110. #define TMP12           38

  111. #define TMP14           40

  112. #define TMP16           42

  113. #define TMP18           44

  114. #define TMP20           46

  115. #define TMP22           48

  116. #define TMP24           50

  117. #define TMP26           52

  118. #define TMP28           54

  119. #define TMP30           56

  120. #define TMP32           58

  121. 

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

  123.                              const int stride, int height)

  124. {

  125.         ref = vis_alignaddr(ref);

  126.         do {    /* 5 cycles */

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

  128. 

  129.                 vis_ld64_2(ref, 8, TMP2);

  130. 

  131.                 vis_ld64_2(ref, 16, TMP4);

  132.                 ref += stride;

  133. 

  134.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  136. 

  137.                 vis_faligndata(TMP2, TMP4, REF_2);

  138.                 vis_st64_2(REF_2, dest, 8);

  139.                 dest += stride;

  140.         } while (--height);

  141. }

  142. 

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

  144.                             const int stride, int height)

  145. {

  146.         ref = vis_alignaddr(ref);

  147.         do {    /* 4 cycles */

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

  149. 

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

  151.                 ref += stride;

  152. 

  153.                 /* stall */

  154. 

  155.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  157.                 dest += stride;

  158.         } while (--height);

  159. }

  160. 

  161. 

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

  163.                              const int stride, int height)

  164. {

  165.         int stride_8 = stride + 8;

  166. 

  167.         ref = vis_alignaddr(ref);

  168. 

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

  170. 

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

  172. 

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

  174. 

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

  176. 

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

  178. 

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

  180.         vis_faligndata(TMP0, TMP2, REF_0);

  181. 

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

  183.         vis_faligndata(TMP2, TMP4, REF_2);

  184. 

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

  186. 

  187.         ref += stride;

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

  189. 

  190.         do {    /* 24 cycles */

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

  192.                 vis_xor(DST_0, REF_0, TMP6);

  193. 

  194.                 vis_ld64_2(ref, 8, TMP2);

  195.                 vis_and(TMP6, MASK_fe, TMP6);

  196. 

  197.                 vis_ld64_2(ref, 16, TMP4);

  198.                 ref += stride;

  199.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  200.                 vis_xor(DST_2, REF_2, TMP8);

  201. 

  202.                 vis_and(TMP8, MASK_fe, TMP8);

  203. 

  204.                 vis_or(DST_0, REF_0, TMP10);

  205.                 vis_ld64_2(dest, stride, DST_0);

  206.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  207. 

  208.                 vis_or(DST_2, REF_2, TMP12);

  209.                 vis_ld64_2(dest, stride_8, DST_2);

  210. 

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

  212.                 vis_and(TMP6, MASK_7f, TMP6);

  213. 

  214.                 vis_and(TMP8, MASK_7f, TMP8);

  215. 

  216.                 vis_psub16(TMP10, TMP6, TMP6);

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

  218. 

  219.                 vis_psub16(TMP12, TMP8, TMP8);

  220.                 vis_st64_2(TMP8, dest, 8);

  221. 

  222.                 dest += stride;

  223.                 vis_ld64_2(ref, 8, TMP16);

  224.                 vis_faligndata(TMP0, TMP2, REF_0);

  225. 

  226.                 vis_ld64_2(ref, 16, TMP18);

  227.                 vis_faligndata(TMP2, TMP4, REF_2);

  228.                 ref += stride;

  229. 

  230.                 vis_xor(DST_0, REF_0, TMP20);

  231. 

  232.                 vis_and(TMP20, MASK_fe, TMP20);

  233. 

  234.                 vis_xor(DST_2, REF_2, TMP22);

  235.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  236. 

  237.                 vis_and(TMP22, MASK_fe, TMP22);

  238. 

  239.                 vis_or(DST_0, REF_0, TMP24);

  240.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  241. 

  242.                 vis_or(DST_2, REF_2, TMP26);

  243. 

  244.                 vis_ld64_2(dest, stride, DST_0);

  245.                 vis_faligndata(TMP14, TMP16, REF_0);

  246. 

  247.                 vis_ld64_2(dest, stride_8, DST_2);

  248.                 vis_faligndata(TMP16, TMP18, REF_2);

  249. 

  250.                 vis_and(TMP20, MASK_7f, TMP20);

  251. 

  252.                 vis_and(TMP22, MASK_7f, TMP22);

  253. 

  254.                 vis_psub16(TMP24, TMP20, TMP20);

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

  256. 

  257.                 vis_psub16(TMP26, TMP22, TMP22);

  258.                 vis_st64_2(TMP22, dest, 8);

  259.                 dest += stride;

  260.         } while (--height);

  261. 

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

  263.         vis_xor(DST_0, REF_0, TMP6);

  264. 

  265.         vis_ld64_2(ref, 8, TMP2);

  266.         vis_and(TMP6, MASK_fe, TMP6);

  267. 

  268.         vis_ld64_2(ref, 16, TMP4);

  269.         vis_mul8x16(CONST_128, TMP6, TMP6);

  270.         vis_xor(DST_2, REF_2, TMP8);

  271. 

  272.         vis_and(TMP8, MASK_fe, TMP8);

  273. 

  274.         vis_or(DST_0, REF_0, TMP10);

  275.         vis_ld64_2(dest, stride, DST_0);

  276.         vis_mul8x16(CONST_128, TMP8, TMP8);

  277. 

  278.         vis_or(DST_2, REF_2, TMP12);

  279.         vis_ld64_2(dest, stride_8, DST_2);

  280. 

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

  282.         vis_and(TMP6, MASK_7f, TMP6);

  283. 

  284.         vis_and(TMP8, MASK_7f, TMP8);

  285. 

  286.         vis_psub16(TMP10, TMP6, TMP6);

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

  288. 

  289.         vis_psub16(TMP12, TMP8, TMP8);

  290.         vis_st64_2(TMP8, dest, 8);

  291. 

  292.         dest += stride;

  293.         vis_faligndata(TMP0, TMP2, REF_0);

  294. 

  295.         vis_faligndata(TMP2, TMP4, REF_2);

  296. 

  297.         vis_xor(DST_0, REF_0, TMP20);

  298. 

  299.         vis_and(TMP20, MASK_fe, TMP20);

  300. 

  301.         vis_xor(DST_2, REF_2, TMP22);

  302.         vis_mul8x16(CONST_128, TMP20, TMP20);

  303. 

  304.         vis_and(TMP22, MASK_fe, TMP22);

  305. 

  306.         vis_or(DST_0, REF_0, TMP24);

  307.         vis_mul8x16(CONST_128, TMP22, TMP22);

  308. 

  309.         vis_or(DST_2, REF_2, TMP26);

  310. 

  311.         vis_and(TMP20, MASK_7f, TMP20);

  312. 

  313.         vis_and(TMP22, MASK_7f, TMP22);

  314. 

  315.         vis_psub16(TMP24, TMP20, TMP20);

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

  317. 

  318.         vis_psub16(TMP26, TMP22, TMP22);

  319.         vis_st64_2(TMP22, dest, 8);

  320. }

  321. 

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

  323.                             const int stride, int height)

  324. {

  325.         ref = vis_alignaddr(ref);

  326. 

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

  328. 

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

  330. 

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

  332. 

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

  334. 

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

  336.         vis_faligndata(TMP0, TMP2, REF_0);

  337. 

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

  339. 

  340.         ref += stride;

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

  342. 

  343.         do {    /* 12 cycles */

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

  345.                 vis_xor(DST_0, REF_0, TMP4);

  346. 

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

  348.                 vis_and(TMP4, MASK_fe, TMP4);

  349. 

  350.                 vis_or(DST_0, REF_0, TMP6);

  351.                 vis_ld64_2(dest, stride, DST_0);

  352.                 ref += stride;

  353.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  354. 

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

  356.                 vis_faligndata(TMP0, TMP2, REF_0);

  357. 

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

  359.                 vis_xor(DST_0, REF_0, TMP0);

  360.                 ref += stride;

  361. 

  362.                 vis_and(TMP0, MASK_fe, TMP0);

  363. 

  364.                 vis_and(TMP4, MASK_7f, TMP4);

  365. 

  366.                 vis_psub16(TMP6, TMP4, TMP4);

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

  368.                 dest += stride;

  369.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  370. 

  371.                 vis_or(DST_0, REF_0, TMP6);

  372.                 vis_ld64_2(dest, stride, DST_0);

  373. 

  374.                 vis_faligndata(TMP12, TMP2, REF_0);

  375. 

  376.                 vis_and(TMP0, MASK_7f, TMP0);

  377. 

  378.                 vis_psub16(TMP6, TMP0, TMP4);

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

  380.                 dest += stride;

  381.         } while (--height);

  382. 

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

  384.         vis_xor(DST_0, REF_0, TMP4);

  385. 

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

  387.         vis_and(TMP4, MASK_fe, TMP4);

  388. 

  389.         vis_or(DST_0, REF_0, TMP6);

  390.         vis_ld64_2(dest, stride, DST_0);

  391.         vis_mul8x16(CONST_128, TMP4, TMP4);

  392. 

  393.         vis_faligndata(TMP0, TMP2, REF_0);

  394. 

  395.         vis_xor(DST_0, REF_0, TMP0);

  396. 

  397.         vis_and(TMP0, MASK_fe, TMP0);

  398. 

  399.         vis_and(TMP4, MASK_7f, TMP4);

  400. 

  401.         vis_psub16(TMP6, TMP4, TMP4);

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

  403.         dest += stride;

  404.         vis_mul8x16(CONST_128, TMP0, TMP0);

  405. 

  406.         vis_or(DST_0, REF_0, TMP6);

  407. 

  408.         vis_and(TMP0, MASK_7f, TMP0);

  409. 

  410.         vis_psub16(TMP6, TMP0, TMP4);

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

  412. }

  413. 

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

  415.                              const int stride, int height)

  416. {

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

  418.         unsigned long off_plus_1 = off + 1;

  419. 

  420.         ref = vis_alignaddr(ref);

  421. 

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

  423. 

  424.         vis_ld64_2(ref, 8,  TMP2);

  425. 

  426.         vis_ld64_2(ref, 16, TMP4);

  427. 

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

  429. 

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

  431.         vis_faligndata(TMP0, TMP2, REF_0);

  432. 

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

  434.         vis_faligndata(TMP2, TMP4, REF_4);

  435. 

  436.         if (off != 0x7) {

  437.                 vis_alignaddr_g0((void *)off_plus_1);

  438.                 vis_faligndata(TMP0, TMP2, REF_2);

  439.                 vis_faligndata(TMP2, TMP4, REF_6);

  440.         } else {

  441.                 vis_src1(TMP2, REF_2);

  442.                 vis_src1(TMP4, REF_6);

  443.         }

  444. 

  445.         ref += stride;

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

  447. 

  448.         do {    /* 34 cycles */

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

  450.                 vis_xor(REF_0, REF_2, TMP6);

  451. 

  452.                 vis_ld64_2(ref, 8,  TMP2);

  453.                 vis_xor(REF_4, REF_6, TMP8);

  454. 

  455.                 vis_ld64_2(ref, 16, TMP4);

  456.                 vis_and(TMP6, MASK_fe, TMP6);

  457.                 ref += stride;

  458. 

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

  460.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  461.                 vis_and(TMP8, MASK_fe, TMP8);

  462. 

  463.                 vis_ld64_2(ref, 8,  TMP16);

  464.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  465.                 vis_or(REF_0, REF_2, TMP10);

  466. 

  467.                 vis_ld64_2(ref, 16, TMP18);

  468.                 ref += stride;

  469.                 vis_or(REF_4, REF_6, TMP12);

  470. 

  471.                 vis_alignaddr_g0((void *)off);

  472. 

  473.                 vis_faligndata(TMP0, TMP2, REF_0);

  474. 

  475.                 vis_faligndata(TMP2, TMP4, REF_4);

  476. 

  477.                 if (off != 0x7) {

  478.                         vis_alignaddr_g0((void *)off_plus_1);

  479.                         vis_faligndata(TMP0, TMP2, REF_2);

  480.                         vis_faligndata(TMP2, TMP4, REF_6);

  481.                 } else {

  482.                         vis_src1(TMP2, REF_2);

  483.                         vis_src1(TMP4, REF_6);

  484.                 }

  485. 

  486.                 vis_and(TMP6, MASK_7f, TMP6);

  487. 

  488.                 vis_and(TMP8, MASK_7f, TMP8);

  489. 

  490.                 vis_psub16(TMP10, TMP6, TMP6);

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

  492. 

  493.                 vis_psub16(TMP12, TMP8, TMP8);

  494.                 vis_st64_2(TMP8, dest, 8);

  495.                 dest += stride;

  496. 

  497.                 vis_xor(REF_0, REF_2, TMP6);

  498. 

  499.                 vis_xor(REF_4, REF_6, TMP8);

  500. 

  501.                 vis_and(TMP6, MASK_fe, TMP6);

  502. 

  503.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  504.                 vis_and(TMP8, MASK_fe, TMP8);

  505. 

  506.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  507.                 vis_or(REF_0, REF_2, TMP10);

  508. 

  509.                 vis_or(REF_4, REF_6, TMP12);

  510. 

  511.                 vis_alignaddr_g0((void *)off);

  512. 

  513.                 vis_faligndata(TMP14, TMP16, REF_0);

  514. 

  515.                 vis_faligndata(TMP16, TMP18, REF_4);

  516. 

  517.                 if (off != 0x7) {

  518.                         vis_alignaddr_g0((void *)off_plus_1);

  519.                         vis_faligndata(TMP14, TMP16, REF_2);

  520.                         vis_faligndata(TMP16, TMP18, REF_6);

  521.                 } else {

  522.                         vis_src1(TMP16, REF_2);

  523.                         vis_src1(TMP18, REF_6);

  524.                 }

  525. 

  526.                 vis_and(TMP6, MASK_7f, TMP6);

  527. 

  528.                 vis_and(TMP8, MASK_7f, TMP8);

  529. 

  530.                 vis_psub16(TMP10, TMP6, TMP6);

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

  532. 

  533.                 vis_psub16(TMP12, TMP8, TMP8);

  534.                 vis_st64_2(TMP8, dest, 8);

  535.                 dest += stride;

  536.         } while (--height);

  537. 

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

  539.         vis_xor(REF_0, REF_2, TMP6);

  540. 

  541.         vis_ld64_2(ref, 8,  TMP2);

  542.         vis_xor(REF_4, REF_6, TMP8);

  543. 

  544.         vis_ld64_2(ref, 16, TMP4);

  545.         vis_and(TMP6, MASK_fe, TMP6);

  546. 

  547.         vis_mul8x16(CONST_128, TMP6, TMP6);

  548.         vis_and(TMP8, MASK_fe, TMP8);

  549. 

  550.         vis_mul8x16(CONST_128, TMP8, TMP8);

  551.         vis_or(REF_0, REF_2, TMP10);

  552. 

  553.         vis_or(REF_4, REF_6, TMP12);

  554. 

  555.         vis_alignaddr_g0((void *)off);

  556. 

  557.         vis_faligndata(TMP0, TMP2, REF_0);

  558. 

  559.         vis_faligndata(TMP2, TMP4, REF_4);

  560. 

  561.         if (off != 0x7) {

  562.                 vis_alignaddr_g0((void *)off_plus_1);

  563.                 vis_faligndata(TMP0, TMP2, REF_2);

  564.                 vis_faligndata(TMP2, TMP4, REF_6);

  565.         } else {

  566.                 vis_src1(TMP2, REF_2);

  567.                 vis_src1(TMP4, REF_6);

  568.         }

  569. 

  570.         vis_and(TMP6, MASK_7f, TMP6);

  571. 

  572.         vis_and(TMP8, MASK_7f, TMP8);

  573. 

  574.         vis_psub16(TMP10, TMP6, TMP6);

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

  576. 

  577.         vis_psub16(TMP12, TMP8, TMP8);

  578.         vis_st64_2(TMP8, dest, 8);

  579.         dest += stride;

  580. 

  581.         vis_xor(REF_0, REF_2, TMP6);

  582. 

  583.         vis_xor(REF_4, REF_6, TMP8);

  584. 

  585.         vis_and(TMP6, MASK_fe, TMP6);

  586. 

  587.         vis_mul8x16(CONST_128, TMP6, TMP6);

  588.         vis_and(TMP8, MASK_fe, TMP8);

  589. 

  590.         vis_mul8x16(CONST_128, TMP8, TMP8);

  591.         vis_or(REF_0, REF_2, TMP10);

  592. 

  593.         vis_or(REF_4, REF_6, TMP12);

  594. 

  595.         vis_and(TMP6, MASK_7f, TMP6);

  596. 

  597.         vis_and(TMP8, MASK_7f, TMP8);

  598. 

  599.         vis_psub16(TMP10, TMP6, TMP6);

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

  601. 

  602.         vis_psub16(TMP12, TMP8, TMP8);

  603.         vis_st64_2(TMP8, dest, 8);

  604. }

  605. 

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

  607.                             const int stride, int height)

  608. {

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

  610.         unsigned long off_plus_1 = off + 1;

  611. 

  612.         ref = vis_alignaddr(ref);

  613. 

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

  615. 

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

  617. 

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

  619. 

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

  621. 

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

  623.         vis_faligndata(TMP0, TMP2, REF_0);

  624. 

  625.         if (off != 0x7) {

  626.                 vis_alignaddr_g0((void *)off_plus_1);

  627.                 vis_faligndata(TMP0, TMP2, REF_2);

  628.         } else {

  629.                 vis_src1(TMP2, REF_2);

  630.         }

  631. 

  632.         ref += stride;

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

  634. 

  635.         do {    /* 20 cycles */

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

  637.                 vis_xor(REF_0, REF_2, TMP4);

  638. 

  639.                 vis_ld64_2(ref, 8, TMP2);

  640.                 vis_and(TMP4, MASK_fe, TMP4);

  641.                 ref += stride;

  642. 

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

  644.                 vis_or(REF_0, REF_2, TMP6);

  645.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  646. 

  647.                 vis_alignaddr_g0((void *)off);

  648. 

  649.                 vis_ld64_2(ref, 8, TMP10);

  650.                 ref += stride;

  651.                 vis_faligndata(TMP0, TMP2, REF_0);

  652. 

  653.                 if (off != 0x7) {

  654.                         vis_alignaddr_g0((void *)off_plus_1);

  655.                         vis_faligndata(TMP0, TMP2, REF_2);

  656.                 } else {

  657.                         vis_src1(TMP2, REF_2);

  658.                 }

  659. 

  660.                 vis_and(TMP4, MASK_7f, TMP4);

  661. 

  662.                 vis_psub16(TMP6, TMP4, DST_0);

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

  664.                 dest += stride;

  665. 

  666.                 vis_xor(REF_0, REF_2, TMP12);

  667. 

  668.                 vis_and(TMP12, MASK_fe, TMP12);

  669. 

  670.                 vis_or(REF_0, REF_2, TMP14);

  671.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  672. 

  673.                 vis_alignaddr_g0((void *)off);

  674.                 vis_faligndata(TMP8, TMP10, REF_0);

  675.                 if (off != 0x7) {

  676.                         vis_alignaddr_g0((void *)off_plus_1);

  677.                         vis_faligndata(TMP8, TMP10, REF_2);

  678.                 } else {

  679.                         vis_src1(TMP10, REF_2);

  680.                 }

  681. 

  682.                 vis_and(TMP12, MASK_7f, TMP12);

  683. 

  684.                 vis_psub16(TMP14, TMP12, DST_0);

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

  686.                 dest += stride;

  687.         } while (--height);

  688. 

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

  690.         vis_xor(REF_0, REF_2, TMP4);

  691. 

  692.         vis_ld64_2(ref, 8, TMP2);

  693.         vis_and(TMP4, MASK_fe, TMP4);

  694. 

  695.         vis_or(REF_0, REF_2, TMP6);

  696.         vis_mul8x16(CONST_128, TMP4, TMP4);

  697. 

  698.         vis_alignaddr_g0((void *)off);

  699. 

  700.         vis_faligndata(TMP0, TMP2, REF_0);

  701. 

  702.         if (off != 0x7) {

  703.                 vis_alignaddr_g0((void *)off_plus_1);

  704.                 vis_faligndata(TMP0, TMP2, REF_2);

  705.         } else {

  706.                 vis_src1(TMP2, REF_2);

  707.         }

  708. 

  709.         vis_and(TMP4, MASK_7f, TMP4);

  710. 

  711.         vis_psub16(TMP6, TMP4, DST_0);

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

  713.         dest += stride;

  714. 

  715.         vis_xor(REF_0, REF_2, TMP12);

  716. 

  717.         vis_and(TMP12, MASK_fe, TMP12);

  718. 

  719.         vis_or(REF_0, REF_2, TMP14);

  720.         vis_mul8x16(CONST_128, TMP12, TMP12);

  721. 

  722.         vis_and(TMP12, MASK_7f, TMP12);

  723. 

  724.         vis_psub16(TMP14, TMP12, DST_0);

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

  726.         dest += stride;

  727. }

  728. 

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

  730.                              const int stride, int height)

  731. {

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

  733.         unsigned long off_plus_1 = off + 1;

  734. 

  735.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  736. 

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

  738.         vis_fzero(ZERO);

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

  740. 

  741.         ref = vis_alignaddr(ref);

  742.         do {    /* 26 cycles */

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

  744. 

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

  746. 

  747.                 vis_alignaddr_g0((void *)off);

  748. 

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

  750. 

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

  752.                 vis_faligndata(TMP0, TMP2, REF_0);

  753. 

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

  755.                 vis_faligndata(TMP2, TMP4, REF_4);

  756. 

  757.                 if (off != 0x7) {

  758.                         vis_alignaddr_g0((void *)off_plus_1);

  759.                         vis_faligndata(TMP0, TMP2, REF_2);

  760.                         vis_faligndata(TMP2, TMP4, REF_6);

  761.                 } else {

  762.                         vis_src1(TMP2, REF_2);

  763.                         vis_src1(TMP4, REF_6);

  764.                 }

  765. 

  766.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  767. 

  768.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  769.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  770. 

  771.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  772. 

  773.                 vis_padd16(TMP0, TMP4, TMP0);

  774. 

  775.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  776.                 vis_padd16(TMP2, TMP6, TMP2);

  777. 

  778.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  779. 

  780.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  781. 

  782.                 vis_padd16(TMP0, TMP4, TMP0);

  783.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  784. 

  785.                 vis_padd16(TMP2, TMP6, TMP2);

  786.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  787. 

  788.                 vis_padd16(TMP0, CONST_3, TMP8);

  789.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  790. 

  791.                 vis_padd16(TMP2, CONST_3, TMP10);

  792.                 vis_pack16(TMP8, DST_0);

  793. 

  794.                 vis_pack16(TMP10, DST_1);

  795.                 vis_padd16(TMP16, TMP12, TMP0);

  796. 

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

  798.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  799.                 vis_padd16(TMP18, TMP14, TMP2);

  800. 

  801.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  802.                 vis_padd16(TMP0, CONST_3, TMP0);

  803. 

  804.                 vis_padd16(TMP2, CONST_3, TMP2);

  805. 

  806.                 vis_padd16(TMP0, TMP4, TMP0);

  807. 

  808.                 vis_padd16(TMP2, TMP6, TMP2);

  809.                 vis_pack16(TMP0, DST_2);

  810. 

  811.                 vis_pack16(TMP2, DST_3);

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

  813. 

  814.                 ref += stride;

  815.                 dest += stride;

  816.         } while (--height);

  817. }

  818. 

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

  820.                             const int stride, int height)

  821. {

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

  823.         unsigned long off_plus_1 = off + 1;

  824.         int stride_times_2 = stride << 1;

  825. 

  826.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  827. 

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

  829.         vis_fzero(ZERO);

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

  831. 

  832.         ref = vis_alignaddr(ref);

  833.         height >>= 2;

  834.         do {    /* 47 cycles */

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

  836. 

  837.                 vis_ld64_2(ref, 8, TMP2);

  838.                 ref += stride;

  839. 

  840.                 vis_alignaddr_g0((void *)off);

  841. 

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

  843.                 vis_faligndata(TMP0, TMP2, REF_0);

  844. 

  845.                 vis_ld64_2(ref, 8, TMP6);

  846.                 ref += stride;

  847. 

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

  849. 

  850.                 vis_ld64_2(ref, 8, TMP10);

  851.                 ref += stride;

  852.                 vis_faligndata(TMP4, TMP6, REF_4);

  853. 

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

  855. 

  856.                 vis_ld64_2(ref, 8, TMP14);

  857.                 ref += stride;

  858.                 vis_faligndata(TMP8, TMP10, REF_S0);

  859. 

  860.                 vis_faligndata(TMP12, TMP14, REF_S4);

  861. 

  862.                 if (off != 0x7) {

  863.                         vis_alignaddr_g0((void *)off_plus_1);

  864. 

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

  866.                         vis_faligndata(TMP0, TMP2, REF_2);

  867. 

  868.                         vis_ld64_2(dest, stride, DST_2);

  869.                         vis_faligndata(TMP4, TMP6, REF_6);

  870. 

  871.                         vis_faligndata(TMP8, TMP10, REF_S2);

  872. 

  873.                         vis_faligndata(TMP12, TMP14, REF_S6);

  874.                 } else {

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

  876.                         vis_src1(TMP2, REF_2);

  877. 

  878.                         vis_ld64_2(dest, stride, DST_2);

  879.                         vis_src1(TMP6, REF_6);

  880. 

  881.                         vis_src1(TMP10, REF_S2);

  882. 

  883.                         vis_src1(TMP14, REF_S6);

  884.                 }

  885. 

  886.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  887.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  888. 

  889.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  890.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  891. 

  892.                 vis_padd16(TMP0, CONST_3, TMP0);

  893.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  894. 

  895.                 vis_padd16(TMP2, CONST_3, TMP2);

  896.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  897. 

  898.                 vis_padd16(TMP0, TMP4, TMP0);

  899.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  900. 

  901.                 vis_padd16(TMP2, TMP6, TMP2);

  902.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  903. 

  904.                 vis_padd16(TMP0, TMP16, TMP0);

  905.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  906. 

  907.                 vis_padd16(TMP2, TMP18, TMP2);

  908.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  909. 

  910.                 vis_padd16(TMP8, CONST_3, TMP8);

  911.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  912. 

  913.                 vis_padd16(TMP8, TMP12, TMP8);

  914.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  915. 

  916.                 vis_padd16(TMP10, TMP14, TMP10);

  917.                 vis_pack16(TMP0, DST_0);

  918. 

  919.                 vis_pack16(TMP2, DST_1);

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

  921.                 dest += stride;

  922.                 vis_padd16(TMP10, CONST_3, TMP10);

  923. 

  924.                 vis_ld64_2(dest, stride, DST_0);

  925.                 vis_padd16(TMP8, TMP16, TMP8);

  926. 

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

  928.                 vis_padd16(TMP10, TMP18, TMP10);

  929.                 vis_pack16(TMP8, DST_2);

  930. 

  931.                 vis_pack16(TMP10, DST_3);

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

  933.                 dest += stride;

  934. 

  935.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  936.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  937. 

  938.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  939.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  940. 

  941.                 vis_padd16(TMP0, CONST_3, TMP0);

  942.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  943. 

  944.                 vis_padd16(TMP2, CONST_3, TMP2);

  945.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  946. 

  947.                 vis_padd16(TMP0, TMP24, TMP0);

  948.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  949. 

  950.                 vis_padd16(TMP2, TMP6, TMP2);

  951.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  952. 

  953.                 vis_padd16(TMP8, CONST_3, TMP8);

  954.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  955. 

  956.                 vis_padd16(TMP10, CONST_3, TMP10);

  957.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  958. 

  959.                 vis_padd16(TMP8, TMP12, TMP8);

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

  961. 

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

  963.                 vis_padd16(TMP0, TMP16, TMP0);

  964. 

  965.                 vis_padd16(TMP2, TMP18, TMP2);

  966.                 vis_pack16(TMP0, DST_0);

  967. 

  968.                 vis_padd16(TMP10, TMP14, TMP10);

  969.                 vis_pack16(TMP2, DST_1);

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

  971.                 dest += stride;

  972. 

  973.                 vis_padd16(TMP8, TMP20, TMP8);

  974. 

  975.                 vis_padd16(TMP10, TMP22, TMP10);

  976.                 vis_pack16(TMP8, DST_2);

  977. 

  978.                 vis_pack16(TMP10, DST_3);

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

  980.                 dest += stride;

  981.         } while (--height);

  982. }

  983. 

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

  985.                              const int stride, int height)

  986. {

  987.         ref = vis_alignaddr(ref);

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

  989. 

  990.         vis_ld64_2(ref, 8, TMP2);

  991. 

  992.         vis_ld64_2(ref, 16, TMP4);

  993.         ref += stride;

  994. 

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

  996.         vis_faligndata(TMP0, TMP2, REF_0);

  997. 

  998.         vis_ld64_2(ref, 8, TMP8);

  999.         vis_faligndata(TMP2, TMP4, REF_4);

  1000. 

  1001.         vis_ld64_2(ref, 16, TMP10);

  1002.         ref += stride;

  1003. 

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

  1005.         vis_faligndata(TMP6, TMP8, REF_2);

  1006. 

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

  1008.         vis_faligndata(TMP8, TMP10, REF_6);

  1009. 

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

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

  1012.         do {    /* 24 cycles */

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

  1014.                 vis_xor(REF_0, REF_2, TMP12);

  1015. 

  1016.                 vis_ld64_2(ref, 8, TMP2);

  1017.                 vis_xor(REF_4, REF_6, TMP16);

  1018. 

  1019.                 vis_ld64_2(ref, 16, TMP4);

  1020.                 ref += stride;

  1021.                 vis_or(REF_0, REF_2, TMP14);

  1022. 

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

  1024.                 vis_or(REF_4, REF_6, TMP18);

  1025. 

  1026.                 vis_ld64_2(ref, 8, TMP8);

  1027.                 vis_faligndata(TMP0, TMP2, REF_0);

  1028. 

  1029.                 vis_ld64_2(ref, 16, TMP10);

  1030.                 ref += stride;

  1031.                 vis_faligndata(TMP2, TMP4, REF_4);

  1032. 

  1033.                 vis_and(TMP12, MASK_fe, TMP12);

  1034. 

  1035.                 vis_and(TMP16, MASK_fe, TMP16);

  1036.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1037. 

  1038.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  1039.                 vis_xor(REF_0, REF_2, TMP0);

  1040. 

  1041.                 vis_xor(REF_4, REF_6, TMP2);

  1042. 

  1043.                 vis_or(REF_0, REF_2, TMP20);

  1044. 

  1045.                 vis_and(TMP12, MASK_7f, TMP12);

  1046. 

  1047.                 vis_and(TMP16, MASK_7f, TMP16);

  1048. 

  1049.                 vis_psub16(TMP14, TMP12, TMP12);

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

  1051. 

  1052.                 vis_psub16(TMP18, TMP16, TMP16);

  1053.                 vis_st64_2(TMP16, dest, 8);

  1054.                 dest += stride;

  1055. 

  1056.                 vis_or(REF_4, REF_6, TMP18);

  1057. 

  1058.                 vis_and(TMP0, MASK_fe, TMP0);

  1059. 

  1060.                 vis_and(TMP2, MASK_fe, TMP2);

  1061.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  1062. 

  1063.                 vis_faligndata(TMP6, TMP8, REF_2);

  1064.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  1065. 

  1066.                 vis_faligndata(TMP8, TMP10, REF_6);

  1067. 

  1068.                 vis_and(TMP0, MASK_7f, TMP0);

  1069. 

  1070.                 vis_and(TMP2, MASK_7f, TMP2);

  1071. 

  1072.                 vis_psub16(TMP20, TMP0, TMP0);

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

  1074. 

  1075.                 vis_psub16(TMP18, TMP2, TMP2);

  1076.                 vis_st64_2(TMP2, dest, 8);

  1077.                 dest += stride;

  1078.         } while (--height);

  1079. 

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

  1081.         vis_xor(REF_0, REF_2, TMP12);

  1082. 

  1083.         vis_ld64_2(ref, 8, TMP2);

  1084.         vis_xor(REF_4, REF_6, TMP16);

  1085. 

  1086.         vis_ld64_2(ref, 16, TMP4);

  1087.         vis_or(REF_0, REF_2, TMP14);

  1088. 

  1089.         vis_or(REF_4, REF_6, TMP18);

  1090. 

  1091.         vis_faligndata(TMP0, TMP2, REF_0);

  1092. 

  1093.         vis_faligndata(TMP2, TMP4, REF_4);

  1094. 

  1095.         vis_and(TMP12, MASK_fe, TMP12);

  1096. 

  1097.         vis_and(TMP16, MASK_fe, TMP16);

  1098.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1099. 

  1100.         vis_mul8x16(CONST_128, TMP16, TMP16);

  1101.         vis_xor(REF_0, REF_2, TMP0);

  1102. 

  1103.         vis_xor(REF_4, REF_6, TMP2);

  1104. 

  1105.         vis_or(REF_0, REF_2, TMP20);

  1106. 

  1107.         vis_and(TMP12, MASK_7f, TMP12);

  1108. 

  1109.         vis_and(TMP16, MASK_7f, TMP16);

  1110. 

  1111.         vis_psub16(TMP14, TMP12, TMP12);

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

  1113. 

  1114.         vis_psub16(TMP18, TMP16, TMP16);

  1115.         vis_st64_2(TMP16, dest, 8);

  1116.         dest += stride;

  1117. 

  1118.         vis_or(REF_4, REF_6, TMP18);

  1119. 

  1120.         vis_and(TMP0, MASK_fe, TMP0);

  1121. 

  1122.         vis_and(TMP2, MASK_fe, TMP2);

  1123.         vis_mul8x16(CONST_128, TMP0, TMP0);

  1124. 

  1125.         vis_mul8x16(CONST_128, TMP2, TMP2);

  1126. 

  1127.         vis_and(TMP0, MASK_7f, TMP0);

  1128. 

  1129.         vis_and(TMP2, MASK_7f, TMP2);

  1130. 

  1131.         vis_psub16(TMP20, TMP0, TMP0);

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

  1133. 

  1134.         vis_psub16(TMP18, TMP2, TMP2);

  1135.         vis_st64_2(TMP2, dest, 8);

  1136. }

  1137. 

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

  1139.                             const int stride, int height)

  1140. {

  1141.         ref = vis_alignaddr(ref);

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

  1143. 

  1144.         vis_ld64_2(ref, 8, TMP2);

  1145.         ref += stride;

  1146. 

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

  1148. 

  1149.         vis_ld64_2(ref, 8, TMP6);

  1150.         ref += stride;

  1151. 

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

  1153.         vis_faligndata(TMP0, TMP2, REF_0);

  1154. 

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

  1156.         vis_faligndata(TMP4, TMP6, REF_2);

  1157. 

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

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

  1160.         do {    /* 12 cycles */

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

  1162.                 vis_xor(REF_0, REF_2, TMP4);

  1163. 

  1164.                 vis_ld64_2(ref, 8, TMP2);

  1165.                 ref += stride;

  1166.                 vis_and(TMP4, MASK_fe, TMP4);

  1167. 

  1168.                 vis_or(REF_0, REF_2, TMP6);

  1169.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  1170. 

  1171.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  1173. 

  1174.                 vis_ld64_2(ref, 8, TMP2);

  1175.                 ref += stride;

  1176.                 vis_xor(REF_0, REF_2, TMP12);

  1177. 

  1178.                 vis_and(TMP4, MASK_7f, TMP4);

  1179. 

  1180.                 vis_and(TMP12, MASK_fe, TMP12);

  1181. 

  1182.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  1183.                 vis_or(REF_0, REF_2, TMP14);

  1184. 

  1185.                 vis_psub16(TMP6, TMP4, DST_0);

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

  1187.                 dest += stride;

  1188. 

  1189.                 vis_faligndata(TMP0, TMP2, REF_2);

  1190. 

  1191.                 vis_and(TMP12, MASK_7f, TMP12);

  1192. 

  1193.                 vis_psub16(TMP14, TMP12, DST_0);

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

  1195.                 dest += stride;

  1196.         } while (--height);

  1197. 

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

  1199.         vis_xor(REF_0, REF_2, TMP4);

  1200. 

  1201.         vis_ld64_2(ref, 8, TMP2);

  1202.         vis_and(TMP4, MASK_fe, TMP4);

  1203. 

  1204.         vis_or(REF_0, REF_2, TMP6);

  1205.         vis_mul8x16(CONST_128, TMP4, TMP4);

  1206. 

  1207.         vis_faligndata(TMP0, TMP2, REF_0);

  1208. 

  1209.         vis_xor(REF_0, REF_2, TMP12);

  1210. 

  1211.         vis_and(TMP4, MASK_7f, TMP4);

  1212. 

  1213.         vis_and(TMP12, MASK_fe, TMP12);

  1214. 

  1215.         vis_mul8x16(CONST_128, TMP12, TMP12);

  1216.         vis_or(REF_0, REF_2, TMP14);

  1217. 

  1218.         vis_psub16(TMP6, TMP4, DST_0);

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

  1220.         dest += stride;

  1221. 

  1222.         vis_and(TMP12, MASK_7f, TMP12);

  1223. 

  1224.         vis_psub16(TMP14, TMP12, DST_0);

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

  1226. }

  1227. 

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

  1229.                              const int stride, int height)

  1230. {

  1231.         int stride_8 = stride + 8;

  1232.         int stride_16 = stride + 16;

  1233. 

  1234.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1235. 

  1236.         ref = vis_alignaddr(ref);

  1237. 

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

  1239.         vis_fzero(ZERO);

  1240. 

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

  1242. 

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

  1244. 

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

  1246.         vis_faligndata(TMP0, TMP2, REF_2);

  1247. 

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

  1249.         vis_faligndata(TMP2, TMP4, REF_6);

  1250.         height >>= 1;

  1251. 

  1252.         do {    /* 31 cycles */

  1253.                 vis_ld64_2(ref, stride, TMP0);

  1254.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  1255.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  1256. 

  1257.                 vis_ld64_2(ref, stride_8, TMP2);

  1258.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  1259.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  1260. 

  1261.                 vis_ld64_2(ref, stride_16, TMP4);

  1262.                 ref += stride;

  1263. 

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

  1265.                 vis_faligndata(TMP0, TMP2, REF_0);

  1266. 

  1267.                 vis_ld64_2(dest, 8, DST_2);

  1268.                 vis_faligndata(TMP2, TMP4, REF_4);

  1269. 

  1270.                 vis_ld64_2(ref, stride, TMP6);

  1271.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  1272.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  1273. 

  1274.                 vis_ld64_2(ref, stride_8, TMP8);

  1275.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  1276. 

  1277.                 vis_ld64_2(ref, stride_16, TMP10);

  1278.                 ref += stride;

  1279. 

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

  1281.                 vis_faligndata(TMP6, TMP8, REF_2);

  1282.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1283. 

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

  1285.                 vis_faligndata(TMP8, TMP10, REF_6);

  1286.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  1287. 

  1288.                 vis_padd16(TMP0, CONST_3, TMP0);

  1289.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  1290. 

  1291.                 vis_padd16(TMP2, CONST_3, TMP2);

  1292.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1293. 

  1294.                 vis_padd16(TMP4, CONST_3, TMP4);

  1295.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1296. 

  1297.                 vis_padd16(TMP6, CONST_3, TMP6);

  1298. 

  1299.                 vis_padd16(TMP12, TMP20, TMP12);

  1300.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  1301. 

  1302.                 vis_padd16(TMP14, TMP22, TMP14);

  1303.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  1304. 

  1305.                 vis_padd16(TMP16, TMP24, TMP16);

  1306.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  1307. 

  1308.                 vis_padd16(TMP18, TMP26, TMP18);

  1309.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  1310. 

  1311.                 vis_padd16(TMP12, TMP0, TMP12);

  1312.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  1313. 

  1314.                 vis_padd16(TMP14, TMP2, TMP14);

  1315.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  1316. 

  1317.                 vis_padd16(TMP16, TMP4, TMP16);

  1318.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  1319. 

  1320.                 vis_padd16(TMP18, TMP6, TMP18);

  1321.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  1322. 

  1323.                 vis_pack16(TMP12, DST_0);

  1324.                 vis_padd16(TMP28, TMP0, TMP12);

  1325. 

  1326.                 vis_pack16(TMP14, DST_1);

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

  1328.                 vis_padd16(TMP30, TMP2, TMP14);

  1329. 

  1330.                 vis_pack16(TMP16, DST_2);

  1331.                 vis_padd16(REF_S4, TMP4, TMP16);

  1332. 

  1333.                 vis_pack16(TMP18, DST_3);

  1334.                 vis_st64_2(DST_2, dest, 8);

  1335.                 dest += stride;

  1336.                 vis_padd16(REF_S6, TMP6, TMP18);

  1337. 

  1338.                 vis_padd16(TMP12, TMP20, TMP12);

  1339. 

  1340.                 vis_padd16(TMP14, TMP22, TMP14);

  1341.                 vis_pack16(TMP12, DST_0);

  1342. 

  1343.                 vis_padd16(TMP16, TMP24, TMP16);

  1344.                 vis_pack16(TMP14, DST_1);

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

  1346. 

  1347.                 vis_padd16(TMP18, TMP26, TMP18);

  1348.                 vis_pack16(TMP16, DST_2);

  1349. 

  1350.                 vis_pack16(TMP18, DST_3);

  1351.                 vis_st64_2(DST_2, dest, 8);

  1352.                 dest += stride;

  1353.         } while (--height);

  1354. }

  1355. 

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

  1357.                             const int stride, int height)

  1358. {

  1359.         int stride_8 = stride + 8;

  1360. 

  1361.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1362. 

  1363.         ref = vis_alignaddr(ref);

  1364. 

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

  1366.         vis_fzero(ZERO);

  1367. 

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

  1369. 

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

  1371.         vis_faligndata(TMP0, TMP2, REF_2);

  1372. 

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

  1374. 

  1375.         height >>= 1;

  1376.         do {    /* 20 cycles */

  1377.                 vis_ld64_2(ref, stride, TMP0);

  1378.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  1379.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  1380. 

  1381.                 vis_ld64_2(ref, stride_8, TMP2);

  1382.                 ref += stride;

  1383. 

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

  1385. 

  1386.                 vis_ld64_2(dest, stride, DST_2);

  1387.                 vis_faligndata(TMP0, TMP2, REF_0);

  1388. 

  1389.                 vis_ld64_2(ref, stride, TMP4);

  1390.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  1391.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  1392. 

  1393.                 vis_ld64_2(ref, stride_8, TMP6);

  1394.                 ref += stride;

  1395.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  1396.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  1397. 

  1398.                 vis_padd16(TMP12, CONST_3, TMP12);

  1399.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  1400. 

  1401.                 vis_padd16(TMP14, CONST_3, TMP14);

  1402.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  1403. 

  1404.                 vis_faligndata(TMP4, TMP6, REF_2);

  1405. 

  1406.                 vis_padd16(TMP8, TMP12, TMP8);

  1407. 

  1408.                 vis_padd16(TMP10, TMP14, TMP10);

  1409.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  1410. 

  1411.                 vis_padd16(TMP8, TMP16, TMP0);

  1412.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  1413. 

  1414.                 vis_padd16(TMP10, TMP18, TMP2);

  1415.                 vis_pack16(TMP0, DST_0);

  1416. 

  1417.                 vis_pack16(TMP2, DST_1);

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

  1419.                 dest += stride;

  1420.                 vis_padd16(TMP12, TMP20, TMP12);

  1421. 

  1422.                 vis_padd16(TMP14, TMP22, TMP14);

  1423. 

  1424.                 vis_padd16(TMP12, TMP24, TMP0);

  1425. 

  1426.                 vis_padd16(TMP14, TMP26, TMP2);

  1427.                 vis_pack16(TMP0, DST_2);

  1428. 

  1429.                 vis_pack16(TMP2, DST_3);

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

  1431.                 dest += stride;

  1432.         } while (--height);

  1433. }

  1434. 

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

  1436.                               const int stride, int height)

  1437. {

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

  1439.         unsigned long off_plus_1 = off + 1;

  1440.         int stride_8 = stride + 8;

  1441.         int stride_16 = stride + 16;

  1442. 

  1443.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1444. 

  1445.         ref = vis_alignaddr(ref);

  1446. 

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

  1448.         vis_fzero(ZERO);

  1449. 

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

  1451. 

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

  1453. 

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

  1455.         vis_faligndata(TMP0, TMP2, REF_S0);

  1456. 

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

  1458.         vis_faligndata(TMP2, TMP4, REF_S4);

  1459. 

  1460.         if (off != 0x7) {

  1461.                 vis_alignaddr_g0((void *)off_plus_1);

  1462.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1463.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1464.         } else {

  1465.                 vis_src1(TMP2, REF_S2);

  1466.                 vis_src1(TMP4, REF_S6);

  1467.         }

  1468. 

  1469.         height >>= 1;

  1470.         do {

  1471.                 vis_ld64_2(ref, stride, TMP0);

  1472.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1473.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1474. 

  1475.                 vis_alignaddr_g0((void *)off);

  1476. 

  1477.                 vis_ld64_2(ref, stride_8, TMP2);

  1478.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1479.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1480. 

  1481.                 vis_ld64_2(ref, stride_16, TMP4);

  1482.                 ref += stride;

  1483.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1484.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1485. 

  1486.                 vis_ld64_2(ref, stride, TMP6);

  1487.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1488.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1489. 

  1490.                 vis_ld64_2(ref, stride_8, TMP8);

  1491.                 vis_faligndata(TMP0, TMP2, REF_0);

  1492. 

  1493.                 vis_ld64_2(ref, stride_16, TMP10);

  1494.                 ref += stride;

  1495.                 vis_faligndata(TMP2, TMP4, REF_4);

  1496. 

  1497.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1498. 

  1499.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1500. 

  1501.                 if (off != 0x7) {

  1502.                         vis_alignaddr_g0((void *)off_plus_1);

  1503.                         vis_faligndata(TMP0, TMP2, REF_2);

  1504.                         vis_faligndata(TMP2, TMP4, REF_6);

  1505.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1506.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1507.                 } else {

  1508.                         vis_src1(TMP2, REF_2);

  1509.                         vis_src1(TMP4, REF_6);

  1510.                         vis_src1(TMP8, REF_S2);

  1511.                         vis_src1(TMP10, REF_S6);

  1512.                 }

  1513. 

  1514.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  1515.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1516. 

  1517.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1518.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1519. 

  1520.                 vis_padd16(TMP0, CONST_2, TMP8);

  1521.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  1522. 

  1523.                 vis_padd16(TMP2, CONST_2, TMP10);

  1524.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  1525. 

  1526.                 vis_padd16(TMP8, TMP4, TMP8);

  1527.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  1528. 

  1529.                 vis_padd16(TMP10, TMP6, TMP10);

  1530.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  1531. 

  1532.                 vis_padd16(TMP12, TMP8, TMP12);

  1533. 

  1534.                 vis_padd16(TMP14, TMP10, TMP14);

  1535. 

  1536.                 vis_padd16(TMP12, TMP16, TMP12);

  1537. 

  1538.                 vis_padd16(TMP14, TMP18, TMP14);

  1539.                 vis_pack16(TMP12, DST_0);

  1540. 

  1541.                 vis_pack16(TMP14, DST_1);

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

  1543.                 vis_padd16(TMP0, CONST_2, TMP12);

  1544. 

  1545.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  1546.                 vis_padd16(TMP2, CONST_2, TMP14);

  1547. 

  1548.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  1549.                 vis_padd16(TMP12, TMP4, TMP12);

  1550. 

  1551.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  1552.                 vis_padd16(TMP14, TMP6, TMP14);

  1553. 

  1554.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  1555.                 vis_padd16(TMP20, TMP12, TMP20);

  1556. 

  1557.                 vis_padd16(TMP22, TMP14, TMP22);

  1558. 

  1559.                 vis_padd16(TMP20, TMP24, TMP20);

  1560. 

  1561.                 vis_padd16(TMP22, TMP26, TMP22);

  1562.                 vis_pack16(TMP20, DST_2);

  1563. 

  1564.                 vis_pack16(TMP22, DST_3);

  1565.                 vis_st64_2(DST_2, dest, 8);

  1566.                 dest += stride;

  1567.                 vis_padd16(TMP0, TMP4, TMP24);

  1568. 

  1569.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  1570.                 vis_padd16(TMP2, TMP6, TMP26);

  1571. 

  1572.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  1573.                 vis_padd16(TMP24, TMP8, TMP24);

  1574. 

  1575.                 vis_padd16(TMP26, TMP10, TMP26);

  1576.                 vis_pack16(TMP24, DST_0);

  1577. 

  1578.                 vis_pack16(TMP26, DST_1);

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

  1580.                 vis_pmerge(ZERO, REF_S6, TMP4);

  1581. 

  1582.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  1583. 

  1584.                 vis_padd16(TMP0, TMP4, TMP0);

  1585. 

  1586.                 vis_padd16(TMP2, TMP6, TMP2);

  1587. 

  1588.                 vis_padd16(TMP0, TMP12, TMP0);

  1589. 

  1590.                 vis_padd16(TMP2, TMP14, TMP2);

  1591.                 vis_pack16(TMP0, DST_2);

  1592. 

  1593.                 vis_pack16(TMP2, DST_3);

  1594.                 vis_st64_2(DST_2, dest, 8);

  1595.                 dest += stride;

  1596.         } while (--height);

  1597. }

  1598. 

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

  1600.                              const int stride, int height)

  1601. {

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

  1603.         unsigned long off_plus_1 = off + 1;

  1604.         int stride_8 = stride + 8;

  1605. 

  1606.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  1607. 

  1608.         ref = vis_alignaddr(ref);

  1609. 

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

  1611.         vis_fzero(ZERO);

  1612. 

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

  1614. 

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

  1616. 

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

  1618.         vis_faligndata(TMP0, TMP2, REF_S0);

  1619. 

  1620.         if (off != 0x7) {

  1621.                 vis_alignaddr_g0((void *)off_plus_1);

  1622.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1623.         } else {

  1624.                 vis_src1(TMP2, REF_S2);

  1625.         }

  1626. 

  1627.         height >>= 1;

  1628.         do {    /* 26 cycles */

  1629.                 vis_ld64_2(ref, stride, TMP0);

  1630.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  1631.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  1632. 

  1633.                 vis_alignaddr_g0((void *)off);

  1634. 

  1635.                 vis_ld64_2(ref, stride_8, TMP2);

  1636.                 ref += stride;

  1637.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  1638.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  1639. 

  1640.                 vis_ld64_2(ref, stride, TMP4);

  1641. 

  1642.                 vis_ld64_2(ref, stride_8, TMP6);

  1643.                 ref += stride;

  1644.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1645. 

  1646.                 vis_pmerge(ZERO, REF_S4, TMP18);

  1647. 

  1648.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  1649. 

  1650.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1651. 

  1652.                 if (off != 0x7) {

  1653.                         vis_alignaddr_g0((void *)off_plus_1);

  1654.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1655.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1656.                 } else {

  1657.                         vis_src1(TMP2, REF_S6);

  1658.                         vis_src1(TMP6, REF_S2);

  1659.                 }

  1660. 

  1661.                 vis_padd16(TMP18, CONST_2, TMP18);

  1662.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  1663. 

  1664.                 vis_padd16(TMP20, CONST_2, TMP20);

  1665.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  1666. 

  1667.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  1668.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  1669. 

  1670.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  1671.                 vis_padd16(TMP18, TMP22, TMP18);

  1672. 

  1673.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  1674.                 vis_padd16(TMP20, TMP24, TMP20);

  1675. 

  1676.                 vis_padd16(TMP8,  TMP18, TMP8);

  1677. 

  1678.                 vis_padd16(TMP10, TMP20, TMP10);

  1679. 

  1680.                 vis_padd16(TMP8,  TMP12, TMP8);

  1681. 

  1682.                 vis_padd16(TMP10, TMP14, TMP10);

  1683.                 vis_pack16(TMP8,  DST_0);

  1684. 

  1685.                 vis_pack16(TMP10, DST_1);

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

  1687.                 dest += stride;

  1688.                 vis_padd16(TMP18, TMP26, TMP18);

  1689. 

  1690.                 vis_padd16(TMP20, TMP28, TMP20);

  1691. 

  1692.                 vis_padd16(TMP18, TMP30, TMP18);

  1693. 

  1694.                 vis_padd16(TMP20, TMP32, TMP20);

  1695.                 vis_pack16(TMP18, DST_2);

  1696. 

  1697.                 vis_pack16(TMP20, DST_3);

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

  1699.                 dest += stride;

  1700.         } while (--height);

  1701. }

  1702. 

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

  1704.                               const int stride, int height)

  1705. {

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

  1707.         unsigned long off_plus_1 = off + 1;

  1708.         int stride_8 = stride + 8;

  1709.         int stride_16 = stride + 16;

  1710. 

  1711.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1712. 

  1713.         ref = vis_alignaddr(ref);

  1714. 

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

  1716.         vis_fzero(ZERO);

  1717. 

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

  1719. 

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

  1721. 

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

  1723.         vis_faligndata(TMP0, TMP2, REF_S0);

  1724. 

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

  1726.         vis_faligndata(TMP2, TMP4, REF_S4);

  1727. 

  1728.         if (off != 0x7) {

  1729.                 vis_alignaddr_g0((void *)off_plus_1);

  1730.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1731.                 vis_faligndata(TMP2, TMP4, REF_S6);

  1732.         } else {

  1733.                 vis_src1(TMP2, REF_S2);

  1734.                 vis_src1(TMP4, REF_S6);

  1735.         }

  1736. 

  1737.         height >>= 1;

  1738.         do {    /* 55 cycles */

  1739.                 vis_ld64_2(ref, stride, TMP0);

  1740.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  1741.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  1742. 

  1743.                 vis_alignaddr_g0((void *)off);

  1744. 

  1745.                 vis_ld64_2(ref, stride_8, TMP2);

  1746.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  1747.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  1748. 

  1749.                 vis_ld64_2(ref, stride_16, TMP4);

  1750.                 ref += stride;

  1751.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  1752.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  1753. 

  1754.                 vis_ld64_2(ref, stride, TMP6);

  1755.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  1756.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  1757. 

  1758.                 vis_ld64_2(ref, stride_8, TMP8);

  1759.                 vis_faligndata(TMP0, TMP2, REF_0);

  1760. 

  1761.                 vis_ld64_2(ref, stride_16, TMP10);

  1762.                 ref += stride;

  1763.                 vis_faligndata(TMP2, TMP4, REF_4);

  1764. 

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

  1766.                 vis_faligndata(TMP6, TMP8, REF_S0);

  1767. 

  1768.                 vis_ld64_2(dest, 8, DST_2);

  1769.                 vis_faligndata(TMP8, TMP10, REF_S4);

  1770. 

  1771.                 if (off != 0x7) {

  1772.                         vis_alignaddr_g0((void *)off_plus_1);

  1773.                         vis_faligndata(TMP0, TMP2, REF_2);

  1774.                         vis_faligndata(TMP2, TMP4, REF_6);

  1775.                         vis_faligndata(TMP6, TMP8, REF_S2);

  1776.                         vis_faligndata(TMP8, TMP10, REF_S6);

  1777.                 } else {

  1778.                         vis_src1(TMP2, REF_2);

  1779.                         vis_src1(TMP4, REF_6);

  1780.                         vis_src1(TMP8, REF_S2);

  1781.                         vis_src1(TMP10, REF_S6);

  1782.                 }

  1783. 

  1784.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1785.                 vis_pmerge(ZERO, REF_0, TMP0);

  1786. 

  1787.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1788.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  1789. 

  1790.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  1791.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  1792. 

  1793.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1794.                 vis_padd16(TMP0, CONST_6, TMP0);

  1795. 

  1796.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1797.                 vis_padd16(TMP2, CONST_6, TMP2);

  1798. 

  1799.                 vis_padd16(TMP0, TMP4, TMP0);

  1800.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  1801. 

  1802.                 vis_padd16(TMP2, TMP6, TMP2);

  1803.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  1804. 

  1805.                 vis_padd16(TMP12, TMP0, TMP12);

  1806.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  1807. 

  1808.                 vis_padd16(TMP14, TMP2, TMP14);

  1809.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  1810. 

  1811.                 vis_padd16(TMP12, TMP16, TMP12);

  1812.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  1813. 

  1814.                 vis_padd16(TMP14, TMP18, TMP14);

  1815.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  1816. 

  1817.                 vis_padd16(TMP12, TMP30, TMP12);

  1818. 

  1819.                 vis_padd16(TMP14, TMP32, TMP14);

  1820.                 vis_pack16(TMP12, DST_0);

  1821. 

  1822.                 vis_pack16(TMP14, DST_1);

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

  1824.                 vis_padd16(TMP4, CONST_6, TMP4);

  1825. 

  1826.                 vis_ld64_2(dest, stride, DST_0);

  1827.                 vis_padd16(TMP6, CONST_6, TMP6);

  1828.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1829. 

  1830.                 vis_padd16(TMP4, TMP8, TMP4);

  1831.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  1832. 

  1833.                 vis_padd16(TMP6, TMP10, TMP6);

  1834. 

  1835.                 vis_padd16(TMP20, TMP4, TMP20);

  1836. 

  1837.                 vis_padd16(TMP22, TMP6, TMP22);

  1838. 

  1839.                 vis_padd16(TMP20, TMP24, TMP20);

  1840. 

  1841.                 vis_padd16(TMP22, TMP26, TMP22);

  1842. 

  1843.                 vis_padd16(TMP20, REF_0, TMP20);

  1844.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  1845. 

  1846.                 vis_padd16(TMP22, REF_2, TMP22);

  1847.                 vis_pack16(TMP20, DST_2);

  1848. 

  1849.                 vis_pack16(TMP22, DST_3);

  1850.                 vis_st64_2(DST_2, dest, 8);

  1851.                 dest += stride;

  1852. 

  1853.                 vis_ld64_2(dest, 8, DST_2);

  1854.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1855.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  1856. 

  1857.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1858.                 vis_padd16(REF_4, TMP0, TMP8);

  1859. 

  1860.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  1861.                 vis_padd16(REF_6, TMP2, TMP10);

  1862. 

  1863.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  1864.                 vis_padd16(TMP8, TMP12, TMP8);

  1865. 

  1866.                 vis_padd16(TMP10, TMP14, TMP10);

  1867. 

  1868.                 vis_padd16(TMP8, TMP30, TMP8);

  1869. 

  1870.                 vis_padd16(TMP10, TMP32, TMP10);

  1871.                 vis_pack16(TMP8, DST_0);

  1872. 

  1873.                 vis_pack16(TMP10, DST_1);

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

  1875. 

  1876.                 vis_padd16(REF_0, TMP4, REF_0);

  1877. 

  1878.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  1879.                 vis_padd16(REF_2, TMP6, REF_2);

  1880. 

  1881.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  1882.                 vis_padd16(REF_0, REF_4, REF_0);

  1883. 

  1884.                 vis_padd16(REF_2, REF_6, REF_2);

  1885. 

  1886.                 vis_padd16(REF_0, TMP30, REF_0);

  1887. 

  1888.                 /* stall */

  1889. 

  1890.                 vis_padd16(REF_2, TMP32, REF_2);

  1891.                 vis_pack16(REF_0, DST_2);

  1892. 

  1893.                 vis_pack16(REF_2, DST_3);

  1894.                 vis_st64_2(DST_2, dest, 8);

  1895.                 dest += stride;

  1896.         } while (--height);

  1897. }

  1898. 

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

  1900.                              const int stride, int height)

  1901. {

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

  1903.         unsigned long off_plus_1 = off + 1;

  1904.         int stride_8 = stride + 8;

  1905. 

  1906.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  1907. 

  1908.         ref = vis_alignaddr(ref);

  1909. 

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

  1911.         vis_fzero(ZERO);

  1912. 

  1913.         vis_ld64_2(ref, 8, TMP2);

  1914. 

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

  1916. 

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

  1918.         vis_faligndata(TMP0, TMP2, REF_S0);

  1919. 

  1920.         if (off != 0x7) {

  1921.                 vis_alignaddr_g0((void *)off_plus_1);

  1922.                 vis_faligndata(TMP0, TMP2, REF_S2);

  1923.         } else {

  1924.                 vis_src1(TMP2, REF_S2);

  1925.         }

  1926. 

  1927.         height >>= 1;

  1928.         do {    /* 31 cycles */

  1929.                 vis_ld64_2(ref, stride, TMP0);

  1930.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  1931.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  1932. 

  1933.                 vis_ld64_2(ref, stride_8, TMP2);

  1934.                 ref += stride;

  1935.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  1936.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  1937. 

  1938.                 vis_alignaddr_g0((void *)off);

  1939. 

  1940.                 vis_ld64_2(ref, stride, TMP4);

  1941.                 vis_faligndata(TMP0, TMP2, REF_S4);

  1942. 

  1943.                 vis_ld64_2(ref, stride_8, TMP6);

  1944.                 ref += stride;

  1945. 

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

  1947.                 vis_faligndata(TMP4, TMP6, REF_S0);

  1948. 

  1949.                 vis_ld64_2(dest, stride, DST_2);

  1950. 

  1951.                 if (off != 0x7) {

  1952.                         vis_alignaddr_g0((void *)off_plus_1);

  1953.                         vis_faligndata(TMP0, TMP2, REF_S6);

  1954.                         vis_faligndata(TMP4, TMP6, REF_S2);

  1955.                 } else {

  1956.                         vis_src1(TMP2, REF_S6);

  1957.                         vis_src1(TMP6, REF_S2);

  1958.                 }

  1959. 

  1960.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  1961.                 vis_pmerge(ZERO, REF_S4, TMP22);

  1962. 

  1963.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  1964.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  1965. 

  1966.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  1967.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  1968. 

  1969.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  1970.                 vis_padd16(TMP22, CONST_6, TMP22);

  1971. 

  1972.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  1973.                 vis_padd16(TMP24, CONST_6, TMP24);

  1974. 

  1975.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  1976.                 vis_padd16(TMP22, TMP26, TMP22);

  1977. 

  1978.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  1979.                 vis_padd16(TMP24, TMP28, TMP24);

  1980. 

  1981.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  1982.                 vis_padd16(TMP8, TMP22, TMP8);

  1983. 

  1984.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  1985.                 vis_padd16(TMP10, TMP24, TMP10);

  1986. 

  1987.                 vis_padd16(TMP8, TMP12, TMP8);

  1988. 

  1989.                 vis_padd16(TMP10, TMP14, TMP10);

  1990. 

  1991.                 vis_padd16(TMP8, TMP30, TMP8);

  1992. 

  1993.                 vis_padd16(TMP10, TMP32, TMP10);

  1994.                 vis_pack16(TMP8, DST_0);

  1995. 

  1996.                 vis_pack16(TMP10, DST_1);

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

  1998.                 dest += stride;

  1999. 

  2000.                 vis_padd16(REF_S4, TMP22, TMP12);

  2001. 

  2002.                 vis_padd16(REF_S6, TMP24, TMP14);

  2003. 

  2004.                 vis_padd16(TMP12, TMP26, TMP12);

  2005. 

  2006.                 vis_padd16(TMP14, TMP28, TMP14);

  2007. 

  2008.                 vis_padd16(TMP12, REF_0, TMP12);

  2009. 

  2010.                 vis_padd16(TMP14, REF_2, TMP14);

  2011.                 vis_pack16(TMP12, DST_2);

  2012. 

  2013.                 vis_pack16(TMP14, DST_3);

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

  2015.                 dest += stride;

  2016.         } while (--height);

  2017. }

  2018. 

  2019. /* End of rounding code */

  2020. 

  2021. /* Start of no rounding code */

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

  2023.  * motion comp code, which is:

  2024.  *

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

  2026.  *

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

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

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

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

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

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

  2033.  *

  2034.  *      fxor            f0,   f2, f10

  2035.  *      fand            f10,  f4, f10

  2036.  *      fmul8x16        f8,  f10, f10

  2037.  *      fand            f10,  f6, f10

  2038.  *      fand            f0,   f2, f12

  2039.  *      fpadd16         f12, f10, f10

  2040.  */

  2041. 

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

  2043.                                       const int stride, int height)

  2044. {

  2045.         ref = vis_alignaddr(ref);

  2046.         do {    /* 5 cycles */

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

  2048. 

  2049.                 vis_ld64_2(ref, 8, TMP2);

  2050. 

  2051.                 vis_ld64_2(ref, 16, TMP4);

  2052.                 ref += stride;

  2053. 

  2054.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2056. 

  2057.                 vis_faligndata(TMP2, TMP4, REF_2);

  2058.                 vis_st64_2(REF_2, dest, 8);

  2059.                 dest += stride;

  2060.         } while (--height);

  2061. }

  2062. 

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

  2064.                             const int stride, int height)

  2065. {

  2066.         ref = vis_alignaddr(ref);

  2067.         do {    /* 4 cycles */

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

  2069. 

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

  2071.                 ref += stride;

  2072. 

  2073.                 /* stall */

  2074. 

  2075.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  2077.                 dest += stride;

  2078.         } while (--height);

  2079. }

  2080. 

  2081. 

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

  2083.                              const int stride, int height)

  2084. {

  2085.         int stride_8 = stride + 8;

  2086. 

  2087.         ref = vis_alignaddr(ref);

  2088. 

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

  2090. 

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

  2092. 

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

  2094. 

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

  2096. 

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

  2098. 

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

  2100.         vis_faligndata(TMP0, TMP2, REF_0);

  2101. 

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

  2103.         vis_faligndata(TMP2, TMP4, REF_2);

  2104. 

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

  2106. 

  2107.         ref += stride;

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

  2109. 

  2110.         do {    /* 24 cycles */

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

  2112.                 vis_xor(DST_0, REF_0, TMP6);

  2113. 

  2114.                 vis_ld64_2(ref, 8, TMP2);

  2115.                 vis_and(TMP6, MASK_fe, TMP6);

  2116. 

  2117.                 vis_ld64_2(ref, 16, TMP4);

  2118.                 ref += stride;

  2119.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2120.                 vis_xor(DST_2, REF_2, TMP8);

  2121. 

  2122.                 vis_and(TMP8, MASK_fe, TMP8);

  2123. 

  2124.                 vis_and(DST_0, REF_0, TMP10);

  2125.                 vis_ld64_2(dest, stride, DST_0);

  2126.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2127. 

  2128.                 vis_and(DST_2, REF_2, TMP12);

  2129.                 vis_ld64_2(dest, stride_8, DST_2);

  2130. 

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

  2132.                 vis_and(TMP6, MASK_7f, TMP6);

  2133. 

  2134.                 vis_and(TMP8, MASK_7f, TMP8);

  2135. 

  2136.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2138. 

  2139.                 vis_padd16(TMP12, TMP8, TMP8);

  2140.                 vis_st64_2(TMP8, dest, 8);

  2141. 

  2142.                 dest += stride;

  2143.                 vis_ld64_2(ref, 8, TMP16);

  2144.                 vis_faligndata(TMP0, TMP2, REF_0);

  2145. 

  2146.                 vis_ld64_2(ref, 16, TMP18);

  2147.                 vis_faligndata(TMP2, TMP4, REF_2);

  2148.                 ref += stride;

  2149. 

  2150.                 vis_xor(DST_0, REF_0, TMP20);

  2151. 

  2152.                 vis_and(TMP20, MASK_fe, TMP20);

  2153. 

  2154.                 vis_xor(DST_2, REF_2, TMP22);

  2155.                 vis_mul8x16(CONST_128, TMP20, TMP20);

  2156. 

  2157.                 vis_and(TMP22, MASK_fe, TMP22);

  2158. 

  2159.                 vis_and(DST_0, REF_0, TMP24);

  2160.                 vis_mul8x16(CONST_128, TMP22, TMP22);

  2161. 

  2162.                 vis_and(DST_2, REF_2, TMP26);

  2163. 

  2164.                 vis_ld64_2(dest, stride, DST_0);

  2165.                 vis_faligndata(TMP14, TMP16, REF_0);

  2166. 

  2167.                 vis_ld64_2(dest, stride_8, DST_2);

  2168.                 vis_faligndata(TMP16, TMP18, REF_2);

  2169. 

  2170.                 vis_and(TMP20, MASK_7f, TMP20);

  2171. 

  2172.                 vis_and(TMP22, MASK_7f, TMP22);

  2173. 

  2174.                 vis_padd16(TMP24, TMP20, TMP20);

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

  2176. 

  2177.                 vis_padd16(TMP26, TMP22, TMP22);

  2178.                 vis_st64_2(TMP22, dest, 8);

  2179.                 dest += stride;

  2180.         } while (--height);

  2181. 

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

  2183.         vis_xor(DST_0, REF_0, TMP6);

  2184. 

  2185.         vis_ld64_2(ref, 8, TMP2);

  2186.         vis_and(TMP6, MASK_fe, TMP6);

  2187. 

  2188.         vis_ld64_2(ref, 16, TMP4);

  2189.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2190.         vis_xor(DST_2, REF_2, TMP8);

  2191. 

  2192.         vis_and(TMP8, MASK_fe, TMP8);

  2193. 

  2194.         vis_and(DST_0, REF_0, TMP10);

  2195.         vis_ld64_2(dest, stride, DST_0);

  2196.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2197. 

  2198.         vis_and(DST_2, REF_2, TMP12);

  2199.         vis_ld64_2(dest, stride_8, DST_2);

  2200. 

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

  2202.         vis_and(TMP6, MASK_7f, TMP6);

  2203. 

  2204.         vis_and(TMP8, MASK_7f, TMP8);

  2205. 

  2206.         vis_padd16(TMP10, TMP6, TMP6);

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

  2208. 

  2209.         vis_padd16(TMP12, TMP8, TMP8);

  2210.         vis_st64_2(TMP8, dest, 8);

  2211. 

  2212.         dest += stride;

  2213.         vis_faligndata(TMP0, TMP2, REF_0);

  2214. 

  2215.         vis_faligndata(TMP2, TMP4, REF_2);

  2216. 

  2217.         vis_xor(DST_0, REF_0, TMP20);

  2218. 

  2219.         vis_and(TMP20, MASK_fe, TMP20);

  2220. 

  2221.         vis_xor(DST_2, REF_2, TMP22);

  2222.         vis_mul8x16(CONST_128, TMP20, TMP20);

  2223. 

  2224.         vis_and(TMP22, MASK_fe, TMP22);

  2225. 

  2226.         vis_and(DST_0, REF_0, TMP24);

  2227.         vis_mul8x16(CONST_128, TMP22, TMP22);

  2228. 

  2229.         vis_and(DST_2, REF_2, TMP26);

  2230. 

  2231.         vis_and(TMP20, MASK_7f, TMP20);

  2232. 

  2233.         vis_and(TMP22, MASK_7f, TMP22);

  2234. 

  2235.         vis_padd16(TMP24, TMP20, TMP20);

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

  2237. 

  2238.         vis_padd16(TMP26, TMP22, TMP22);

  2239.         vis_st64_2(TMP22, dest, 8);

  2240. }

  2241. 

  2242. static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * ref,

  2243.                             const int stride, int height)

  2244. {

  2245.         ref = vis_alignaddr(ref);

  2246. 

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

  2248. 

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

  2250. 

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

  2252. 

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

  2254. 

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

  2256.         vis_faligndata(TMP0, TMP2, REF_0);

  2257. 

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

  2259. 

  2260.         ref += stride;

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

  2262. 

  2263.         do {    /* 12 cycles */

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

  2265.                 vis_xor(DST_0, REF_0, TMP4);

  2266. 

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

  2268.                 vis_and(TMP4, MASK_fe, TMP4);

  2269. 

  2270.                 vis_and(DST_0, REF_0, TMP6);

  2271.                 vis_ld64_2(dest, stride, DST_0);

  2272.                 ref += stride;

  2273.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2274. 

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

  2276.                 vis_faligndata(TMP0, TMP2, REF_0);

  2277. 

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

  2279.                 vis_xor(DST_0, REF_0, TMP0);

  2280.                 ref += stride;

  2281. 

  2282.                 vis_and(TMP0, MASK_fe, TMP0);

  2283. 

  2284.                 vis_and(TMP4, MASK_7f, TMP4);

  2285. 

  2286.                 vis_padd16(TMP6, TMP4, TMP4);

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

  2288.                 dest += stride;

  2289.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  2290. 

  2291.                 vis_and(DST_0, REF_0, TMP6);

  2292.                 vis_ld64_2(dest, stride, DST_0);

  2293. 

  2294.                 vis_faligndata(TMP12, TMP2, REF_0);

  2295. 

  2296.                 vis_and(TMP0, MASK_7f, TMP0);

  2297. 

  2298.                 vis_padd16(TMP6, TMP0, TMP4);

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

  2300.                 dest += stride;

  2301.         } while (--height);

  2302. 

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

  2304.         vis_xor(DST_0, REF_0, TMP4);

  2305. 

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

  2307.         vis_and(TMP4, MASK_fe, TMP4);

  2308. 

  2309.         vis_and(DST_0, REF_0, TMP6);

  2310.         vis_ld64_2(dest, stride, DST_0);

  2311.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2312. 

  2313.         vis_faligndata(TMP0, TMP2, REF_0);

  2314. 

  2315.         vis_xor(DST_0, REF_0, TMP0);

  2316. 

  2317.         vis_and(TMP0, MASK_fe, TMP0);

  2318. 

  2319.         vis_and(TMP4, MASK_7f, TMP4);

  2320. 

  2321.         vis_padd16(TMP6, TMP4, TMP4);

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

  2323.         dest += stride;

  2324.         vis_mul8x16(CONST_128, TMP0, TMP0);

  2325. 

  2326.         vis_and(DST_0, REF_0, TMP6);

  2327. 

  2328.         vis_and(TMP0, MASK_7f, TMP0);

  2329. 

  2330.         vis_padd16(TMP6, TMP0, TMP4);

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

  2332. }

  2333. 

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

  2335.                              const int stride, int height)

  2336. {

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

  2338.         unsigned long off_plus_1 = off + 1;

  2339. 

  2340.         ref = vis_alignaddr(ref);

  2341. 

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

  2343. 

  2344.         vis_ld64_2(ref, 8,  TMP2);

  2345. 

  2346.         vis_ld64_2(ref, 16, TMP4);

  2347. 

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

  2349. 

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

  2351.         vis_faligndata(TMP0, TMP2, REF_0);

  2352. 

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

  2354.         vis_faligndata(TMP2, TMP4, REF_4);

  2355. 

  2356.         if (off != 0x7) {

  2357.                 vis_alignaddr_g0((void *)off_plus_1);

  2358.                 vis_faligndata(TMP0, TMP2, REF_2);

  2359.                 vis_faligndata(TMP2, TMP4, REF_6);

  2360.         } else {

  2361.                 vis_src1(TMP2, REF_2);

  2362.                 vis_src1(TMP4, REF_6);

  2363.         }

  2364. 

  2365.         ref += stride;

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

  2367. 

  2368.         do {    /* 34 cycles */

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

  2370.                 vis_xor(REF_0, REF_2, TMP6);

  2371. 

  2372.                 vis_ld64_2(ref, 8,  TMP2);

  2373.                 vis_xor(REF_4, REF_6, TMP8);

  2374. 

  2375.                 vis_ld64_2(ref, 16, TMP4);

  2376.                 vis_and(TMP6, MASK_fe, TMP6);

  2377.                 ref += stride;

  2378. 

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

  2380.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2381.                 vis_and(TMP8, MASK_fe, TMP8);

  2382. 

  2383.                 vis_ld64_2(ref, 8,  TMP16);

  2384.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2385.                 vis_and(REF_0, REF_2, TMP10);

  2386. 

  2387.                 vis_ld64_2(ref, 16, TMP18);

  2388.                 ref += stride;

  2389.                 vis_and(REF_4, REF_6, TMP12);

  2390. 

  2391.                 vis_alignaddr_g0((void *)off);

  2392. 

  2393.                 vis_faligndata(TMP0, TMP2, REF_0);

  2394. 

  2395.                 vis_faligndata(TMP2, TMP4, REF_4);

  2396. 

  2397.                 if (off != 0x7) {

  2398.                         vis_alignaddr_g0((void *)off_plus_1);

  2399.                         vis_faligndata(TMP0, TMP2, REF_2);

  2400.                         vis_faligndata(TMP2, TMP4, REF_6);

  2401.                 } else {

  2402.                         vis_src1(TMP2, REF_2);

  2403.                         vis_src1(TMP4, REF_6);

  2404.                 }

  2405. 

  2406.                 vis_and(TMP6, MASK_7f, TMP6);

  2407. 

  2408.                 vis_and(TMP8, MASK_7f, TMP8);

  2409. 

  2410.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2412. 

  2413.                 vis_padd16(TMP12, TMP8, TMP8);

  2414.                 vis_st64_2(TMP8, dest, 8);

  2415.                 dest += stride;

  2416. 

  2417.                 vis_xor(REF_0, REF_2, TMP6);

  2418. 

  2419.                 vis_xor(REF_4, REF_6, TMP8);

  2420. 

  2421.                 vis_and(TMP6, MASK_fe, TMP6);

  2422. 

  2423.                 vis_mul8x16(CONST_128, TMP6, TMP6);

  2424.                 vis_and(TMP8, MASK_fe, TMP8);

  2425. 

  2426.                 vis_mul8x16(CONST_128, TMP8, TMP8);

  2427.                 vis_and(REF_0, REF_2, TMP10);

  2428. 

  2429.                 vis_and(REF_4, REF_6, TMP12);

  2430. 

  2431.                 vis_alignaddr_g0((void *)off);

  2432. 

  2433.                 vis_faligndata(TMP14, TMP16, REF_0);

  2434. 

  2435.                 vis_faligndata(TMP16, TMP18, REF_4);

  2436. 

  2437.                 if (off != 0x7) {

  2438.                         vis_alignaddr_g0((void *)off_plus_1);

  2439.                         vis_faligndata(TMP14, TMP16, REF_2);

  2440.                         vis_faligndata(TMP16, TMP18, REF_6);

  2441.                 } else {

  2442.                         vis_src1(TMP16, REF_2);

  2443.                         vis_src1(TMP18, REF_6);

  2444.                 }

  2445. 

  2446.                 vis_and(TMP6, MASK_7f, TMP6);

  2447. 

  2448.                 vis_and(TMP8, MASK_7f, TMP8);

  2449. 

  2450.                 vis_padd16(TMP10, TMP6, TMP6);

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

  2452. 

  2453.                 vis_padd16(TMP12, TMP8, TMP8);

  2454.                 vis_st64_2(TMP8, dest, 8);

  2455.                 dest += stride;

  2456.         } while (--height);

  2457. 

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

  2459.         vis_xor(REF_0, REF_2, TMP6);

  2460. 

  2461.         vis_ld64_2(ref, 8,  TMP2);

  2462.         vis_xor(REF_4, REF_6, TMP8);

  2463. 

  2464.         vis_ld64_2(ref, 16, TMP4);

  2465.         vis_and(TMP6, MASK_fe, TMP6);

  2466. 

  2467.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2468.         vis_and(TMP8, MASK_fe, TMP8);

  2469. 

  2470.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2471.         vis_and(REF_0, REF_2, TMP10);

  2472. 

  2473.         vis_and(REF_4, REF_6, TMP12);

  2474. 

  2475.         vis_alignaddr_g0((void *)off);

  2476. 

  2477.         vis_faligndata(TMP0, TMP2, REF_0);

  2478. 

  2479.         vis_faligndata(TMP2, TMP4, REF_4);

  2480. 

  2481.         if (off != 0x7) {

  2482.                 vis_alignaddr_g0((void *)off_plus_1);

  2483.                 vis_faligndata(TMP0, TMP2, REF_2);

  2484.                 vis_faligndata(TMP2, TMP4, REF_6);

  2485.         } else {

  2486.                 vis_src1(TMP2, REF_2);

  2487.                 vis_src1(TMP4, REF_6);

  2488.         }

  2489. 

  2490.         vis_and(TMP6, MASK_7f, TMP6);

  2491. 

  2492.         vis_and(TMP8, MASK_7f, TMP8);

  2493. 

  2494.         vis_padd16(TMP10, TMP6, TMP6);

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

  2496. 

  2497.         vis_padd16(TMP12, TMP8, TMP8);

  2498.         vis_st64_2(TMP8, dest, 8);

  2499.         dest += stride;

  2500. 

  2501.         vis_xor(REF_0, REF_2, TMP6);

  2502. 

  2503.         vis_xor(REF_4, REF_6, TMP8);

  2504. 

  2505.         vis_and(TMP6, MASK_fe, TMP6);

  2506. 

  2507.         vis_mul8x16(CONST_128, TMP6, TMP6);

  2508.         vis_and(TMP8, MASK_fe, TMP8);

  2509. 

  2510.         vis_mul8x16(CONST_128, TMP8, TMP8);

  2511.         vis_and(REF_0, REF_2, TMP10);

  2512. 

  2513.         vis_and(REF_4, REF_6, TMP12);

  2514. 

  2515.         vis_and(TMP6, MASK_7f, TMP6);

  2516. 

  2517.         vis_and(TMP8, MASK_7f, TMP8);

  2518. 

  2519.         vis_padd16(TMP10, TMP6, TMP6);

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

  2521. 

  2522.         vis_padd16(TMP12, TMP8, TMP8);

  2523.         vis_st64_2(TMP8, dest, 8);

  2524. }

  2525. 

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

  2527.                             const int stride, int height)

  2528. {

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

  2530.         unsigned long off_plus_1 = off + 1;

  2531. 

  2532.         ref = vis_alignaddr(ref);

  2533. 

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

  2535. 

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

  2537. 

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

  2539. 

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

  2541. 

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

  2543.         vis_faligndata(TMP0, TMP2, REF_0);

  2544. 

  2545.         if (off != 0x7) {

  2546.                 vis_alignaddr_g0((void *)off_plus_1);

  2547.                 vis_faligndata(TMP0, TMP2, REF_2);

  2548.         } else {

  2549.                 vis_src1(TMP2, REF_2);

  2550.         }

  2551. 

  2552.         ref += stride;

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

  2554. 

  2555.         do {    /* 20 cycles */

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

  2557.                 vis_xor(REF_0, REF_2, TMP4);

  2558. 

  2559.                 vis_ld64_2(ref, 8, TMP2);

  2560.                 vis_and(TMP4, MASK_fe, TMP4);

  2561.                 ref += stride;

  2562. 

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

  2564.                 vis_and(REF_0, REF_2, TMP6);

  2565.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  2566. 

  2567.                 vis_alignaddr_g0((void *)off);

  2568. 

  2569.                 vis_ld64_2(ref, 8, TMP10);

  2570.                 ref += stride;

  2571.                 vis_faligndata(TMP0, TMP2, REF_0);

  2572. 

  2573.                 if (off != 0x7) {

  2574.                         vis_alignaddr_g0((void *)off_plus_1);

  2575.                         vis_faligndata(TMP0, TMP2, REF_2);

  2576.                 } else {

  2577.                         vis_src1(TMP2, REF_2);

  2578.                 }

  2579. 

  2580.                 vis_and(TMP4, MASK_7f, TMP4);

  2581. 

  2582.                 vis_padd16(TMP6, TMP4, DST_0);

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

  2584.                 dest += stride;

  2585. 

  2586.                 vis_xor(REF_0, REF_2, TMP12);

  2587. 

  2588.                 vis_and(TMP12, MASK_fe, TMP12);

  2589. 

  2590.                 vis_and(REF_0, REF_2, TMP14);

  2591.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2592. 

  2593.                 vis_alignaddr_g0((void *)off);

  2594.                 vis_faligndata(TMP8, TMP10, REF_0);

  2595.                 if (off != 0x7) {

  2596.                         vis_alignaddr_g0((void *)off_plus_1);

  2597.                         vis_faligndata(TMP8, TMP10, REF_2);

  2598.                 } else {

  2599.                         vis_src1(TMP10, REF_2);

  2600.                 }

  2601. 

  2602.                 vis_and(TMP12, MASK_7f, TMP12);

  2603. 

  2604.                 vis_padd16(TMP14, TMP12, DST_0);

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

  2606.                 dest += stride;

  2607.         } while (--height);

  2608. 

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

  2610.         vis_xor(REF_0, REF_2, TMP4);

  2611. 

  2612.         vis_ld64_2(ref, 8, TMP2);

  2613.         vis_and(TMP4, MASK_fe, TMP4);

  2614. 

  2615.         vis_and(REF_0, REF_2, TMP6);

  2616.         vis_mul8x16(CONST_128, TMP4, TMP4);

  2617. 

  2618.         vis_alignaddr_g0((void *)off);

  2619. 

  2620.         vis_faligndata(TMP0, TMP2, REF_0);

  2621. 

  2622.         if (off != 0x7) {

  2623.                 vis_alignaddr_g0((void *)off_plus_1);

  2624.                 vis_faligndata(TMP0, TMP2, REF_2);

  2625.         } else {

  2626.                 vis_src1(TMP2, REF_2);

  2627.         }

  2628. 

  2629.         vis_and(TMP4, MASK_7f, TMP4);

  2630. 

  2631.         vis_padd16(TMP6, TMP4, DST_0);

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

  2633.         dest += stride;

  2634. 

  2635.         vis_xor(REF_0, REF_2, TMP12);

  2636. 

  2637.         vis_and(TMP12, MASK_fe, TMP12);

  2638. 

  2639.         vis_and(REF_0, REF_2, TMP14);

  2640.         vis_mul8x16(CONST_128, TMP12, TMP12);

  2641. 

  2642.         vis_and(TMP12, MASK_7f, TMP12);

  2643. 

  2644.         vis_padd16(TMP14, TMP12, DST_0);

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

  2646.         dest += stride;

  2647. }

  2648. 

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

  2650.                              const int stride, int height)

  2651. {

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

  2653.         unsigned long off_plus_1 = off + 1;

  2654. 

  2655.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2656. 

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

  2658.         vis_fzero(ZERO);

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

  2660. 

  2661.         ref = vis_alignaddr(ref);

  2662.         do {    /* 26 cycles */

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

  2664. 

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

  2666. 

  2667.                 vis_alignaddr_g0((void *)off);

  2668. 

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

  2670. 

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

  2672.                 vis_faligndata(TMP0, TMP2, REF_0);

  2673. 

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

  2675.                 vis_faligndata(TMP2, TMP4, REF_4);

  2676. 

  2677.                 if (off != 0x7) {

  2678.                         vis_alignaddr_g0((void *)off_plus_1);

  2679.                         vis_faligndata(TMP0, TMP2, REF_2);

  2680.                         vis_faligndata(TMP2, TMP4, REF_6);

  2681.                 } else {

  2682.                         vis_src1(TMP2, REF_2);

  2683.                         vis_src1(TMP4, REF_6);

  2684.                 }

  2685. 

  2686.                 vis_mul8x16au(REF_0,   CONST_256, TMP0);

  2687. 

  2688.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2689.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2690. 

  2691.                 vis_pmerge(ZERO, REF_2_1, TMP6);

  2692. 

  2693.                 vis_padd16(TMP0, TMP4, TMP0);

  2694. 

  2695.                 vis_mul8x16al(DST_0,   CONST_512, TMP4);

  2696.                 vis_padd16(TMP2, TMP6, TMP2);

  2697. 

  2698.                 vis_mul8x16al(DST_1,   CONST_512, TMP6);

  2699. 

  2700.                 vis_mul8x16au(REF_6,   CONST_256, TMP12);

  2701. 

  2702.                 vis_padd16(TMP0, TMP4, TMP0);

  2703.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2704. 

  2705.                 vis_padd16(TMP2, TMP6, TMP2);

  2706.                 vis_mul8x16au(REF_4,   CONST_256, TMP16);

  2707. 

  2708.                 vis_padd16(TMP0, CONST_3, TMP8);

  2709.                 vis_mul8x16au(REF_4_1, CONST_256, TMP18);

  2710. 

  2711.                 vis_padd16(TMP2, CONST_3, TMP10);

  2712.                 vis_pack16(TMP8, DST_0);

  2713. 

  2714.                 vis_pack16(TMP10, DST_1);

  2715.                 vis_padd16(TMP16, TMP12, TMP0);

  2716. 

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

  2718.                 vis_mul8x16al(DST_2,   CONST_512, TMP4);

  2719.                 vis_padd16(TMP18, TMP14, TMP2);

  2720. 

  2721.                 vis_mul8x16al(DST_3,   CONST_512, TMP6);

  2722.                 vis_padd16(TMP0, CONST_3, TMP0);

  2723. 

  2724.                 vis_padd16(TMP2, CONST_3, TMP2);

  2725. 

  2726.                 vis_padd16(TMP0, TMP4, TMP0);

  2727. 

  2728.                 vis_padd16(TMP2, TMP6, TMP2);

  2729.                 vis_pack16(TMP0, DST_2);

  2730. 

  2731.                 vis_pack16(TMP2, DST_3);

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

  2733. 

  2734.                 ref += stride;

  2735.                 dest += stride;

  2736.         } while (--height);

  2737. }

  2738. 

  2739. static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * ref,

  2740.                             const int stride, int height)

  2741. {

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

  2743.         unsigned long off_plus_1 = off + 1;

  2744.         int stride_times_2 = stride << 1;

  2745. 

  2746.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  2747. 

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

  2749.         vis_fzero(ZERO);

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

  2751. 

  2752.         ref = vis_alignaddr(ref);

  2753.         height >>= 2;

  2754.         do {    /* 47 cycles */

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

  2756. 

  2757.                 vis_ld64_2(ref, 8, TMP2);

  2758.                 ref += stride;

  2759. 

  2760.                 vis_alignaddr_g0((void *)off);

  2761. 

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

  2763.                 vis_faligndata(TMP0, TMP2, REF_0);

  2764. 

  2765.                 vis_ld64_2(ref, 8, TMP6);

  2766.                 ref += stride;

  2767. 

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

  2769. 

  2770.                 vis_ld64_2(ref, 8, TMP10);

  2771.                 ref += stride;

  2772.                 vis_faligndata(TMP4, TMP6, REF_4);

  2773. 

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

  2775. 

  2776.                 vis_ld64_2(ref, 8, TMP14);

  2777.                 ref += stride;

  2778.                 vis_faligndata(TMP8, TMP10, REF_S0);

  2779. 

  2780.                 vis_faligndata(TMP12, TMP14, REF_S4);

  2781. 

  2782.                 if (off != 0x7) {

  2783.                         vis_alignaddr_g0((void *)off_plus_1);

  2784. 

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

  2786.                         vis_faligndata(TMP0, TMP2, REF_2);

  2787. 

  2788.                         vis_ld64_2(dest, stride, DST_2);

  2789.                         vis_faligndata(TMP4, TMP6, REF_6);

  2790. 

  2791.                         vis_faligndata(TMP8, TMP10, REF_S2);

  2792. 

  2793.                         vis_faligndata(TMP12, TMP14, REF_S6);

  2794.                 } else {

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

  2796.                         vis_src1(TMP2, REF_2);

  2797. 

  2798.                         vis_ld64_2(dest, stride, DST_2);

  2799.                         vis_src1(TMP6, REF_6);

  2800. 

  2801.                         vis_src1(TMP10, REF_S2);

  2802. 

  2803.                         vis_src1(TMP14, REF_S6);

  2804.                 }

  2805. 

  2806.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  2807.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  2808. 

  2809.                 vis_pmerge(ZERO,     REF_2,     TMP4);

  2810.                 vis_mul8x16au(REF_2_1, CONST_256, TMP6);

  2811. 

  2812.                 vis_padd16(TMP0, CONST_3, TMP0);

  2813.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  2814. 

  2815.                 vis_padd16(TMP2, CONST_3, TMP2);

  2816.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  2817. 

  2818.                 vis_padd16(TMP0, TMP4, TMP0);

  2819.                 vis_mul8x16au(REF_4, CONST_256, TMP8);

  2820. 

  2821.                 vis_padd16(TMP2, TMP6, TMP2);

  2822.                 vis_mul8x16au(REF_4_1, CONST_256, TMP10);

  2823. 

  2824.                 vis_padd16(TMP0, TMP16, TMP0);

  2825.                 vis_mul8x16au(REF_6, CONST_256, TMP12);

  2826. 

  2827.                 vis_padd16(TMP2, TMP18, TMP2);

  2828.                 vis_mul8x16au(REF_6_1, CONST_256, TMP14);

  2829. 

  2830.                 vis_padd16(TMP8, CONST_3, TMP8);

  2831.                 vis_mul8x16al(DST_2, CONST_512, TMP16);

  2832. 

  2833.                 vis_padd16(TMP8, TMP12, TMP8);

  2834.                 vis_mul8x16al(DST_3, CONST_512, TMP18);

  2835. 

  2836.                 vis_padd16(TMP10, TMP14, TMP10);

  2837.                 vis_pack16(TMP0, DST_0);

  2838. 

  2839.                 vis_pack16(TMP2, DST_1);

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

  2841.                 dest += stride;

  2842.                 vis_padd16(TMP10, CONST_3, TMP10);

  2843. 

  2844.                 vis_ld64_2(dest, stride, DST_0);

  2845.                 vis_padd16(TMP8, TMP16, TMP8);

  2846. 

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

  2848.                 vis_padd16(TMP10, TMP18, TMP10);

  2849.                 vis_pack16(TMP8, DST_2);

  2850. 

  2851.                 vis_pack16(TMP10, DST_3);

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

  2853.                 dest += stride;

  2854. 

  2855.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  2856.                 vis_pmerge(ZERO,     REF_S0,     TMP0);

  2857. 

  2858.                 vis_pmerge(ZERO,     REF_S2,     TMP24);

  2859.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  2860. 

  2861.                 vis_padd16(TMP0, CONST_3, TMP0);

  2862.                 vis_mul8x16au(REF_S4, CONST_256, TMP8);

  2863. 

  2864.                 vis_padd16(TMP2, CONST_3, TMP2);

  2865.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

  2866. 

  2867.                 vis_padd16(TMP0, TMP24, TMP0);

  2868.                 vis_mul8x16au(REF_S6, CONST_256, TMP12);

  2869. 

  2870.                 vis_padd16(TMP2, TMP6, TMP2);

  2871.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

  2872. 

  2873.                 vis_padd16(TMP8, CONST_3, TMP8);

  2874.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  2875. 

  2876.                 vis_padd16(TMP10, CONST_3, TMP10);

  2877.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  2878. 

  2879.                 vis_padd16(TMP8, TMP12, TMP8);

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

  2881. 

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

  2883.                 vis_padd16(TMP0, TMP16, TMP0);

  2884. 

  2885.                 vis_padd16(TMP2, TMP18, TMP2);

  2886.                 vis_pack16(TMP0, DST_0);

  2887. 

  2888.                 vis_padd16(TMP10, TMP14, TMP10);

  2889.                 vis_pack16(TMP2, DST_1);

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

  2891.                 dest += stride;

  2892. 

  2893.                 vis_padd16(TMP8, TMP20, TMP8);

  2894. 

  2895.                 vis_padd16(TMP10, TMP22, TMP10);

  2896.                 vis_pack16(TMP8, DST_2);

  2897. 

  2898.                 vis_pack16(TMP10, DST_3);

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

  2900.                 dest += stride;

  2901.         } while (--height);

  2902. }

  2903. 

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

  2905.                              const int stride, int height)

  2906. {

  2907.         ref = vis_alignaddr(ref);

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

  2909. 

  2910.         vis_ld64_2(ref, 8, TMP2);

  2911. 

  2912.         vis_ld64_2(ref, 16, TMP4);

  2913.         ref += stride;

  2914. 

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

  2916.         vis_faligndata(TMP0, TMP2, REF_0);

  2917. 

  2918.         vis_ld64_2(ref, 8, TMP8);

  2919.         vis_faligndata(TMP2, TMP4, REF_4);

  2920. 

  2921.         vis_ld64_2(ref, 16, TMP10);

  2922.         ref += stride;

  2923. 

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

  2925.         vis_faligndata(TMP6, TMP8, REF_2);

  2926. 

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

  2928.         vis_faligndata(TMP8, TMP10, REF_6);

  2929. 

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

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

  2932.         do {    /* 24 cycles */

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

  2934.                 vis_xor(REF_0, REF_2, TMP12);

  2935. 

  2936.                 vis_ld64_2(ref, 8, TMP2);

  2937.                 vis_xor(REF_4, REF_6, TMP16);

  2938. 

  2939.                 vis_ld64_2(ref, 16, TMP4);

  2940.                 ref += stride;

  2941.                 vis_and(REF_0, REF_2, TMP14);

  2942. 

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

  2944.                 vis_and(REF_4, REF_6, TMP18);

  2945. 

  2946.                 vis_ld64_2(ref, 8, TMP8);

  2947.                 vis_faligndata(TMP0, TMP2, REF_0);

  2948. 

  2949.                 vis_ld64_2(ref, 16, TMP10);

  2950.                 ref += stride;

  2951.                 vis_faligndata(TMP2, TMP4, REF_4);

  2952. 

  2953.                 vis_and(TMP12, MASK_fe, TMP12);

  2954. 

  2955.                 vis_and(TMP16, MASK_fe, TMP16);

  2956.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  2957. 

  2958.                 vis_mul8x16(CONST_128, TMP16, TMP16);

  2959.                 vis_xor(REF_0, REF_2, TMP0);

  2960. 

  2961.                 vis_xor(REF_4, REF_6, TMP2);

  2962. 

  2963.                 vis_and(REF_0, REF_2, TMP20);

  2964. 

  2965.                 vis_and(TMP12, MASK_7f, TMP12);

  2966. 

  2967.                 vis_and(TMP16, MASK_7f, TMP16);

  2968. 

  2969.                 vis_padd16(TMP14, TMP12, TMP12);

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

  2971. 

  2972.                 vis_padd16(TMP18, TMP16, TMP16);

  2973.                 vis_st64_2(TMP16, dest, 8);

  2974.                 dest += stride;

  2975. 

  2976.                 vis_and(REF_4, REF_6, TMP18);

  2977. 

  2978.                 vis_and(TMP0, MASK_fe, TMP0);

  2979. 

  2980.                 vis_and(TMP2, MASK_fe, TMP2);

  2981.                 vis_mul8x16(CONST_128, TMP0, TMP0);

  2982. 

  2983.                 vis_faligndata(TMP6, TMP8, REF_2);

  2984.                 vis_mul8x16(CONST_128, TMP2, TMP2);

  2985. 

  2986.                 vis_faligndata(TMP8, TMP10, REF_6);

  2987. 

  2988.                 vis_and(TMP0, MASK_7f, TMP0);

  2989. 

  2990.                 vis_and(TMP2, MASK_7f, TMP2);

  2991. 

  2992.                 vis_padd16(TMP20, TMP0, TMP0);

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

  2994. 

  2995.                 vis_padd16(TMP18, TMP2, TMP2);

  2996.                 vis_st64_2(TMP2, dest, 8);

  2997.                 dest += stride;

  2998.         } while (--height);

  2999. 

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

  3001.         vis_xor(REF_0, REF_2, TMP12);

  3002. 

  3003.         vis_ld64_2(ref, 8, TMP2);

  3004.         vis_xor(REF_4, REF_6, TMP16);

  3005. 

  3006.         vis_ld64_2(ref, 16, TMP4);

  3007.         vis_and(REF_0, REF_2, TMP14);

  3008. 

  3009.         vis_and(REF_4, REF_6, TMP18);

  3010. 

  3011.         vis_faligndata(TMP0, TMP2, REF_0);

  3012. 

  3013.         vis_faligndata(TMP2, TMP4, REF_4);

  3014. 

  3015.         vis_and(TMP12, MASK_fe, TMP12);

  3016. 

  3017.         vis_and(TMP16, MASK_fe, TMP16);

  3018.         vis_mul8x16(CONST_128, TMP12, TMP12);

  3019. 

  3020.         vis_mul8x16(CONST_128, TMP16, TMP16);

  3021.         vis_xor(REF_0, REF_2, TMP0);

  3022. 

  3023.         vis_xor(REF_4, REF_6, TMP2);

  3024. 

  3025.         vis_and(REF_0, REF_2, TMP20);

  3026. 

  3027.         vis_and(TMP12, MASK_7f, TMP12);

  3028. 

  3029.         vis_and(TMP16, MASK_7f, TMP16);

  3030. 

  3031.         vis_padd16(TMP14, TMP12, TMP12);

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

  3033. 

  3034.         vis_padd16(TMP18, TMP16, TMP16);

  3035.         vis_st64_2(TMP16, dest, 8);

  3036.         dest += stride;

  3037. 

  3038.         vis_and(REF_4, REF_6, TMP18);

  3039. 

  3040.         vis_and(TMP0, MASK_fe, TMP0);

  3041. 

  3042.         vis_and(TMP2, MASK_fe, TMP2);

  3043.         vis_mul8x16(CONST_128, TMP0, TMP0);

  3044. 

  3045.         vis_mul8x16(CONST_128, TMP2, TMP2);

  3046. 

  3047.         vis_and(TMP0, MASK_7f, TMP0);

  3048. 

  3049.         vis_and(TMP2, MASK_7f, TMP2);

  3050. 

  3051.         vis_padd16(TMP20, TMP0, TMP0);

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

  3053. 

  3054.         vis_padd16(TMP18, TMP2, TMP2);

  3055.         vis_st64_2(TMP2, dest, 8);

  3056. }

  3057. 

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

  3059.                             const int stride, int height)

  3060. {

  3061.         ref = vis_alignaddr(ref);

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

  3063. 

  3064.         vis_ld64_2(ref, 8, TMP2);

  3065.         ref += stride;

  3066. 

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

  3068. 

  3069.         vis_ld64_2(ref, 8, TMP6);

  3070.         ref += stride;

  3071. 

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

  3073.         vis_faligndata(TMP0, TMP2, REF_0);

  3074. 

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

  3076.         vis_faligndata(TMP4, TMP6, REF_2);

  3077. 

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

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

  3080.         do {    /* 12 cycles */

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

  3082.                 vis_xor(REF_0, REF_2, TMP4);

  3083. 

  3084.                 vis_ld64_2(ref, 8, TMP2);

  3085.                 ref += stride;

  3086.                 vis_and(TMP4, MASK_fe, TMP4);

  3087. 

  3088.                 vis_and(REF_0, REF_2, TMP6);

  3089.                 vis_mul8x16(CONST_128, TMP4, TMP4);

  3090. 

  3091.                 vis_faligndata(TMP0, TMP2, REF_0);

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

  3093. 

  3094.                 vis_ld64_2(ref, 8, TMP2);

  3095.                 ref += stride;

  3096.                 vis_xor(REF_0, REF_2, TMP12);

  3097. 

  3098.                 vis_and(TMP4, MASK_7f, TMP4);

  3099. 

  3100.                 vis_and(TMP12, MASK_fe, TMP12);

  3101. 

  3102.                 vis_mul8x16(CONST_128, TMP12, TMP12);

  3103.                 vis_and(REF_0, REF_2, TMP14);

  3104. 

  3105.                 vis_padd16(TMP6, TMP4, DST_0);

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

  3107.                 dest += stride;

  3108. 

  3109.                 vis_faligndata(TMP0, TMP2, REF_2);

  3110. 

  3111.                 vis_and(TMP12, MASK_7f, TMP12);

  3112. 

  3113.                 vis_padd16(TMP14, TMP12, DST_0);

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

  3115.                 dest += stride;

  3116.         } while (--height);

  3117. 

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

  3119.         vis_xor(REF_0, REF_2, TMP4);

  3120. 

  3121.         vis_ld64_2(ref, 8, TMP2);

  3122.         vis_and(TMP4, MASK_fe, TMP4);

  3123. 

  3124.         vis_and(REF_0, REF_2, TMP6);

  3125.         vis_mul8x16(CONST_128, TMP4, TMP4);

  3126. 

  3127.         vis_faligndata(TMP0, TMP2, REF_0);

  3128. 

  3129.         vis_xor(REF_0, REF_2, TMP12);

  3130. 

  3131.         vis_and(TMP4, MASK_7f, TMP4);

  3132. 

  3133.         vis_and(TMP12, MASK_fe, TMP12);

  3134. 

  3135.         vis_mul8x16(CONST_128, TMP12, TMP12);

  3136.         vis_and(REF_0, REF_2, TMP14);

  3137. 

  3138.         vis_padd16(TMP6, TMP4, DST_0);

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

  3140.         dest += stride;

  3141. 

  3142.         vis_and(TMP12, MASK_7f, TMP12);

  3143. 

  3144.         vis_padd16(TMP14, TMP12, DST_0);

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

  3146. }

  3147. 

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

  3149.                              const int stride, int height)

  3150. {

  3151.         int stride_8 = stride + 8;

  3152.         int stride_16 = stride + 16;

  3153. 

  3154.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3155. 

  3156.         ref = vis_alignaddr(ref);

  3157. 

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

  3159.         vis_fzero(ZERO);

  3160. 

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

  3162. 

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

  3164. 

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

  3166.         vis_faligndata(TMP0, TMP2, REF_2);

  3167. 

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

  3169.         vis_faligndata(TMP2, TMP4, REF_6);

  3170.         height >>= 1;

  3171. 

  3172.         do {    /* 31 cycles */

  3173.                 vis_ld64_2(ref, stride, TMP0);

  3174.                 vis_pmerge(ZERO,       REF_2,     TMP12);

  3175.                 vis_mul8x16au(REF_2_1, CONST_256, TMP14);

  3176. 

  3177.                 vis_ld64_2(ref, stride_8, TMP2);

  3178.                 vis_pmerge(ZERO,       REF_6,     TMP16);

  3179.                 vis_mul8x16au(REF_6_1, CONST_256, TMP18);

  3180. 

  3181.                 vis_ld64_2(ref, stride_16, TMP4);

  3182.                 ref += stride;

  3183. 

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

  3185.                 vis_faligndata(TMP0, TMP2, REF_0);

  3186. 

  3187.                 vis_ld64_2(dest, 8, DST_2);

  3188.                 vis_faligndata(TMP2, TMP4, REF_4);

  3189. 

  3190.                 vis_ld64_2(ref, stride, TMP6);

  3191.                 vis_pmerge(ZERO,     REF_0,     TMP0);

  3192.                 vis_mul8x16au(REF_0_1, CONST_256, TMP2);

  3193. 

  3194.                 vis_ld64_2(ref, stride_8, TMP8);

  3195.                 vis_pmerge(ZERO,     REF_4,     TMP4);

  3196. 

  3197.                 vis_ld64_2(ref, stride_16, TMP10);

  3198.                 ref += stride;

  3199. 

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

  3201.                 vis_faligndata(TMP6, TMP8, REF_2);

  3202.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3203. 

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

  3205.                 vis_faligndata(TMP8, TMP10, REF_6);

  3206.                 vis_mul8x16al(DST_0,   CONST_512, TMP20);

  3207. 

  3208.                 vis_padd16(TMP0, CONST_3, TMP0);

  3209.                 vis_mul8x16al(DST_1,   CONST_512, TMP22);

  3210. 

  3211.                 vis_padd16(TMP2, CONST_3, TMP2);

  3212.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  3213. 

  3214.                 vis_padd16(TMP4, CONST_3, TMP4);

  3215.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  3216. 

  3217.                 vis_padd16(TMP6, CONST_3, TMP6);

  3218. 

  3219.                 vis_padd16(TMP12, TMP20, TMP12);

  3220.                 vis_mul8x16al(REF_S0,   CONST_512, TMP20);

  3221. 

  3222.                 vis_padd16(TMP14, TMP22, TMP14);

  3223.                 vis_mul8x16al(REF_S0_1, CONST_512, TMP22);

  3224. 

  3225.                 vis_padd16(TMP16, TMP24, TMP16);

  3226.                 vis_mul8x16al(REF_S2,   CONST_512, TMP24);

  3227. 

  3228.                 vis_padd16(TMP18, TMP26, TMP18);

  3229.                 vis_mul8x16al(REF_S2_1, CONST_512, TMP26);

  3230. 

  3231.                 vis_padd16(TMP12, TMP0, TMP12);

  3232.                 vis_mul8x16au(REF_2,   CONST_256, TMP28);

  3233. 

  3234.                 vis_padd16(TMP14, TMP2, TMP14);

  3235.                 vis_mul8x16au(REF_2_1, CONST_256, TMP30);

  3236. 

  3237.                 vis_padd16(TMP16, TMP4, TMP16);

  3238.                 vis_mul8x16au(REF_6,   CONST_256, REF_S4);

  3239. 

  3240.                 vis_padd16(TMP18, TMP6, TMP18);

  3241.                 vis_mul8x16au(REF_6_1, CONST_256, REF_S6);

  3242. 

  3243.                 vis_pack16(TMP12, DST_0);

  3244.                 vis_padd16(TMP28, TMP0, TMP12);

  3245. 

  3246.                 vis_pack16(TMP14, DST_1);

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

  3248.                 vis_padd16(TMP30, TMP2, TMP14);

  3249. 

  3250.                 vis_pack16(TMP16, DST_2);

  3251.                 vis_padd16(REF_S4, TMP4, TMP16);

  3252. 

  3253.                 vis_pack16(TMP18, DST_3);

  3254.                 vis_st64_2(DST_2, dest, 8);

  3255.                 dest += stride;

  3256.                 vis_padd16(REF_S6, TMP6, TMP18);

  3257. 

  3258.                 vis_padd16(TMP12, TMP20, TMP12);

  3259. 

  3260.                 vis_padd16(TMP14, TMP22, TMP14);

  3261.                 vis_pack16(TMP12, DST_0);

  3262. 

  3263.                 vis_padd16(TMP16, TMP24, TMP16);

  3264.                 vis_pack16(TMP14, DST_1);

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

  3266. 

  3267.                 vis_padd16(TMP18, TMP26, TMP18);

  3268.                 vis_pack16(TMP16, DST_2);

  3269. 

  3270.                 vis_pack16(TMP18, DST_3);

  3271.                 vis_st64_2(DST_2, dest, 8);

  3272.                 dest += stride;

  3273.         } while (--height);

  3274. }

  3275. 

  3276. static void MC_avg_no_round_y_8_vis (uint8_t * dest, const uint8_t * ref,

  3277.                             const int stride, int height)

  3278. {

  3279.         int stride_8 = stride + 8;

  3280. 

  3281.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3282. 

  3283.         ref = vis_alignaddr(ref);

  3284. 

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

  3286.         vis_fzero(ZERO);

  3287. 

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

  3289. 

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

  3291.         vis_faligndata(TMP0, TMP2, REF_2);

  3292. 

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

  3294. 

  3295.         height >>= 1;

  3296.         do {    /* 20 cycles */

  3297.                 vis_ld64_2(ref, stride, TMP0);

  3298.                 vis_pmerge(ZERO,       REF_2,     TMP8);

  3299.                 vis_mul8x16au(REF_2_1, CONST_256, TMP10);

  3300. 

  3301.                 vis_ld64_2(ref, stride_8, TMP2);

  3302.                 ref += stride;

  3303. 

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

  3305. 

  3306.                 vis_ld64_2(dest, stride, DST_2);

  3307.                 vis_faligndata(TMP0, TMP2, REF_0);

  3308. 

  3309.                 vis_ld64_2(ref, stride, TMP4);

  3310.                 vis_mul8x16al(DST_0,   CONST_512, TMP16);

  3311.                 vis_pmerge(ZERO,       REF_0,     TMP12);

  3312. 

  3313.                 vis_ld64_2(ref, stride_8, TMP6);

  3314.                 ref += stride;

  3315.                 vis_mul8x16al(DST_1,   CONST_512, TMP18);

  3316.                 vis_pmerge(ZERO,       REF_0_1,   TMP14);

  3317. 

  3318.                 vis_padd16(TMP12, CONST_3, TMP12);

  3319.                 vis_mul8x16al(DST_2,   CONST_512, TMP24);

  3320. 

  3321.                 vis_padd16(TMP14, CONST_3, TMP14);

  3322.                 vis_mul8x16al(DST_3,   CONST_512, TMP26);

  3323. 

  3324.                 vis_faligndata(TMP4, TMP6, REF_2);

  3325. 

  3326.                 vis_padd16(TMP8, TMP12, TMP8);

  3327. 

  3328.                 vis_padd16(TMP10, TMP14, TMP10);

  3329.                 vis_mul8x16au(REF_2,   CONST_256, TMP20);

  3330. 

  3331.                 vis_padd16(TMP8, TMP16, TMP0);

  3332.                 vis_mul8x16au(REF_2_1, CONST_256, TMP22);

  3333. 

  3334.                 vis_padd16(TMP10, TMP18, TMP2);

  3335.                 vis_pack16(TMP0, DST_0);

  3336. 

  3337.                 vis_pack16(TMP2, DST_1);

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

  3339.                 dest += stride;

  3340.                 vis_padd16(TMP12, TMP20, TMP12);

  3341. 

  3342.                 vis_padd16(TMP14, TMP22, TMP14);

  3343. 

  3344.                 vis_padd16(TMP12, TMP24, TMP0);

  3345. 

  3346.                 vis_padd16(TMP14, TMP26, TMP2);

  3347.                 vis_pack16(TMP0, DST_2);

  3348. 

  3349.                 vis_pack16(TMP2, DST_3);

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

  3351.                 dest += stride;

  3352.         } while (--height);

  3353. }

  3354. 

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

  3356.                                        const int stride, int height)

  3357. {

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

  3359.         unsigned long off_plus_1 = off + 1;

  3360.         int stride_8 = stride + 8;

  3361.         int stride_16 = stride + 16;

  3362. 

  3363.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3364. 

  3365.         ref = vis_alignaddr(ref);

  3366. 

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

  3368.         vis_fzero(ZERO);

  3369. 

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

  3371. 

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

  3373. 

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

  3375.         vis_faligndata(TMP0, TMP2, REF_S0);

  3376. 

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

  3378.         vis_faligndata(TMP2, TMP4, REF_S4);

  3379. 

  3380.         if (off != 0x7) {

  3381.                 vis_alignaddr_g0((void *)off_plus_1);

  3382.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3383.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3384.         } else {

  3385.                 vis_src1(TMP2, REF_S2);

  3386.                 vis_src1(TMP4, REF_S6);

  3387.         }

  3388. 

  3389.         height >>= 1;

  3390.         do {

  3391.                 vis_ld64_2(ref, stride, TMP0);

  3392.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3393.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3394. 

  3395.                 vis_alignaddr_g0((void *)off);

  3396. 

  3397.                 vis_ld64_2(ref, stride_8, TMP2);

  3398.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3399.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3400. 

  3401.                 vis_ld64_2(ref, stride_16, TMP4);

  3402.                 ref += stride;

  3403.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3404.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3405. 

  3406.                 vis_ld64_2(ref, stride, TMP6);

  3407.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3408.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3409. 

  3410.                 vis_ld64_2(ref, stride_8, TMP8);

  3411.                 vis_faligndata(TMP0, TMP2, REF_0);

  3412. 

  3413.                 vis_ld64_2(ref, stride_16, TMP10);

  3414.                 ref += stride;

  3415.                 vis_faligndata(TMP2, TMP4, REF_4);

  3416. 

  3417.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3418. 

  3419.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3420. 

  3421.                 if (off != 0x7) {

  3422.                         vis_alignaddr_g0((void *)off_plus_1);

  3423.                         vis_faligndata(TMP0, TMP2, REF_2);

  3424.                         vis_faligndata(TMP2, TMP4, REF_6);

  3425.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3426.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3427.                 } else {

  3428.                         vis_src1(TMP2, REF_2);

  3429.                         vis_src1(TMP4, REF_6);

  3430.                         vis_src1(TMP8, REF_S2);

  3431.                         vis_src1(TMP10, REF_S6);

  3432.                 }

  3433. 

  3434.                 vis_mul8x16au(REF_0, CONST_256, TMP0);

  3435.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3436. 

  3437.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3438.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3439. 

  3440.                 vis_padd16(TMP0, CONST_2, TMP8);

  3441.                 vis_mul8x16au(REF_4, CONST_256, TMP0);

  3442. 

  3443.                 vis_padd16(TMP2, CONST_1, TMP10);

  3444.                 vis_mul8x16au(REF_4_1, CONST_256, TMP2);

  3445. 

  3446.                 vis_padd16(TMP8, TMP4, TMP8);

  3447.                 vis_mul8x16au(REF_6, CONST_256, TMP4);

  3448. 

  3449.                 vis_padd16(TMP10, TMP6, TMP10);

  3450.                 vis_mul8x16au(REF_6_1, CONST_256, TMP6);

  3451. 

  3452.                 vis_padd16(TMP12, TMP8, TMP12);

  3453. 

  3454.                 vis_padd16(TMP14, TMP10, TMP14);

  3455. 

  3456.                 vis_padd16(TMP12, TMP16, TMP12);

  3457. 

  3458.                 vis_padd16(TMP14, TMP18, TMP14);

  3459.                 vis_pack16(TMP12, DST_0);

  3460. 

  3461.                 vis_pack16(TMP14, DST_1);

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

  3463.                 vis_padd16(TMP0, CONST_1, TMP12);

  3464. 

  3465.                 vis_mul8x16au(REF_S0, CONST_256, TMP0);

  3466.                 vis_padd16(TMP2, CONST_1, TMP14);

  3467. 

  3468.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP2);

  3469.                 vis_padd16(TMP12, TMP4, TMP12);

  3470. 

  3471.                 vis_mul8x16au(REF_S2, CONST_256, TMP4);

  3472.                 vis_padd16(TMP14, TMP6, TMP14);

  3473. 

  3474.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

  3475.                 vis_padd16(TMP20, TMP12, TMP20);

  3476. 

  3477.                 vis_padd16(TMP22, TMP14, TMP22);

  3478. 

  3479.                 vis_padd16(TMP20, TMP24, TMP20);

  3480. 

  3481.                 vis_padd16(TMP22, TMP26, TMP22);

  3482.                 vis_pack16(TMP20, DST_2);

  3483. 

  3484.                 vis_pack16(TMP22, DST_3);

  3485.                 vis_st64_2(DST_2, dest, 8);

  3486.                 dest += stride;

  3487.                 vis_padd16(TMP0, TMP4, TMP24);

  3488. 

  3489.                 vis_mul8x16au(REF_S4, CONST_256, TMP0);

  3490.                 vis_padd16(TMP2, TMP6, TMP26);

  3491. 

  3492.                 vis_mul8x16au(REF_S4_1, CONST_256, TMP2);

  3493.                 vis_padd16(TMP24, TMP8, TMP24);

  3494. 

  3495.                 vis_padd16(TMP26, TMP10, TMP26);

  3496.                 vis_pack16(TMP24, DST_0);

  3497. 

  3498.                 vis_pack16(TMP26, DST_1);

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

  3500.                 vis_pmerge(ZERO, REF_S6, TMP4);

  3501. 

  3502.                 vis_pmerge(ZERO,      REF_S6_1,  TMP6);

  3503. 

  3504.                 vis_padd16(TMP0, TMP4, TMP0);

  3505. 

  3506.                 vis_padd16(TMP2, TMP6, TMP2);

  3507. 

  3508.                 vis_padd16(TMP0, TMP12, TMP0);

  3509. 

  3510.                 vis_padd16(TMP2, TMP14, TMP2);

  3511.                 vis_pack16(TMP0, DST_2);

  3512. 

  3513.                 vis_pack16(TMP2, DST_3);

  3514.                 vis_st64_2(DST_2, dest, 8);

  3515.                 dest += stride;

  3516.         } while (--height);

  3517. }

  3518. 

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

  3520.                                       const int stride, int height)

  3521. {

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

  3523.         unsigned long off_plus_1 = off + 1;

  3524.         int stride_8 = stride + 8;

  3525. 

  3526.         vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

  3527. 

  3528.         ref = vis_alignaddr(ref);

  3529. 

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

  3531.         vis_fzero(ZERO);

  3532. 

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

  3534. 

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

  3536. 

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

  3538.         vis_faligndata(TMP0, TMP2, REF_S0);

  3539. 

  3540.         if (off != 0x7) {

  3541.                 vis_alignaddr_g0((void *)off_plus_1);

  3542.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3543.         } else {

  3544.                 vis_src1(TMP2, REF_S2);

  3545.         }

  3546. 

  3547.         height >>= 1;

  3548.         do {    /* 26 cycles */

  3549.                 vis_ld64_2(ref, stride, TMP0);

  3550.                 vis_mul8x16au(REF_S0,   CONST_256, TMP8);

  3551.                 vis_pmerge(ZERO,        REF_S2,    TMP12);

  3552. 

  3553.                 vis_alignaddr_g0((void *)off);

  3554. 

  3555.                 vis_ld64_2(ref, stride_8, TMP2);

  3556.                 ref += stride;

  3557.                 vis_mul8x16au(REF_S0_1, CONST_256, TMP10);

  3558.                 vis_pmerge(ZERO,        REF_S2_1,  TMP14);

  3559. 

  3560.                 vis_ld64_2(ref, stride, TMP4);

  3561. 

  3562.                 vis_ld64_2(ref, stride_8, TMP6);

  3563.                 ref += stride;

  3564.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3565. 

  3566.                 vis_pmerge(ZERO, REF_S4, TMP18);

  3567. 

  3568.                 vis_pmerge(ZERO, REF_S4_1, TMP20);

  3569. 

  3570.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3571. 

  3572.                 if (off != 0x7) {

  3573.                         vis_alignaddr_g0((void *)off_plus_1);

  3574.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3575.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3576.                 } else {

  3577.                         vis_src1(TMP2, REF_S6);

  3578.                         vis_src1(TMP6, REF_S2);

  3579.                 }

  3580. 

  3581.                 vis_padd16(TMP18, CONST_1, TMP18);

  3582.                 vis_mul8x16au(REF_S6,   CONST_256, TMP22);

  3583. 

  3584.                 vis_padd16(TMP20, CONST_1, TMP20);

  3585.                 vis_mul8x16au(REF_S6_1, CONST_256, TMP24);

  3586. 

  3587.                 vis_mul8x16au(REF_S0,   CONST_256, TMP26);

  3588.                 vis_pmerge(ZERO, REF_S0_1, TMP28);

  3589. 

  3590.                 vis_mul8x16au(REF_S2,   CONST_256, TMP30);

  3591.                 vis_padd16(TMP18, TMP22, TMP18);

  3592. 

  3593.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP32);

  3594.                 vis_padd16(TMP20, TMP24, TMP20);

  3595. 

  3596.                 vis_padd16(TMP8,  TMP18, TMP8);

  3597. 

  3598.                 vis_padd16(TMP10, TMP20, TMP10);

  3599. 

  3600.                 vis_padd16(TMP8,  TMP12, TMP8);

  3601. 

  3602.                 vis_padd16(TMP10, TMP14, TMP10);

  3603.                 vis_pack16(TMP8,  DST_0);

  3604. 

  3605.                 vis_pack16(TMP10, DST_1);

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

  3607.                 dest += stride;

  3608.                 vis_padd16(TMP18, TMP26, TMP18);

  3609. 

  3610.                 vis_padd16(TMP20, TMP28, TMP20);

  3611. 

  3612.                 vis_padd16(TMP18, TMP30, TMP18);

  3613. 

  3614.                 vis_padd16(TMP20, TMP32, TMP20);

  3615.                 vis_pack16(TMP18, DST_2);

  3616. 

  3617.                 vis_pack16(TMP20, DST_3);

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

  3619.                 dest += stride;

  3620.         } while (--height);

  3621. }

  3622. 

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

  3624.                                        const int stride, int height)

  3625. {

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

  3627.         unsigned long off_plus_1 = off + 1;

  3628.         int stride_8 = stride + 8;

  3629.         int stride_16 = stride + 16;

  3630. 

  3631.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3632. 

  3633.         ref = vis_alignaddr(ref);

  3634. 

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

  3636.         vis_fzero(ZERO);

  3637. 

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

  3639. 

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

  3641. 

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

  3643.         vis_faligndata(TMP0, TMP2, REF_S0);

  3644. 

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

  3646.         vis_faligndata(TMP2, TMP4, REF_S4);

  3647. 

  3648.         if (off != 0x7) {

  3649.                 vis_alignaddr_g0((void *)off_plus_1);

  3650.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3651.                 vis_faligndata(TMP2, TMP4, REF_S6);

  3652.         } else {

  3653.                 vis_src1(TMP2, REF_S2);

  3654.                 vis_src1(TMP4, REF_S6);

  3655.         }

  3656. 

  3657.         height >>= 1;

  3658.         do {    /* 55 cycles */

  3659.                 vis_ld64_2(ref, stride, TMP0);

  3660.                 vis_mul8x16au(REF_S0, CONST_256, TMP12);

  3661.                 vis_pmerge(ZERO,      REF_S0_1,  TMP14);

  3662. 

  3663.                 vis_alignaddr_g0((void *)off);

  3664. 

  3665.                 vis_ld64_2(ref, stride_8, TMP2);

  3666.                 vis_mul8x16au(REF_S2, CONST_256, TMP16);

  3667.                 vis_pmerge(ZERO,      REF_S2_1,  TMP18);

  3668. 

  3669.                 vis_ld64_2(ref, stride_16, TMP4);

  3670.                 ref += stride;

  3671.                 vis_mul8x16au(REF_S4, CONST_256, TMP20);

  3672.                 vis_pmerge(ZERO,      REF_S4_1,  TMP22);

  3673. 

  3674.                 vis_ld64_2(ref, stride, TMP6);

  3675.                 vis_mul8x16au(REF_S6, CONST_256, TMP24);

  3676.                 vis_pmerge(ZERO,      REF_S6_1,  TMP26);

  3677. 

  3678.                 vis_ld64_2(ref, stride_8, TMP8);

  3679.                 vis_faligndata(TMP0, TMP2, REF_0);

  3680. 

  3681.                 vis_ld64_2(ref, stride_16, TMP10);

  3682.                 ref += stride;

  3683.                 vis_faligndata(TMP2, TMP4, REF_4);

  3684. 

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

  3686.                 vis_faligndata(TMP6, TMP8, REF_S0);

  3687. 

  3688.                 vis_ld64_2(dest, 8, DST_2);

  3689.                 vis_faligndata(TMP8, TMP10, REF_S4);

  3690. 

  3691.                 if (off != 0x7) {

  3692.                         vis_alignaddr_g0((void *)off_plus_1);

  3693.                         vis_faligndata(TMP0, TMP2, REF_2);

  3694.                         vis_faligndata(TMP2, TMP4, REF_6);

  3695.                         vis_faligndata(TMP6, TMP8, REF_S2);

  3696.                         vis_faligndata(TMP8, TMP10, REF_S6);

  3697.                 } else {

  3698.                         vis_src1(TMP2, REF_2);

  3699.                         vis_src1(TMP4, REF_6);

  3700.                         vis_src1(TMP8, REF_S2);

  3701.                         vis_src1(TMP10, REF_S6);

  3702.                 }

  3703. 

  3704.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3705.                 vis_pmerge(ZERO, REF_0, TMP0);

  3706. 

  3707.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3708.                 vis_pmerge(ZERO,      REF_0_1,  TMP2);

  3709. 

  3710.                 vis_mul8x16au(REF_2, CONST_256, TMP4);

  3711.                 vis_pmerge(ZERO,      REF_2_1,  TMP6);

  3712. 

  3713.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3714.                 vis_padd16(TMP0, CONST_6, TMP0);

  3715. 

  3716.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3717.                 vis_padd16(TMP2, CONST_6, TMP2);

  3718. 

  3719.                 vis_padd16(TMP0, TMP4, TMP0);

  3720.                 vis_mul8x16au(REF_4, CONST_256, TMP4);

  3721. 

  3722.                 vis_padd16(TMP2, TMP6, TMP2);

  3723.                 vis_mul8x16au(REF_4_1, CONST_256, TMP6);

  3724. 

  3725.                 vis_padd16(TMP12, TMP0, TMP12);

  3726.                 vis_mul8x16au(REF_6, CONST_256, TMP8);

  3727. 

  3728.                 vis_padd16(TMP14, TMP2, TMP14);

  3729.                 vis_mul8x16au(REF_6_1, CONST_256, TMP10);

  3730. 

  3731.                 vis_padd16(TMP12, TMP16, TMP12);

  3732.                 vis_mul8x16au(REF_S0, CONST_256, REF_4);

  3733. 

  3734.                 vis_padd16(TMP14, TMP18, TMP14);

  3735.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_6);

  3736. 

  3737.                 vis_padd16(TMP12, TMP30, TMP12);

  3738. 

  3739.                 vis_padd16(TMP14, TMP32, TMP14);

  3740.                 vis_pack16(TMP12, DST_0);

  3741. 

  3742.                 vis_pack16(TMP14, DST_1);

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

  3744.                 vis_padd16(TMP4, CONST_6, TMP4);

  3745. 

  3746.                 vis_ld64_2(dest, stride, DST_0);

  3747.                 vis_padd16(TMP6, CONST_6, TMP6);

  3748.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3749. 

  3750.                 vis_padd16(TMP4, TMP8, TMP4);

  3751.                 vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);

  3752. 

  3753.                 vis_padd16(TMP6, TMP10, TMP6);

  3754. 

  3755.                 vis_padd16(TMP20, TMP4, TMP20);

  3756. 

  3757.                 vis_padd16(TMP22, TMP6, TMP22);

  3758. 

  3759.                 vis_padd16(TMP20, TMP24, TMP20);

  3760. 

  3761.                 vis_padd16(TMP22, TMP26, TMP22);

  3762. 

  3763.                 vis_padd16(TMP20, REF_0, TMP20);

  3764.                 vis_mul8x16au(REF_S4, CONST_256, REF_0);

  3765. 

  3766.                 vis_padd16(TMP22, REF_2, TMP22);

  3767.                 vis_pack16(TMP20, DST_2);

  3768. 

  3769.                 vis_pack16(TMP22, DST_3);

  3770.                 vis_st64_2(DST_2, dest, 8);

  3771.                 dest += stride;

  3772. 

  3773.                 vis_ld64_2(dest, 8, DST_2);

  3774.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3775.                 vis_pmerge(ZERO,      REF_S4_1,  REF_2);

  3776. 

  3777.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3778.                 vis_padd16(REF_4, TMP0, TMP8);

  3779. 

  3780.                 vis_mul8x16au(REF_S6, CONST_256, REF_4);

  3781.                 vis_padd16(REF_6, TMP2, TMP10);

  3782. 

  3783.                 vis_mul8x16au(REF_S6_1, CONST_256, REF_6);

  3784.                 vis_padd16(TMP8, TMP12, TMP8);

  3785. 

  3786.                 vis_padd16(TMP10, TMP14, TMP10);

  3787. 

  3788.                 vis_padd16(TMP8, TMP30, TMP8);

  3789. 

  3790.                 vis_padd16(TMP10, TMP32, TMP10);

  3791.                 vis_pack16(TMP8, DST_0);

  3792. 

  3793.                 vis_pack16(TMP10, DST_1);

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

  3795. 

  3796.                 vis_padd16(REF_0, TMP4, REF_0);

  3797. 

  3798.                 vis_mul8x16al(DST_2,   CONST_1024, TMP30);

  3799.                 vis_padd16(REF_2, TMP6, REF_2);

  3800. 

  3801.                 vis_mul8x16al(DST_3,   CONST_1024, TMP32);

  3802.                 vis_padd16(REF_0, REF_4, REF_0);

  3803. 

  3804.                 vis_padd16(REF_2, REF_6, REF_2);

  3805. 

  3806.                 vis_padd16(REF_0, TMP30, REF_0);

  3807. 

  3808.                 /* stall */

  3809. 

  3810.                 vis_padd16(REF_2, TMP32, REF_2);

  3811.                 vis_pack16(REF_0, DST_2);

  3812. 

  3813.                 vis_pack16(REF_2, DST_3);

  3814.                 vis_st64_2(DST_2, dest, 8);

  3815.                 dest += stride;

  3816.         } while (--height);

  3817. }

  3818. 

  3819. static void MC_avg_no_round_xy_8_vis (uint8_t * dest, const uint8_t * ref,

  3820.                                       const int stride, int height)

  3821. {

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

  3823.         unsigned long off_plus_1 = off + 1;

  3824.         int stride_8 = stride + 8;

  3825. 

  3826.         vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);

  3827. 

  3828.         ref = vis_alignaddr(ref);

  3829. 

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

  3831.         vis_fzero(ZERO);

  3832. 

  3833.         vis_ld64_2(ref, 8, TMP2);

  3834. 

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

  3836. 

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

  3838.         vis_faligndata(TMP0, TMP2, REF_S0);

  3839. 

  3840.         if (off != 0x7) {

  3841.                 vis_alignaddr_g0((void *)off_plus_1);

  3842.                 vis_faligndata(TMP0, TMP2, REF_S2);

  3843.         } else {

  3844.                 vis_src1(TMP2, REF_S2);

  3845.         }

  3846. 

  3847.         height >>= 1;

  3848.         do {    /* 31 cycles */

  3849.                 vis_ld64_2(ref, stride, TMP0);

  3850.                 vis_mul8x16au(REF_S0, CONST_256, TMP8);

  3851.                 vis_pmerge(ZERO,      REF_S0_1,  TMP10);

  3852. 

  3853.                 vis_ld64_2(ref, stride_8, TMP2);

  3854.                 ref += stride;

  3855.                 vis_mul8x16au(REF_S2, CONST_256, TMP12);

  3856.                 vis_pmerge(ZERO,      REF_S2_1,  TMP14);

  3857. 

  3858.                 vis_alignaddr_g0((void *)off);

  3859. 

  3860.                 vis_ld64_2(ref, stride, TMP4);

  3861.                 vis_faligndata(TMP0, TMP2, REF_S4);

  3862. 

  3863.                 vis_ld64_2(ref, stride_8, TMP6);

  3864.                 ref += stride;

  3865. 

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

  3867.                 vis_faligndata(TMP4, TMP6, REF_S0);

  3868. 

  3869.                 vis_ld64_2(dest, stride, DST_2);

  3870. 

  3871.                 if (off != 0x7) {

  3872.                         vis_alignaddr_g0((void *)off_plus_1);

  3873.                         vis_faligndata(TMP0, TMP2, REF_S6);

  3874.                         vis_faligndata(TMP4, TMP6, REF_S2);

  3875.                 } else {

  3876.                         vis_src1(TMP2, REF_S6);

  3877.                         vis_src1(TMP6, REF_S2);

  3878.                 }

  3879. 

  3880.                 vis_mul8x16al(DST_0,   CONST_1024, TMP30);

  3881.                 vis_pmerge(ZERO, REF_S4, TMP22);

  3882. 

  3883.                 vis_mul8x16al(DST_1,   CONST_1024, TMP32);

  3884.                 vis_pmerge(ZERO,      REF_S4_1,  TMP24);

  3885. 

  3886.                 vis_mul8x16au(REF_S6, CONST_256, TMP26);

  3887.                 vis_pmerge(ZERO,      REF_S6_1,  TMP28);

  3888. 

  3889.                 vis_mul8x16au(REF_S0, CONST_256, REF_S4);

  3890.                 vis_padd16(TMP22, CONST_6, TMP22);

  3891. 

  3892.                 vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);

  3893.                 vis_padd16(TMP24, CONST_6, TMP24);

  3894. 

  3895.                 vis_mul8x16al(DST_2,   CONST_1024, REF_0);

  3896.                 vis_padd16(TMP22, TMP26, TMP22);

  3897. 

  3898.                 vis_mul8x16al(DST_3,   CONST_1024, REF_2);

  3899.                 vis_padd16(TMP24, TMP28, TMP24);

  3900. 

  3901.                 vis_mul8x16au(REF_S2, CONST_256, TMP26);

  3902.                 vis_padd16(TMP8, TMP22, TMP8);

  3903. 

  3904.                 vis_mul8x16au(REF_S2_1, CONST_256, TMP28);

  3905.                 vis_padd16(TMP10, TMP24, TMP10);

  3906. 

  3907.                 vis_padd16(TMP8, TMP12, TMP8);

  3908. 

  3909.                 vis_padd16(TMP10, TMP14, TMP10);

  3910. 

  3911.                 vis_padd16(TMP8, TMP30, TMP8);

  3912. 

  3913.                 vis_padd16(TMP10, TMP32, TMP10);

  3914.                 vis_pack16(TMP8, DST_0);

  3915. 

  3916.                 vis_pack16(TMP10, DST_1);

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

  3918.                 dest += stride;

  3919. 

  3920.                 vis_padd16(REF_S4, TMP22, TMP12);

  3921. 

  3922.                 vis_padd16(REF_S6, TMP24, TMP14);

  3923. 

  3924.                 vis_padd16(TMP12, TMP26, TMP12);

  3925. 

  3926.                 vis_padd16(TMP14, TMP28, TMP14);

  3927. 

  3928.                 vis_padd16(TMP12, REF_0, TMP12);

  3929. 

  3930.                 vis_padd16(TMP14, REF_2, TMP14);

  3931.                 vis_pack16(TMP12, DST_2);

  3932. 

  3933.                 vis_pack16(TMP14, DST_3);

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

  3935.                 dest += stride;

  3936.         } while (--height);

  3937. }

  3938. 

  3939. /* End of no rounding code */

  3940. 

  3941. #define ACCEL_SPARC_VIS 1

  3942. #define ACCEL_SPARC_VIS2 2

  3943. 

  3944. static int vis_level(void)

  3945. {

  3946.     int accel = 0;

  3947.     accel |= ACCEL_SPARC_VIS;

  3948.     accel |= ACCEL_SPARC_VIS2;

  3949.     return accel;

  3950. }

  3951. 

  3952. /* libavcodec initialization code */

  3953. void ff_dsputil_init_vis(DSPContext* c, AVCodecContext *avctx)

  3954. {

  3955.   /* VIS-specific optimizations */

  3956.   int accel = vis_level ();

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

  3958. 

  3959.   if (accel & ACCEL_SPARC_VIS) {

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

  3961.           avctx->idct_algo == FF_IDCT_SIMPLEVIS) {

  3962.           c->idct_put = ff_simple_idct_put_vis;

  3963.           c->idct_add = ff_simple_idct_add_vis;

  3964.           c->idct     = ff_simple_idct_vis;

  3965.           c->idct_permutation_type = FF_TRANSPOSE_IDCT_PERM;

  3966.       }

  3967. 

  3968.       if (!high_bit_depth) {

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

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

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

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

  3973. 

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

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

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

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

  3978. 

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

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

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

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

  3983. 

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

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

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

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

  3988. 

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

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

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

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

  3993. 

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

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

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

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

  3998. 

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

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

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

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

  4003. 

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

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

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

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

  4008.       }

  4009.   }

  4010. }