开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
dsputil_vis.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：89k
源码类别：

Windows CE

开发平台：

C/C++

dsputil_vis.c：源码内容
  1. /*
  2.  * dsputil_vis.c
  3.  * Copyright (C) 2003 David S. Miller <davem@redhat.com>
  4.  *
  5.  * This file is part of ffmpeg, a free MPEG-4 video stream decoder.
  6.  * See http://ffmpeg.sourceforge.net/ for updates.
  7.  *
  8.  * ffmpeg is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU Lesser General Public License as published by
  10.  * the Free Software Foundation; either version 2.1 of the License, or
  11.  * (at your option) any later version.
  12.  *
  13.  * ffmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the Lesser GNU General Public License
  19.  * along with this program; if not, write to the Free Software
  20.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21.  */
  23. /* The *no_round* functions have been added by James A. Morrison, 2003,2004.
  24.    The vis code from libmpeg2 was adapted for ffmpeg by James A. Morrison.
  25.  */
  27. #include "config.h"
  29. #ifdef ARCH_SPARC
  31. #include <inttypes.h>
  32. #include <signal.h>
  33. #include <setjmp.h>
  35. #include "../dsputil.h"
  37. #include "vis.h"
  39. /* The trick used in some of this file is the formula from the MMX
  40.  * motion comp code, which is:
  41.  *
  42.  * (x+y+1)>>1 == (x|y)-((x^y)>>1)
  43.  *
  44.  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
  45.  * We avoid overflows by masking before we do the shift, and we
  46.  * implement the shift by multiplying by 1/2 using mul8x16.  So in
  47.  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
  48.  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
  49.  * the value 0x80808080 is in f8):
  50.  *
  51.  * fxor f0, f2, f10
  52.  * fand f10, f4, f10
  53.  * fmul8x16 f8, f10, f10
  54.  * fand f10, f6, f10
  55.  * for f0, f2, f12
  56.  * fpsub16 f12, f10, f10
  57.  */
  59. #define ATTR_ALIGN(alignd) __attribute__ ((aligned(alignd)))
  61. #define DUP4(x) {x, x, x, x}
  62. #define DUP8(x) {x, x, x, x, x, x, x, x}
  63. static const int16_t constants1[] ATTR_ALIGN(8) = DUP4 (1);
  64. static const int16_t constants2[] ATTR_ALIGN(8) = DUP4 (2);
  65. static const int16_t constants3[] ATTR_ALIGN(8) = DUP4 (3);
  66. static const int16_t constants6[] ATTR_ALIGN(8) = DUP4 (6);
  67. static const int8_t constants_fe[] ATTR_ALIGN(8) = DUP8 (0xfe);
  68. static const int8_t constants_7f[] ATTR_ALIGN(8) = DUP8 (0x7f);
  69. static const int8_t constants128[] ATTR_ALIGN(8) = DUP8 (128);
  70. static const int16_t constants256_512[] ATTR_ALIGN(8) =
  71. {256, 512, 256, 512};
  72. static const int16_t constants256_1024[] ATTR_ALIGN(8) =
  73. {256, 1024, 256, 1024};
  75. #define REF_0 0
  76. #define REF_0_1 1
  77. #define REF_2 2
  78. #define REF_2_1 3
  79. #define REF_4 4
  80. #define REF_4_1 5
  81. #define REF_6 6
  82. #define REF_6_1 7
  83. #define REF_S0 8
  84. #define REF_S0_1 9
  85. #define REF_S2 10
  86. #define REF_S2_1 11
  87. #define REF_S4 12
  88. #define REF_S4_1 13
  89. #define REF_S6 14
  90. #define REF_S6_1 15
  91. #define DST_0 16
  92. #define DST_1 17
  93. #define DST_2 18
  94. #define DST_3 19
  95. #define CONST_1 20
  96. #define CONST_2 20
  97. #define CONST_3 20
  98. #define CONST_6 20
  99. #define MASK_fe 20
  100. #define CONST_128 22
  101. #define CONST_256 22
  102. #define CONST_512 22
  103. #define CONST_1024 22
  104. #define TMP0 24
  105. #define TMP1 25
  106. #define TMP2 26
  107. #define TMP3 27
  108. #define TMP4 28
  109. #define TMP5 29
  110. #define ZERO 30
  111. #define MASK_7f 30
  113. #define TMP6 32
  114. #define TMP8 34
  115. #define TMP10 36
  116. #define TMP12 38
  117. #define TMP14 40
  118. #define TMP16 42
  119. #define TMP18 44
  120. #define TMP20 46
  121. #define TMP22 48
  122. #define TMP24 50
  123. #define TMP26 52
  124. #define TMP28 54
  125. #define TMP30 56
  126. #define TMP32 58
  128. static void MC_put_o_16_vis (uint8_t * dest, const uint8_t * _ref,
  129.      const int stride, int height)
  130. {
  131. uint8_t *ref = (uint8_t *) _ref;
  133. ref = vis_alignaddr(ref);
  134. do { /* 5 cycles */
  135. vis_ld64(ref[0], TMP0);
  137. vis_ld64_2(ref, 8, TMP2);
  139. vis_ld64_2(ref, 16, TMP4);
  140. ref += stride;
  142. vis_faligndata(TMP0, TMP2, REF_0);
  143. vis_st64(REF_0, dest[0]);
  145. vis_faligndata(TMP2, TMP4, REF_2);
  146. vis_st64_2(REF_2, dest, 8);
  147. dest += stride;
  148. } while (--height);
  149. }
  151. static void MC_put_o_8_vis (uint8_t * dest, const uint8_t * _ref,
  152.     const int stride, int height)
  153. {
  154. uint8_t *ref = (uint8_t *) _ref;
  156. ref = vis_alignaddr(ref);
  157. do { /* 4 cycles */
  158. vis_ld64(ref[0], TMP0);
  160. vis_ld64(ref[8], TMP2);
  161. ref += stride;
  163. /* stall */
  165. vis_faligndata(TMP0, TMP2, REF_0);
  166. vis_st64(REF_0, dest[0]);
  167. dest += stride;
  168. } while (--height);
  169. }
  172. static void MC_avg_o_16_vis (uint8_t * dest, const uint8_t * _ref,
  173.      const int stride, int height)
  174. {
  175. uint8_t *ref = (uint8_t *) _ref;
  176. int stride_8 = stride + 8;
  178. ref = vis_alignaddr(ref);
  180. vis_ld64(ref[0], TMP0);
  182. vis_ld64(ref[8], TMP2);
  184. vis_ld64(ref[16], TMP4);
  186. vis_ld64(dest[0], DST_0);
  188. vis_ld64(dest[8], DST_2);
  190. vis_ld64(constants_fe[0], MASK_fe);
  191. vis_faligndata(TMP0, TMP2, REF_0);
  193. vis_ld64(constants_7f[0], MASK_7f);
  194. vis_faligndata(TMP2, TMP4, REF_2);
  196. vis_ld64(constants128[0], CONST_128);
  198. ref += stride;
  199. height = (height >> 1) - 1;
  201. do { /* 24 cycles */
  202. vis_ld64(ref[0], TMP0);
  203. vis_xor(DST_0, REF_0, TMP6);
  205. vis_ld64_2(ref, 8, TMP2);
  206. vis_and(TMP6, MASK_fe, TMP6);
  208. vis_ld64_2(ref, 16, TMP4);
  209. ref += stride;
  210. vis_mul8x16(CONST_128, TMP6, TMP6);
  211. vis_xor(DST_2, REF_2, TMP8);
  213. vis_and(TMP8, MASK_fe, TMP8);
  215. vis_or(DST_0, REF_0, TMP10);
  216. vis_ld64_2(dest, stride, DST_0);
  217. vis_mul8x16(CONST_128, TMP8, TMP8);
  219. vis_or(DST_2, REF_2, TMP12);
  220. vis_ld64_2(dest, stride_8, DST_2);
  222. vis_ld64(ref[0], TMP14);
  223. vis_and(TMP6, MASK_7f, TMP6);
  225. vis_and(TMP8, MASK_7f, TMP8);
  227. vis_psub16(TMP10, TMP6, TMP6);
  228. vis_st64(TMP6, dest[0]);
  230. vis_psub16(TMP12, TMP8, TMP8);
  231. vis_st64_2(TMP8, dest, 8);
  233. dest += stride;
  234. vis_ld64_2(ref, 8, TMP16);
  235. vis_faligndata(TMP0, TMP2, REF_0);
  237. vis_ld64_2(ref, 16, TMP18);
  238. vis_faligndata(TMP2, TMP4, REF_2);
  239. ref += stride;
  241. vis_xor(DST_0, REF_0, TMP20);
  243. vis_and(TMP20, MASK_fe, TMP20);
  245. vis_xor(DST_2, REF_2, TMP22);
  246. vis_mul8x16(CONST_128, TMP20, TMP20);
  248. vis_and(TMP22, MASK_fe, TMP22);
  250. vis_or(DST_0, REF_0, TMP24);
  251. vis_mul8x16(CONST_128, TMP22, TMP22);
  253. vis_or(DST_2, REF_2, TMP26);
  255. vis_ld64_2(dest, stride, DST_0);
  256. vis_faligndata(TMP14, TMP16, REF_0);
  258. vis_ld64_2(dest, stride_8, DST_2);
  259. vis_faligndata(TMP16, TMP18, REF_2);
  261. vis_and(TMP20, MASK_7f, TMP20);
  263. vis_and(TMP22, MASK_7f, TMP22);
  265. vis_psub16(TMP24, TMP20, TMP20);
  266. vis_st64(TMP20, dest[0]);
  268. vis_psub16(TMP26, TMP22, TMP22);
  269. vis_st64_2(TMP22, dest, 8);
  270. dest += stride;
  271. } while (--height);
  273. vis_ld64(ref[0], TMP0);
  274. vis_xor(DST_0, REF_0, TMP6);
  276. vis_ld64_2(ref, 8, TMP2);
  277. vis_and(TMP6, MASK_fe, TMP6);
  279. vis_ld64_2(ref, 16, TMP4);
  280. vis_mul8x16(CONST_128, TMP6, TMP6);
  281. vis_xor(DST_2, REF_2, TMP8);
  283. vis_and(TMP8, MASK_fe, TMP8);
  285. vis_or(DST_0, REF_0, TMP10);
  286. vis_ld64_2(dest, stride, DST_0);
  287. vis_mul8x16(CONST_128, TMP8, TMP8);
  289. vis_or(DST_2, REF_2, TMP12);
  290. vis_ld64_2(dest, stride_8, DST_2);
  292. vis_ld64(ref[0], TMP14);
  293. vis_and(TMP6, MASK_7f, TMP6);
  295. vis_and(TMP8, MASK_7f, TMP8);
  297. vis_psub16(TMP10, TMP6, TMP6);
  298. vis_st64(TMP6, dest[0]);
  300. vis_psub16(TMP12, TMP8, TMP8);
  301. vis_st64_2(TMP8, dest, 8);
  303. dest += stride;
  304. vis_faligndata(TMP0, TMP2, REF_0);
  306. vis_faligndata(TMP2, TMP4, REF_2);
  308. vis_xor(DST_0, REF_0, TMP20);
  310. vis_and(TMP20, MASK_fe, TMP20);
  312. vis_xor(DST_2, REF_2, TMP22);
  313. vis_mul8x16(CONST_128, TMP20, TMP20);
  315. vis_and(TMP22, MASK_fe, TMP22);
  317. vis_or(DST_0, REF_0, TMP24);
  318. vis_mul8x16(CONST_128, TMP22, TMP22);
  320. vis_or(DST_2, REF_2, TMP26);
  322. vis_and(TMP20, MASK_7f, TMP20);
  324. vis_and(TMP22, MASK_7f, TMP22);
  326. vis_psub16(TMP24, TMP20, TMP20);
  327. vis_st64(TMP20, dest[0]);
  329. vis_psub16(TMP26, TMP22, TMP22);
  330. vis_st64_2(TMP22, dest, 8);
  331. }
  333. static void MC_avg_o_8_vis (uint8_t * dest, const uint8_t * _ref,
  334.     const int stride, int height)
  335. {
  336. uint8_t *ref = (uint8_t *) _ref;
  338. ref = vis_alignaddr(ref);
  340. vis_ld64(ref[0], TMP0);
  342. vis_ld64(ref[8], TMP2);
  344. vis_ld64(dest[0], DST_0);
  346. vis_ld64(constants_fe[0], MASK_fe);
  348. vis_ld64(constants_7f[0], MASK_7f);
  349. vis_faligndata(TMP0, TMP2, REF_0);
  351. vis_ld64(constants128[0], CONST_128);
  353. ref += stride;
  354. height = (height >> 1) - 1;
  356. do { /* 12 cycles */
  357. vis_ld64(ref[0], TMP0);
  358. vis_xor(DST_0, REF_0, TMP4);
  360. vis_ld64(ref[8], TMP2);
  361. vis_and(TMP4, MASK_fe, TMP4);
  363. vis_or(DST_0, REF_0, TMP6);
  364. vis_ld64_2(dest, stride, DST_0);
  365. ref += stride;
  366. vis_mul8x16(CONST_128, TMP4, TMP4);
  368. vis_ld64(ref[0], TMP12);
  369. vis_faligndata(TMP0, TMP2, REF_0);
  371. vis_ld64(ref[8], TMP2);
  372. vis_xor(DST_0, REF_0, TMP0);
  373. ref += stride;
  375. vis_and(TMP0, MASK_fe, TMP0);
  377. vis_and(TMP4, MASK_7f, TMP4);
  379. vis_psub16(TMP6, TMP4, TMP4);
  380. vis_st64(TMP4, dest[0]);
  381. dest += stride;
  382. vis_mul8x16(CONST_128, TMP0, TMP0);
  384. vis_or(DST_0, REF_0, TMP6);
  385. vis_ld64_2(dest, stride, DST_0);
  387. vis_faligndata(TMP12, TMP2, REF_0);
  389. vis_and(TMP0, MASK_7f, TMP0);
  391. vis_psub16(TMP6, TMP0, TMP4);
  392. vis_st64(TMP4, dest[0]);
  393. dest += stride;
  394. } while (--height);
  396. vis_ld64(ref[0], TMP0);
  397. vis_xor(DST_0, REF_0, TMP4);
  399. vis_ld64(ref[8], TMP2);
  400. vis_and(TMP4, MASK_fe, TMP4);
  402. vis_or(DST_0, REF_0, TMP6);
  403. vis_ld64_2(dest, stride, DST_0);
  404. vis_mul8x16(CONST_128, TMP4, TMP4);
  406. vis_faligndata(TMP0, TMP2, REF_0);
  408. vis_xor(DST_0, REF_0, TMP0);
  410. vis_and(TMP0, MASK_fe, TMP0);
  412. vis_and(TMP4, MASK_7f, TMP4);
  414. vis_psub16(TMP6, TMP4, TMP4);
  415. vis_st64(TMP4, dest[0]);
  416. dest += stride;
  417. vis_mul8x16(CONST_128, TMP0, TMP0);
  419. vis_or(DST_0, REF_0, TMP6);
  421. vis_and(TMP0, MASK_7f, TMP0);
  423. vis_psub16(TMP6, TMP0, TMP4);
  424. vis_st64(TMP4, dest[0]);
  425. }
  427. static void MC_put_x_16_vis (uint8_t * dest, const uint8_t * _ref,
  428.      const int stride, int height)
  429. {
  430. uint8_t *ref = (uint8_t *) _ref;
  431. unsigned long off = (unsigned long) ref & 0x7;
  432. unsigned long off_plus_1 = off + 1;
  434. ref = vis_alignaddr(ref);
  436. vis_ld64(ref[0],    TMP0);
  438. vis_ld64_2(ref, 8,  TMP2);
  440. vis_ld64_2(ref, 16, TMP4);
  442. vis_ld64(constants_fe[0], MASK_fe);
  444. vis_ld64(constants_7f[0], MASK_7f);
  445. vis_faligndata(TMP0, TMP2, REF_0);
  447. vis_ld64(constants128[0], CONST_128);
  448. vis_faligndata(TMP2, TMP4, REF_4);
  450. if (off != 0x7) {
  451. vis_alignaddr_g0((void *)off_plus_1);
  452. vis_faligndata(TMP0, TMP2, REF_2);
  453. vis_faligndata(TMP2, TMP4, REF_6);
  454. } else {
  455. vis_src1(TMP2, REF_2);
  456. vis_src1(TMP4, REF_6);
  457. }
  459. ref += stride;
  460. height = (height >> 1) - 1;
  462. do { /* 34 cycles */
  463. vis_ld64(ref[0],    TMP0);
  464. vis_xor(REF_0, REF_2, TMP6);
  466. vis_ld64_2(ref, 8,  TMP2);
  467. vis_xor(REF_4, REF_6, TMP8);
  469. vis_ld64_2(ref, 16, TMP4);
  470. vis_and(TMP6, MASK_fe, TMP6);
  471. ref += stride;
  473. vis_ld64(ref[0],    TMP14);
  474. vis_mul8x16(CONST_128, TMP6, TMP6);
  475. vis_and(TMP8, MASK_fe, TMP8);
  477. vis_ld64_2(ref, 8,  TMP16);
  478. vis_mul8x16(CONST_128, TMP8, TMP8);
  479. vis_or(REF_0, REF_2, TMP10);
  481. vis_ld64_2(ref, 16, TMP18);
  482. ref += stride;
  483. vis_or(REF_4, REF_6, TMP12);
  485. vis_alignaddr_g0((void *)off);
  487. vis_faligndata(TMP0, TMP2, REF_0);
  489. vis_faligndata(TMP2, TMP4, REF_4);
  491. if (off != 0x7) {
  492. vis_alignaddr_g0((void *)off_plus_1);
  493. vis_faligndata(TMP0, TMP2, REF_2);
  494. vis_faligndata(TMP2, TMP4, REF_6);
  495. } else {
  496. vis_src1(TMP2, REF_2);
  497. vis_src1(TMP4, REF_6);
  498. }
  500. vis_and(TMP6, MASK_7f, TMP6);
  502. vis_and(TMP8, MASK_7f, TMP8);
  504. vis_psub16(TMP10, TMP6, TMP6);
  505. vis_st64(TMP6, dest[0]);
  507. vis_psub16(TMP12, TMP8, TMP8);
  508. vis_st64_2(TMP8, dest, 8);
  509. dest += stride;
  511. vis_xor(REF_0, REF_2, TMP6);
  513. vis_xor(REF_4, REF_6, TMP8);
  515. vis_and(TMP6, MASK_fe, TMP6);
  517. vis_mul8x16(CONST_128, TMP6, TMP6);
  518. vis_and(TMP8, MASK_fe, TMP8);
  520. vis_mul8x16(CONST_128, TMP8, TMP8);
  521. vis_or(REF_0, REF_2, TMP10);
  523. vis_or(REF_4, REF_6, TMP12);
  525. vis_alignaddr_g0((void *)off);
  527. vis_faligndata(TMP14, TMP16, REF_0);
  529. vis_faligndata(TMP16, TMP18, REF_4);
  531. if (off != 0x7) {
  532. vis_alignaddr_g0((void *)off_plus_1);
  533. vis_faligndata(TMP14, TMP16, REF_2);
  534. vis_faligndata(TMP16, TMP18, REF_6);
  535. } else {
  536. vis_src1(TMP16, REF_2);
  537. vis_src1(TMP18, REF_6);
  538. }
  540. vis_and(TMP6, MASK_7f, TMP6);
  542. vis_and(TMP8, MASK_7f, TMP8);
  544. vis_psub16(TMP10, TMP6, TMP6);
  545. vis_st64(TMP6, dest[0]);
  547. vis_psub16(TMP12, TMP8, TMP8);
  548. vis_st64_2(TMP8, dest, 8);
  549. dest += stride;
  550. } while (--height);
  552. vis_ld64(ref[0],    TMP0);
  553. vis_xor(REF_0, REF_2, TMP6);
  555. vis_ld64_2(ref, 8,  TMP2);
  556. vis_xor(REF_4, REF_6, TMP8);
  558. vis_ld64_2(ref, 16, TMP4);
  559. vis_and(TMP6, MASK_fe, TMP6);
  561. vis_mul8x16(CONST_128, TMP6, TMP6);
  562. vis_and(TMP8, MASK_fe, TMP8);
  564. vis_mul8x16(CONST_128, TMP8, TMP8);
  565. vis_or(REF_0, REF_2, TMP10);
  567. vis_or(REF_4, REF_6, TMP12);
  569. vis_alignaddr_g0((void *)off);
  571. vis_faligndata(TMP0, TMP2, REF_0);
  573. vis_faligndata(TMP2, TMP4, REF_4);
  575. if (off != 0x7) {
  576. vis_alignaddr_g0((void *)off_plus_1);
  577. vis_faligndata(TMP0, TMP2, REF_2);
  578. vis_faligndata(TMP2, TMP4, REF_6);
  579. } else {
  580. vis_src1(TMP2, REF_2);
  581. vis_src1(TMP4, REF_6);
  582. }
  584. vis_and(TMP6, MASK_7f, TMP6);
  586. vis_and(TMP8, MASK_7f, TMP8);
  588. vis_psub16(TMP10, TMP6, TMP6);
  589. vis_st64(TMP6, dest[0]);
  591. vis_psub16(TMP12, TMP8, TMP8);
  592. vis_st64_2(TMP8, dest, 8);
  593. dest += stride;
  595. vis_xor(REF_0, REF_2, TMP6);
  597. vis_xor(REF_4, REF_6, TMP8);
  599. vis_and(TMP6, MASK_fe, TMP6);
  601. vis_mul8x16(CONST_128, TMP6, TMP6);
  602. vis_and(TMP8, MASK_fe, TMP8);
  604. vis_mul8x16(CONST_128, TMP8, TMP8);
  605. vis_or(REF_0, REF_2, TMP10);
  607. vis_or(REF_4, REF_6, TMP12);
  609. vis_and(TMP6, MASK_7f, TMP6);
  611. vis_and(TMP8, MASK_7f, TMP8);
  613. vis_psub16(TMP10, TMP6, TMP6);
  614. vis_st64(TMP6, dest[0]);
  616. vis_psub16(TMP12, TMP8, TMP8);
  617. vis_st64_2(TMP8, dest, 8);
  618. }
  620. static void MC_put_x_8_vis (uint8_t * dest, const uint8_t * _ref,
  621.     const int stride, int height)
  622. {
  623. uint8_t *ref = (uint8_t *) _ref;
  624. unsigned long off = (unsigned long) ref & 0x7;
  625. unsigned long off_plus_1 = off + 1;
  627. ref = vis_alignaddr(ref);
  629. vis_ld64(ref[0], TMP0);
  631. vis_ld64(ref[8], TMP2);
  633. vis_ld64(constants_fe[0], MASK_fe);
  635. vis_ld64(constants_7f[0], MASK_7f);
  637. vis_ld64(constants128[0], CONST_128);
  638. vis_faligndata(TMP0, TMP2, REF_0);
  640. if (off != 0x7) {
  641. vis_alignaddr_g0((void *)off_plus_1);
  642. vis_faligndata(TMP0, TMP2, REF_2);
  643. } else {
  644. vis_src1(TMP2, REF_2);
  645. }
  647. ref += stride;
  648. height = (height >> 1) - 1;
  650. do { /* 20 cycles */
  651. vis_ld64(ref[0], TMP0);
  652. vis_xor(REF_0, REF_2, TMP4);
  654. vis_ld64_2(ref, 8, TMP2);
  655. vis_and(TMP4, MASK_fe, TMP4);
  656. ref += stride;
  658. vis_ld64(ref[0], TMP8);
  659. vis_or(REF_0, REF_2, TMP6);
  660. vis_mul8x16(CONST_128, TMP4, TMP4);
  662. vis_alignaddr_g0((void *)off);
  664. vis_ld64_2(ref, 8, TMP10);
  665. ref += stride;
  666. vis_faligndata(TMP0, TMP2, REF_0);
  668. if (off != 0x7) {
  669. vis_alignaddr_g0((void *)off_plus_1);
  670. vis_faligndata(TMP0, TMP2, REF_2);
  671. } else {
  672. vis_src1(TMP2, REF_2);
  673. }
  675. vis_and(TMP4, MASK_7f, TMP4);
  677. vis_psub16(TMP6, TMP4, DST_0);
  678. vis_st64(DST_0, dest[0]);
  679. dest += stride;
  681. vis_xor(REF_0, REF_2, TMP12);
  683. vis_and(TMP12, MASK_fe, TMP12);
  685. vis_or(REF_0, REF_2, TMP14);
  686. vis_mul8x16(CONST_128, TMP12, TMP12);
  688. vis_alignaddr_g0((void *)off);
  689. vis_faligndata(TMP8, TMP10, REF_0);
  690. if (off != 0x7) {
  691. vis_alignaddr_g0((void *)off_plus_1);
  692. vis_faligndata(TMP8, TMP10, REF_2);
  693. } else {
  694. vis_src1(TMP10, REF_2);
  695. }
  697. vis_and(TMP12, MASK_7f, TMP12);
  699. vis_psub16(TMP14, TMP12, DST_0);
  700. vis_st64(DST_0, dest[0]);
  701. dest += stride;
  702. } while (--height);
  704. vis_ld64(ref[0], TMP0);
  705. vis_xor(REF_0, REF_2, TMP4);
  707. vis_ld64_2(ref, 8, TMP2);
  708. vis_and(TMP4, MASK_fe, TMP4);
  710. vis_or(REF_0, REF_2, TMP6);
  711. vis_mul8x16(CONST_128, TMP4, TMP4);
  713. vis_alignaddr_g0((void *)off);
  715. vis_faligndata(TMP0, TMP2, REF_0);
  717. if (off != 0x7) {
  718. vis_alignaddr_g0((void *)off_plus_1);
  719. vis_faligndata(TMP0, TMP2, REF_2);
  720. } else {
  721. vis_src1(TMP2, REF_2);
  722. }
  724. vis_and(TMP4, MASK_7f, TMP4);
  726. vis_psub16(TMP6, TMP4, DST_0);
  727. vis_st64(DST_0, dest[0]);
  728. dest += stride;
  730. vis_xor(REF_0, REF_2, TMP12);
  732. vis_and(TMP12, MASK_fe, TMP12);
  734. vis_or(REF_0, REF_2, TMP14);
  735. vis_mul8x16(CONST_128, TMP12, TMP12);
  737. vis_and(TMP12, MASK_7f, TMP12);
  739. vis_psub16(TMP14, TMP12, DST_0);
  740. vis_st64(DST_0, dest[0]);
  741. dest += stride;
  742. }
  744. static void MC_avg_x_16_vis (uint8_t * dest, const uint8_t * _ref,
  745.      const int stride, int height)
  746. {
  747. uint8_t *ref = (uint8_t *) _ref;
  748. unsigned long off = (unsigned long) ref & 0x7;
  749. unsigned long off_plus_1 = off + 1;
  751. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  753. vis_ld64(constants3[0], CONST_3);
  754. vis_fzero(ZERO);
  755. vis_ld64(constants256_512[0], CONST_256);
  757. ref = vis_alignaddr(ref);
  758. do { /* 26 cycles */
  759. vis_ld64(ref[0], TMP0);
  761. vis_ld64(ref[8], TMP2);
  763. vis_alignaddr_g0((void *)off);
  765. vis_ld64(ref[16], TMP4);
  767. vis_ld64(dest[0], DST_0);
  768. vis_faligndata(TMP0, TMP2, REF_0);
  770. vis_ld64(dest[8], DST_2);
  771. vis_faligndata(TMP2, TMP4, REF_4);
  773. if (off != 0x7) {
  774. vis_alignaddr_g0((void *)off_plus_1);
  775. vis_faligndata(TMP0, TMP2, REF_2);
  776. vis_faligndata(TMP2, TMP4, REF_6);
  777. } else {
  778. vis_src1(TMP2, REF_2);
  779. vis_src1(TMP4, REF_6);
  780. }
  782. vis_mul8x16au(REF_0,   CONST_256, TMP0);
  784. vis_pmerge(ZERO,     REF_2,     TMP4);
  785. vis_mul8x16au(REF_0_1, CONST_256, TMP2);
  787. vis_pmerge(ZERO, REF_2_1, TMP6);
  789. vis_padd16(TMP0, TMP4, TMP0);
  791. vis_mul8x16al(DST_0,   CONST_512, TMP4);
  792. vis_padd16(TMP2, TMP6, TMP2);
  794. vis_mul8x16al(DST_1,   CONST_512, TMP6);
  796. vis_mul8x16au(REF_6,   CONST_256, TMP12);
  798. vis_padd16(TMP0, TMP4, TMP0);
  799. vis_mul8x16au(REF_6_1, CONST_256, TMP14);
  801. vis_padd16(TMP2, TMP6, TMP2);
  802. vis_mul8x16au(REF_4,   CONST_256, TMP16);
  804. vis_padd16(TMP0, CONST_3, TMP8);
  805. vis_mul8x16au(REF_4_1, CONST_256, TMP18);
  807. vis_padd16(TMP2, CONST_3, TMP10);
  808. vis_pack16(TMP8, DST_0);
  810. vis_pack16(TMP10, DST_1);
  811. vis_padd16(TMP16, TMP12, TMP0);
  813. vis_st64(DST_0, dest[0]);
  814. vis_mul8x16al(DST_2,   CONST_512, TMP4);
  815. vis_padd16(TMP18, TMP14, TMP2);
  817. vis_mul8x16al(DST_3,   CONST_512, TMP6);
  818. vis_padd16(TMP0, CONST_3, TMP0);
  820. vis_padd16(TMP2, CONST_3, TMP2);
  822. vis_padd16(TMP0, TMP4, TMP0);
  824. vis_padd16(TMP2, TMP6, TMP2);
  825. vis_pack16(TMP0, DST_2);
  827. vis_pack16(TMP2, DST_3);
  828. vis_st64(DST_2, dest[8]);
  830. ref += stride;
  831. dest += stride;
  832. } while (--height);
  833. }
  835. static void MC_avg_x_8_vis (uint8_t * dest, const uint8_t * _ref,
  836.     const int stride, int height)
  837. {
  838. uint8_t *ref = (uint8_t *) _ref;
  839. unsigned long off = (unsigned long) ref & 0x7;
  840. unsigned long off_plus_1 = off + 1;
  841. int stride_times_2 = stride << 1;
  843. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  845. vis_ld64(constants3[0], CONST_3);
  846. vis_fzero(ZERO);
  847. vis_ld64(constants256_512[0], CONST_256);
  849. ref = vis_alignaddr(ref);
  850. height >>= 2;
  851. do { /* 47 cycles */
  852. vis_ld64(ref[0],   TMP0);
  854. vis_ld64_2(ref, 8, TMP2);
  855. ref += stride;
  857. vis_alignaddr_g0((void *)off);
  859. vis_ld64(ref[0],   TMP4);
  860. vis_faligndata(TMP0, TMP2, REF_0);
  862. vis_ld64_2(ref, 8, TMP6);
  863. ref += stride;
  865. vis_ld64(ref[0],   TMP8);
  867. vis_ld64_2(ref, 8, TMP10);
  868. ref += stride;
  869. vis_faligndata(TMP4, TMP6, REF_4);
  871. vis_ld64(ref[0],   TMP12);
  873. vis_ld64_2(ref, 8, TMP14);
  874. ref += stride;
  875. vis_faligndata(TMP8, TMP10, REF_S0);
  877. vis_faligndata(TMP12, TMP14, REF_S4);
  879. if (off != 0x7) {
  880. vis_alignaddr_g0((void *)off_plus_1);
  882. vis_ld64(dest[0], DST_0);
  883. vis_faligndata(TMP0, TMP2, REF_2);
  885. vis_ld64_2(dest, stride, DST_2);
  886. vis_faligndata(TMP4, TMP6, REF_6);
  888. vis_faligndata(TMP8, TMP10, REF_S2);
  890. vis_faligndata(TMP12, TMP14, REF_S6);
  891. } else {
  892. vis_ld64(dest[0], DST_0);
  893. vis_src1(TMP2, REF_2);
  895. vis_ld64_2(dest, stride, DST_2);
  896. vis_src1(TMP6, REF_6);
  898. vis_src1(TMP10, REF_S2);
  900. vis_src1(TMP14, REF_S6);
  901. }
  903. vis_pmerge(ZERO,     REF_0,     TMP0);
  904. vis_mul8x16au(REF_0_1, CONST_256, TMP2);
  906. vis_pmerge(ZERO,     REF_2,     TMP4);
  907. vis_mul8x16au(REF_2_1, CONST_256, TMP6);
  909. vis_padd16(TMP0, CONST_3, TMP0);
  910. vis_mul8x16al(DST_0,   CONST_512, TMP16);
  912. vis_padd16(TMP2, CONST_3, TMP2);
  913. vis_mul8x16al(DST_1,   CONST_512, TMP18);
  915. vis_padd16(TMP0, TMP4, TMP0);
  916. vis_mul8x16au(REF_4, CONST_256, TMP8);
  918. vis_padd16(TMP2, TMP6, TMP2);
  919. vis_mul8x16au(REF_4_1, CONST_256, TMP10);
  921. vis_padd16(TMP0, TMP16, TMP0);
  922. vis_mul8x16au(REF_6, CONST_256, TMP12);
  924. vis_padd16(TMP2, TMP18, TMP2);
  925. vis_mul8x16au(REF_6_1, CONST_256, TMP14);
  927. vis_padd16(TMP8, CONST_3, TMP8);
  928. vis_mul8x16al(DST_2, CONST_512, TMP16);
  930. vis_padd16(TMP8, TMP12, TMP8);
  931. vis_mul8x16al(DST_3, CONST_512, TMP18);
  933. vis_padd16(TMP10, TMP14, TMP10);
  934. vis_pack16(TMP0, DST_0);
  936. vis_pack16(TMP2, DST_1);
  937. vis_st64(DST_0, dest[0]);
  938. dest += stride;
  939. vis_padd16(TMP10, CONST_3, TMP10);
  941. vis_ld64_2(dest, stride, DST_0);
  942. vis_padd16(TMP8, TMP16, TMP8);
  944. vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
  945. vis_padd16(TMP10, TMP18, TMP10);
  946. vis_pack16(TMP8, DST_2);
  948. vis_pack16(TMP10, DST_3);
  949. vis_st64(DST_2, dest[0]);
  950. dest += stride;
  952. vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
  953. vis_pmerge(ZERO,     REF_S0,     TMP0);
  955. vis_pmerge(ZERO,     REF_S2,     TMP24);
  956. vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
  958. vis_padd16(TMP0, CONST_3, TMP0);
  959. vis_mul8x16au(REF_S4, CONST_256, TMP8);
  961. vis_padd16(TMP2, CONST_3, TMP2);
  962. vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
  964. vis_padd16(TMP0, TMP24, TMP0);
  965. vis_mul8x16au(REF_S6, CONST_256, TMP12);
  967. vis_padd16(TMP2, TMP6, TMP2);
  968. vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
  970. vis_padd16(TMP8, CONST_3, TMP8);
  971. vis_mul8x16al(DST_0,   CONST_512, TMP16);
  973. vis_padd16(TMP10, CONST_3, TMP10);
  974. vis_mul8x16al(DST_1,   CONST_512, TMP18);
  976. vis_padd16(TMP8, TMP12, TMP8);
  977. vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
  979. vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
  980. vis_padd16(TMP0, TMP16, TMP0);
  982. vis_padd16(TMP2, TMP18, TMP2);
  983. vis_pack16(TMP0, DST_0);
  985. vis_padd16(TMP10, TMP14, TMP10);
  986. vis_pack16(TMP2, DST_1);
  987. vis_st64(DST_0, dest[0]);
  988. dest += stride;
  990. vis_padd16(TMP8, TMP20, TMP8);
  992. vis_padd16(TMP10, TMP22, TMP10);
  993. vis_pack16(TMP8, DST_2);
  995. vis_pack16(TMP10, DST_3);
  996. vis_st64(DST_2, dest[0]);
  997. dest += stride;
  998. } while (--height);
  999. }
  1001. static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * _ref,
  1002.      const int stride, int height)
  1003. {
  1004. uint8_t *ref = (uint8_t *) _ref;
  1006. ref = vis_alignaddr(ref);
  1007. vis_ld64(ref[0], TMP0);
  1009. vis_ld64_2(ref, 8, TMP2);
  1011. vis_ld64_2(ref, 16, TMP4);
  1012. ref += stride;
  1014. vis_ld64(ref[0], TMP6);
  1015. vis_faligndata(TMP0, TMP2, REF_0);
  1017. vis_ld64_2(ref, 8, TMP8);
  1018. vis_faligndata(TMP2, TMP4, REF_4);
  1020. vis_ld64_2(ref, 16, TMP10);
  1021. ref += stride;
  1023. vis_ld64(constants_fe[0], MASK_fe);
  1024. vis_faligndata(TMP6, TMP8, REF_2);
  1026. vis_ld64(constants_7f[0], MASK_7f);
  1027. vis_faligndata(TMP8, TMP10, REF_6);
  1029. vis_ld64(constants128[0], CONST_128);
  1030. height = (height >> 1) - 1;
  1031. do { /* 24 cycles */
  1032. vis_ld64(ref[0], TMP0);
  1033. vis_xor(REF_0, REF_2, TMP12);
  1035. vis_ld64_2(ref, 8, TMP2);
  1036. vis_xor(REF_4, REF_6, TMP16);
  1038. vis_ld64_2(ref, 16, TMP4);
  1039. ref += stride;
  1040. vis_or(REF_0, REF_2, TMP14);
  1042. vis_ld64(ref[0], TMP6);
  1043. vis_or(REF_4, REF_6, TMP18);
  1045. vis_ld64_2(ref, 8, TMP8);
  1046. vis_faligndata(TMP0, TMP2, REF_0);
  1048. vis_ld64_2(ref, 16, TMP10);
  1049. ref += stride;
  1050. vis_faligndata(TMP2, TMP4, REF_4);
  1052. vis_and(TMP12, MASK_fe, TMP12);
  1054. vis_and(TMP16, MASK_fe, TMP16);
  1055. vis_mul8x16(CONST_128, TMP12, TMP12);
  1057. vis_mul8x16(CONST_128, TMP16, TMP16);
  1058. vis_xor(REF_0, REF_2, TMP0);
  1060. vis_xor(REF_4, REF_6, TMP2);
  1062. vis_or(REF_0, REF_2, TMP20);
  1064. vis_and(TMP12, MASK_7f, TMP12);
  1066. vis_and(TMP16, MASK_7f, TMP16);
  1068. vis_psub16(TMP14, TMP12, TMP12);
  1069. vis_st64(TMP12, dest[0]);
  1071. vis_psub16(TMP18, TMP16, TMP16);
  1072. vis_st64_2(TMP16, dest, 8);
  1073. dest += stride;
  1075. vis_or(REF_4, REF_6, TMP18);
  1077. vis_and(TMP0, MASK_fe, TMP0);
  1079. vis_and(TMP2, MASK_fe, TMP2);
  1080. vis_mul8x16(CONST_128, TMP0, TMP0);
  1082. vis_faligndata(TMP6, TMP8, REF_2);
  1083. vis_mul8x16(CONST_128, TMP2, TMP2);
  1085. vis_faligndata(TMP8, TMP10, REF_6);
  1087. vis_and(TMP0, MASK_7f, TMP0);
  1089. vis_and(TMP2, MASK_7f, TMP2);
  1091. vis_psub16(TMP20, TMP0, TMP0);
  1092. vis_st64(TMP0, dest[0]);
  1094. vis_psub16(TMP18, TMP2, TMP2);
  1095. vis_st64_2(TMP2, dest, 8);
  1096. dest += stride;
  1097. } while (--height);
  1099. vis_ld64(ref[0], TMP0);
  1100. vis_xor(REF_0, REF_2, TMP12);
  1102. vis_ld64_2(ref, 8, TMP2);
  1103. vis_xor(REF_4, REF_6, TMP16);
  1105. vis_ld64_2(ref, 16, TMP4);
  1106. vis_or(REF_0, REF_2, TMP14);
  1108. vis_or(REF_4, REF_6, TMP18);
  1110. vis_faligndata(TMP0, TMP2, REF_0);
  1112. vis_faligndata(TMP2, TMP4, REF_4);
  1114. vis_and(TMP12, MASK_fe, TMP12);
  1116. vis_and(TMP16, MASK_fe, TMP16);
  1117. vis_mul8x16(CONST_128, TMP12, TMP12);
  1119. vis_mul8x16(CONST_128, TMP16, TMP16);
  1120. vis_xor(REF_0, REF_2, TMP0);
  1122. vis_xor(REF_4, REF_6, TMP2);
  1124. vis_or(REF_0, REF_2, TMP20);
  1126. vis_and(TMP12, MASK_7f, TMP12);
  1128. vis_and(TMP16, MASK_7f, TMP16);
  1130. vis_psub16(TMP14, TMP12, TMP12);
  1131. vis_st64(TMP12, dest[0]);
  1133. vis_psub16(TMP18, TMP16, TMP16);
  1134. vis_st64_2(TMP16, dest, 8);
  1135. dest += stride;
  1137. vis_or(REF_4, REF_6, TMP18);
  1139. vis_and(TMP0, MASK_fe, TMP0);
  1141. vis_and(TMP2, MASK_fe, TMP2);
  1142. vis_mul8x16(CONST_128, TMP0, TMP0);
  1144. vis_mul8x16(CONST_128, TMP2, TMP2);
  1146. vis_and(TMP0, MASK_7f, TMP0);
  1148. vis_and(TMP2, MASK_7f, TMP2);
  1150. vis_psub16(TMP20, TMP0, TMP0);
  1151. vis_st64(TMP0, dest[0]);
  1153. vis_psub16(TMP18, TMP2, TMP2);
  1154. vis_st64_2(TMP2, dest, 8);
  1155. }
  1157. static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * _ref,
  1158.     const int stride, int height)
  1159. {
  1160. uint8_t *ref = (uint8_t *) _ref;
  1162. ref = vis_alignaddr(ref);
  1163. vis_ld64(ref[0], TMP0);
  1165. vis_ld64_2(ref, 8, TMP2);
  1166. ref += stride;
  1168. vis_ld64(ref[0], TMP4);
  1170. vis_ld64_2(ref, 8, TMP6);
  1171. ref += stride;
  1173. vis_ld64(constants_fe[0], MASK_fe);
  1174. vis_faligndata(TMP0, TMP2, REF_0);
  1176. vis_ld64(constants_7f[0], MASK_7f);
  1177. vis_faligndata(TMP4, TMP6, REF_2);
  1179. vis_ld64(constants128[0], CONST_128);
  1180. height = (height >> 1) - 1;
  1181. do { /* 12 cycles */
  1182. vis_ld64(ref[0], TMP0);
  1183. vis_xor(REF_0, REF_2, TMP4);
  1185. vis_ld64_2(ref, 8, TMP2);
  1186. ref += stride;
  1187. vis_and(TMP4, MASK_fe, TMP4);
  1189. vis_or(REF_0, REF_2, TMP6);
  1190. vis_mul8x16(CONST_128, TMP4, TMP4);
  1192. vis_faligndata(TMP0, TMP2, REF_0);
  1193. vis_ld64(ref[0], TMP0);
  1195. vis_ld64_2(ref, 8, TMP2);
  1196. ref += stride;
  1197. vis_xor(REF_0, REF_2, TMP12);
  1199. vis_and(TMP4, MASK_7f, TMP4);
  1201. vis_and(TMP12, MASK_fe, TMP12);
  1203. vis_mul8x16(CONST_128, TMP12, TMP12);
  1204. vis_or(REF_0, REF_2, TMP14);
  1206. vis_psub16(TMP6, TMP4, DST_0);
  1207. vis_st64(DST_0, dest[0]);
  1208. dest += stride;
  1210. vis_faligndata(TMP0, TMP2, REF_2);
  1212. vis_and(TMP12, MASK_7f, TMP12);
  1214. vis_psub16(TMP14, TMP12, DST_0);
  1215. vis_st64(DST_0, dest[0]);
  1216. dest += stride;
  1217. } while (--height);
  1219. vis_ld64(ref[0], TMP0);
  1220. vis_xor(REF_0, REF_2, TMP4);
  1222. vis_ld64_2(ref, 8, TMP2);
  1223. vis_and(TMP4, MASK_fe, TMP4);
  1225. vis_or(REF_0, REF_2, TMP6);
  1226. vis_mul8x16(CONST_128, TMP4, TMP4);
  1228. vis_faligndata(TMP0, TMP2, REF_0);
  1230. vis_xor(REF_0, REF_2, TMP12);
  1232. vis_and(TMP4, MASK_7f, TMP4);
  1234. vis_and(TMP12, MASK_fe, TMP12);
  1236. vis_mul8x16(CONST_128, TMP12, TMP12);
  1237. vis_or(REF_0, REF_2, TMP14);
  1239. vis_psub16(TMP6, TMP4, DST_0);
  1240. vis_st64(DST_0, dest[0]);
  1241. dest += stride;
  1243. vis_and(TMP12, MASK_7f, TMP12);
  1245. vis_psub16(TMP14, TMP12, DST_0);
  1246. vis_st64(DST_0, dest[0]);
  1247. }
  1249. static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * _ref,
  1250.      const int stride, int height)
  1251. {
  1252. uint8_t *ref = (uint8_t *) _ref;
  1253. int stride_8 = stride + 8;
  1254. int stride_16 = stride + 16;
  1256. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  1258. ref = vis_alignaddr(ref);
  1260. vis_ld64(ref[ 0], TMP0);
  1261. vis_fzero(ZERO);
  1263. vis_ld64(ref[ 8], TMP2);
  1265. vis_ld64(ref[16], TMP4);
  1267. vis_ld64(constants3[0], CONST_3);
  1268. vis_faligndata(TMP0, TMP2, REF_2);
  1270. vis_ld64(constants256_512[0], CONST_256);
  1271. vis_faligndata(TMP2, TMP4, REF_6);
  1272. height >>= 1;
  1274. do { /* 31 cycles */
  1275. vis_ld64_2(ref, stride, TMP0);
  1276. vis_pmerge(ZERO,       REF_2,     TMP12);
  1277. vis_mul8x16au(REF_2_1, CONST_256, TMP14);
  1279. vis_ld64_2(ref, stride_8, TMP2);
  1280. vis_pmerge(ZERO,       REF_6,     TMP16);
  1281. vis_mul8x16au(REF_6_1, CONST_256, TMP18);
  1283. vis_ld64_2(ref, stride_16, TMP4);
  1284. ref += stride;
  1286. vis_ld64(dest[0], DST_0);
  1287. vis_faligndata(TMP0, TMP2, REF_0);
  1289. vis_ld64_2(dest, 8, DST_2);
  1290. vis_faligndata(TMP2, TMP4, REF_4);
  1292. vis_ld64_2(ref, stride, TMP6);
  1293. vis_pmerge(ZERO,     REF_0,     TMP0);
  1294. vis_mul8x16au(REF_0_1, CONST_256, TMP2);
  1296. vis_ld64_2(ref, stride_8, TMP8);
  1297. vis_pmerge(ZERO,     REF_4,     TMP4);
  1299. vis_ld64_2(ref, stride_16, TMP10);
  1300. ref += stride;
  1302. vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
  1303. vis_faligndata(TMP6, TMP8, REF_2);
  1304. vis_mul8x16au(REF_4_1, CONST_256, TMP6);
  1306. vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
  1307. vis_faligndata(TMP8, TMP10, REF_6);
  1308. vis_mul8x16al(DST_0,   CONST_512, TMP20);
  1310. vis_padd16(TMP0, CONST_3, TMP0);
  1311. vis_mul8x16al(DST_1,   CONST_512, TMP22);
  1313. vis_padd16(TMP2, CONST_3, TMP2);
  1314. vis_mul8x16al(DST_2,   CONST_512, TMP24);
  1316. vis_padd16(TMP4, CONST_3, TMP4);
  1317. vis_mul8x16al(DST_3,   CONST_512, TMP26);
  1319. vis_padd16(TMP6, CONST_3, TMP6);
  1321. vis_padd16(TMP12, TMP20, TMP12);
  1322. vis_mul8x16al(REF_S0,   CONST_512, TMP20);
  1324. vis_padd16(TMP14, TMP22, TMP14);
  1325. vis_mul8x16al(REF_S0_1, CONST_512, TMP22);
  1327. vis_padd16(TMP16, TMP24, TMP16);
  1328. vis_mul8x16al(REF_S2,   CONST_512, TMP24);
  1330. vis_padd16(TMP18, TMP26, TMP18);
  1331. vis_mul8x16al(REF_S2_1, CONST_512, TMP26);
  1333. vis_padd16(TMP12, TMP0, TMP12);
  1334. vis_mul8x16au(REF_2,   CONST_256, TMP28);
  1336. vis_padd16(TMP14, TMP2, TMP14);
  1337. vis_mul8x16au(REF_2_1, CONST_256, TMP30);
  1339. vis_padd16(TMP16, TMP4, TMP16);
  1340. vis_mul8x16au(REF_6,   CONST_256, REF_S4);
  1342. vis_padd16(TMP18, TMP6, TMP18);
  1343. vis_mul8x16au(REF_6_1, CONST_256, REF_S6);
  1345. vis_pack16(TMP12, DST_0);
  1346. vis_padd16(TMP28, TMP0, TMP12);
  1348. vis_pack16(TMP14, DST_1);
  1349. vis_st64(DST_0, dest[0]);
  1350. vis_padd16(TMP30, TMP2, TMP14);
  1352. vis_pack16(TMP16, DST_2);
  1353. vis_padd16(REF_S4, TMP4, TMP16);
  1355. vis_pack16(TMP18, DST_3);
  1356. vis_st64_2(DST_2, dest, 8);
  1357. dest += stride;
  1358. vis_padd16(REF_S6, TMP6, TMP18);
  1360. vis_padd16(TMP12, TMP20, TMP12);
  1362. vis_padd16(TMP14, TMP22, TMP14);
  1363. vis_pack16(TMP12, DST_0);
  1365. vis_padd16(TMP16, TMP24, TMP16);
  1366. vis_pack16(TMP14, DST_1);
  1367. vis_st64(DST_0, dest[0]);
  1369. vis_padd16(TMP18, TMP26, TMP18);
  1370. vis_pack16(TMP16, DST_2);
  1372. vis_pack16(TMP18, DST_3);
  1373. vis_st64_2(DST_2, dest, 8);
  1374. dest += stride;
  1375. } while (--height);
  1376. }
  1378. static void MC_avg_y_8_vis (uint8_t * dest, const uint8_t * _ref,
  1379.     const int stride, int height)
  1380. {
  1381. uint8_t *ref = (uint8_t *) _ref;
  1382. int stride_8 = stride + 8;
  1384. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  1386. ref = vis_alignaddr(ref);
  1388. vis_ld64(ref[ 0], TMP0);
  1389. vis_fzero(ZERO);
  1391. vis_ld64(ref[ 8], TMP2);
  1393. vis_ld64(constants3[0], CONST_3);
  1394. vis_faligndata(TMP0, TMP2, REF_2);
  1396. vis_ld64(constants256_512[0], CONST_256);
  1398. height >>= 1;
  1399. do { /* 20 cycles */
  1400. vis_ld64_2(ref, stride, TMP0);
  1401. vis_pmerge(ZERO,       REF_2,     TMP8);
  1402. vis_mul8x16au(REF_2_1, CONST_256, TMP10);
  1404. vis_ld64_2(ref, stride_8, TMP2);
  1405. ref += stride;
  1407. vis_ld64(dest[0], DST_0);
  1409. vis_ld64_2(dest, stride, DST_2);
  1410. vis_faligndata(TMP0, TMP2, REF_0);
  1412. vis_ld64_2(ref, stride, TMP4);
  1413. vis_mul8x16al(DST_0,   CONST_512, TMP16);
  1414. vis_pmerge(ZERO,       REF_0,     TMP12);
  1416. vis_ld64_2(ref, stride_8, TMP6);
  1417. ref += stride;
  1418. vis_mul8x16al(DST_1,   CONST_512, TMP18);
  1419. vis_pmerge(ZERO,       REF_0_1,   TMP14);
  1421. vis_padd16(TMP12, CONST_3, TMP12);
  1422. vis_mul8x16al(DST_2,   CONST_512, TMP24);
  1424. vis_padd16(TMP14, CONST_3, TMP14);
  1425. vis_mul8x16al(DST_3,   CONST_512, TMP26);
  1427. vis_faligndata(TMP4, TMP6, REF_2);
  1429. vis_padd16(TMP8, TMP12, TMP8);
  1431. vis_padd16(TMP10, TMP14, TMP10);
  1432. vis_mul8x16au(REF_2,   CONST_256, TMP20);
  1434. vis_padd16(TMP8, TMP16, TMP0);
  1435. vis_mul8x16au(REF_2_1, CONST_256, TMP22);
  1437. vis_padd16(TMP10, TMP18, TMP2);
  1438. vis_pack16(TMP0, DST_0);
  1440. vis_pack16(TMP2, DST_1);
  1441. vis_st64(DST_0, dest[0]);
  1442. dest += stride;
  1443. vis_padd16(TMP12, TMP20, TMP12);
  1445. vis_padd16(TMP14, TMP22, TMP14);
  1447. vis_padd16(TMP12, TMP24, TMP0);
  1449. vis_padd16(TMP14, TMP26, TMP2);
  1450. vis_pack16(TMP0, DST_2);
  1452. vis_pack16(TMP2, DST_3);
  1453. vis_st64(DST_2, dest[0]);
  1454. dest += stride;
  1455. } while (--height);
  1456. }
  1458. static void MC_put_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
  1459.       const int stride, int height)
  1460. {
  1461. uint8_t *ref = (uint8_t *) _ref;
  1462. unsigned long off = (unsigned long) ref & 0x7;
  1463. unsigned long off_plus_1 = off + 1;
  1464. int stride_8 = stride + 8;
  1465. int stride_16 = stride + 16;
  1467. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  1469. ref = vis_alignaddr(ref);
  1471. vis_ld64(ref[ 0], TMP0);
  1472. vis_fzero(ZERO);
  1474. vis_ld64(ref[ 8], TMP2);
  1476. vis_ld64(ref[16], TMP4);
  1478. vis_ld64(constants2[0], CONST_2);
  1479. vis_faligndata(TMP0, TMP2, REF_S0);
  1481. vis_ld64(constants256_512[0], CONST_256);
  1482. vis_faligndata(TMP2, TMP4, REF_S4);
  1484. if (off != 0x7) {
  1485. vis_alignaddr_g0((void *)off_plus_1);
  1486. vis_faligndata(TMP0, TMP2, REF_S2);
  1487. vis_faligndata(TMP2, TMP4, REF_S6);
  1488. } else {
  1489. vis_src1(TMP2, REF_S2);
  1490. vis_src1(TMP4, REF_S6);
  1491. }
  1493. height >>= 1;
  1494. do {
  1495. vis_ld64_2(ref, stride, TMP0);
  1496. vis_mul8x16au(REF_S0, CONST_256, TMP12);
  1497. vis_pmerge(ZERO,      REF_S0_1,  TMP14);
  1499. vis_alignaddr_g0((void *)off);
  1501. vis_ld64_2(ref, stride_8, TMP2);
  1502. vis_mul8x16au(REF_S2, CONST_256, TMP16);
  1503. vis_pmerge(ZERO,      REF_S2_1,  TMP18);
  1505. vis_ld64_2(ref, stride_16, TMP4);
  1506. ref += stride;
  1507. vis_mul8x16au(REF_S4, CONST_256, TMP20);
  1508. vis_pmerge(ZERO,      REF_S4_1,  TMP22);
  1510. vis_ld64_2(ref, stride, TMP6);
  1511. vis_mul8x16au(REF_S6, CONST_256, TMP24);
  1512. vis_pmerge(ZERO,      REF_S6_1,  TMP26);
  1514. vis_ld64_2(ref, stride_8, TMP8);
  1515. vis_faligndata(TMP0, TMP2, REF_0);
  1517. vis_ld64_2(ref, stride_16, TMP10);
  1518. ref += stride;
  1519. vis_faligndata(TMP2, TMP4, REF_4);
  1521. vis_faligndata(TMP6, TMP8, REF_S0);
  1523. vis_faligndata(TMP8, TMP10, REF_S4);
  1525. if (off != 0x7) {
  1526. vis_alignaddr_g0((void *)off_plus_1);
  1527. vis_faligndata(TMP0, TMP2, REF_2);
  1528. vis_faligndata(TMP2, TMP4, REF_6);
  1529. vis_faligndata(TMP6, TMP8, REF_S2);
  1530. vis_faligndata(TMP8, TMP10, REF_S6);
  1531. } else {
  1532. vis_src1(TMP2, REF_2);
  1533. vis_src1(TMP4, REF_6);
  1534. vis_src1(TMP8, REF_S2);
  1535. vis_src1(TMP10, REF_S6);
  1536. }
  1538. vis_mul8x16au(REF_0, CONST_256, TMP0);
  1539. vis_pmerge(ZERO,      REF_0_1,  TMP2);
  1541. vis_mul8x16au(REF_2, CONST_256, TMP4);
  1542. vis_pmerge(ZERO,      REF_2_1,  TMP6);
  1544. vis_padd16(TMP0, CONST_2, TMP8);
  1545. vis_mul8x16au(REF_4, CONST_256, TMP0);
  1547. vis_padd16(TMP2, CONST_2, TMP10);
  1548. vis_mul8x16au(REF_4_1, CONST_256, TMP2);
  1550. vis_padd16(TMP8, TMP4, TMP8);
  1551. vis_mul8x16au(REF_6, CONST_256, TMP4);
  1553. vis_padd16(TMP10, TMP6, TMP10);
  1554. vis_mul8x16au(REF_6_1, CONST_256, TMP6);
  1556. vis_padd16(TMP12, TMP8, TMP12);
  1558. vis_padd16(TMP14, TMP10, TMP14);
  1560. vis_padd16(TMP12, TMP16, TMP12);
  1562. vis_padd16(TMP14, TMP18, TMP14);
  1563. vis_pack16(TMP12, DST_0);
  1565. vis_pack16(TMP14, DST_1);
  1566. vis_st64(DST_0, dest[0]);
  1567. vis_padd16(TMP0, CONST_2, TMP12);
  1569. vis_mul8x16au(REF_S0, CONST_256, TMP0);
  1570. vis_padd16(TMP2, CONST_2, TMP14);
  1572. vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
  1573. vis_padd16(TMP12, TMP4, TMP12);
  1575. vis_mul8x16au(REF_S2, CONST_256, TMP4);
  1576. vis_padd16(TMP14, TMP6, TMP14);
  1578. vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
  1579. vis_padd16(TMP20, TMP12, TMP20);
  1581. vis_padd16(TMP22, TMP14, TMP22);
  1583. vis_padd16(TMP20, TMP24, TMP20);
  1585. vis_padd16(TMP22, TMP26, TMP22);
  1586. vis_pack16(TMP20, DST_2);
  1588. vis_pack16(TMP22, DST_3);
  1589. vis_st64_2(DST_2, dest, 8);
  1590. dest += stride;
  1591. vis_padd16(TMP0, TMP4, TMP24);
  1593. vis_mul8x16au(REF_S4, CONST_256, TMP0);
  1594. vis_padd16(TMP2, TMP6, TMP26);
  1596. vis_mul8x16au(REF_S4_1, CONST_256, TMP2);
  1597. vis_padd16(TMP24, TMP8, TMP24);
  1599. vis_padd16(TMP26, TMP10, TMP26);
  1600. vis_pack16(TMP24, DST_0);
  1602. vis_pack16(TMP26, DST_1);
  1603. vis_st64(DST_0, dest[0]);
  1604. vis_pmerge(ZERO, REF_S6, TMP4);
  1606. vis_pmerge(ZERO,      REF_S6_1,  TMP6);
  1608. vis_padd16(TMP0, TMP4, TMP0);
  1610. vis_padd16(TMP2, TMP6, TMP2);
  1612. vis_padd16(TMP0, TMP12, TMP0);
  1614. vis_padd16(TMP2, TMP14, TMP2);
  1615. vis_pack16(TMP0, DST_2);
  1617. vis_pack16(TMP2, DST_3);
  1618. vis_st64_2(DST_2, dest, 8);
  1619. dest += stride;
  1620. } while (--height);
  1621. }
  1623. static void MC_put_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
  1624.      const int stride, int height)
  1625. {
  1626. uint8_t *ref = (uint8_t *) _ref;
  1627. unsigned long off = (unsigned long) ref & 0x7;
  1628. unsigned long off_plus_1 = off + 1;
  1629. int stride_8 = stride + 8;
  1631. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  1633. ref = vis_alignaddr(ref);
  1635. vis_ld64(ref[ 0], TMP0);
  1636. vis_fzero(ZERO);
  1638. vis_ld64(ref[ 8], TMP2);
  1640. vis_ld64(constants2[0], CONST_2);
  1642. vis_ld64(constants256_512[0], CONST_256);
  1643. vis_faligndata(TMP0, TMP2, REF_S0);
  1645. if (off != 0x7) {
  1646. vis_alignaddr_g0((void *)off_plus_1);
  1647. vis_faligndata(TMP0, TMP2, REF_S2);
  1648. } else {
  1649. vis_src1(TMP2, REF_S2);
  1650. }
  1652. height >>= 1;
  1653. do { /* 26 cycles */
  1654. vis_ld64_2(ref, stride, TMP0);
  1655. vis_mul8x16au(REF_S0,   CONST_256, TMP8);
  1656. vis_pmerge(ZERO,        REF_S2,    TMP12);
  1658. vis_alignaddr_g0((void *)off);
  1660. vis_ld64_2(ref, stride_8, TMP2);
  1661. ref += stride;
  1662. vis_mul8x16au(REF_S0_1, CONST_256, TMP10);
  1663. vis_pmerge(ZERO,        REF_S2_1,  TMP14);
  1665. vis_ld64_2(ref, stride, TMP4);
  1667. vis_ld64_2(ref, stride_8, TMP6);
  1668. ref += stride;
  1669. vis_faligndata(TMP0, TMP2, REF_S4);
  1671. vis_pmerge(ZERO, REF_S4, TMP18);
  1673. vis_pmerge(ZERO, REF_S4_1, TMP20);
  1675. vis_faligndata(TMP4, TMP6, REF_S0);
  1677. if (off != 0x7) {
  1678. vis_alignaddr_g0((void *)off_plus_1);
  1679. vis_faligndata(TMP0, TMP2, REF_S6);
  1680. vis_faligndata(TMP4, TMP6, REF_S2);
  1681. } else {
  1682. vis_src1(TMP2, REF_S6);
  1683. vis_src1(TMP6, REF_S2);
  1684. }
  1686. vis_padd16(TMP18, CONST_2, TMP18);
  1687. vis_mul8x16au(REF_S6,   CONST_256, TMP22);
  1689. vis_padd16(TMP20, CONST_2, TMP20);
  1690. vis_mul8x16au(REF_S6_1, CONST_256, TMP24);
  1692. vis_mul8x16au(REF_S0,   CONST_256, TMP26);
  1693. vis_pmerge(ZERO, REF_S0_1, TMP28);
  1695. vis_mul8x16au(REF_S2,   CONST_256, TMP30);
  1696. vis_padd16(TMP18, TMP22, TMP18);
  1698. vis_mul8x16au(REF_S2_1, CONST_256, TMP32);
  1699. vis_padd16(TMP20, TMP24, TMP20);
  1701. vis_padd16(TMP8,  TMP18, TMP8);
  1703. vis_padd16(TMP10, TMP20, TMP10);
  1705. vis_padd16(TMP8,  TMP12, TMP8);
  1707. vis_padd16(TMP10, TMP14, TMP10);
  1708. vis_pack16(TMP8,  DST_0);
  1710. vis_pack16(TMP10, DST_1);
  1711. vis_st64(DST_0, dest[0]);
  1712. dest += stride;
  1713. vis_padd16(TMP18, TMP26, TMP18);
  1715. vis_padd16(TMP20, TMP28, TMP20);
  1717. vis_padd16(TMP18, TMP30, TMP18);
  1719. vis_padd16(TMP20, TMP32, TMP20);
  1720. vis_pack16(TMP18, DST_2);
  1722. vis_pack16(TMP20, DST_3);
  1723. vis_st64(DST_2, dest[0]);
  1724. dest += stride;
  1725. } while (--height);
  1726. }
  1728. static void MC_avg_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
  1729.       const int stride, int height)
  1730. {
  1731. uint8_t *ref = (uint8_t *) _ref;
  1732. unsigned long off = (unsigned long) ref & 0x7;
  1733. unsigned long off_plus_1 = off + 1;
  1734. int stride_8 = stride + 8;
  1735. int stride_16 = stride + 16;
  1737. vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
  1739. ref = vis_alignaddr(ref);
  1741. vis_ld64(ref[ 0], TMP0);
  1742. vis_fzero(ZERO);
  1744. vis_ld64(ref[ 8], TMP2);
  1746. vis_ld64(ref[16], TMP4);
  1748. vis_ld64(constants6[0], CONST_6);
  1749. vis_faligndata(TMP0, TMP2, REF_S0);
  1751. vis_ld64(constants256_1024[0], CONST_256);
  1752. vis_faligndata(TMP2, TMP4, REF_S4);
  1754. if (off != 0x7) {
  1755. vis_alignaddr_g0((void *)off_plus_1);
  1756. vis_faligndata(TMP0, TMP2, REF_S2);
  1757. vis_faligndata(TMP2, TMP4, REF_S6);
  1758. } else {
  1759. vis_src1(TMP2, REF_S2);
  1760. vis_src1(TMP4, REF_S6);
  1761. }
  1763. height >>= 1;
  1764. do { /* 55 cycles */
  1765. vis_ld64_2(ref, stride, TMP0);
  1766. vis_mul8x16au(REF_S0, CONST_256, TMP12);
  1767. vis_pmerge(ZERO,      REF_S0_1,  TMP14);
  1769. vis_alignaddr_g0((void *)off);
  1771. vis_ld64_2(ref, stride_8, TMP2);
  1772. vis_mul8x16au(REF_S2, CONST_256, TMP16);
  1773. vis_pmerge(ZERO,      REF_S2_1,  TMP18);
  1775. vis_ld64_2(ref, stride_16, TMP4);
  1776. ref += stride;
  1777. vis_mul8x16au(REF_S4, CONST_256, TMP20);
  1778. vis_pmerge(ZERO,      REF_S4_1,  TMP22);
  1780. vis_ld64_2(ref, stride, TMP6);
  1781. vis_mul8x16au(REF_S6, CONST_256, TMP24);
  1782. vis_pmerge(ZERO,      REF_S6_1,  TMP26);
  1784. vis_ld64_2(ref, stride_8, TMP8);
  1785. vis_faligndata(TMP0, TMP2, REF_0);
  1787. vis_ld64_2(ref, stride_16, TMP10);
  1788. ref += stride;
  1789. vis_faligndata(TMP2, TMP4, REF_4);
  1791. vis_ld64(dest[0], DST_0);
  1792. vis_faligndata(TMP6, TMP8, REF_S0);
  1794. vis_ld64_2(dest, 8, DST_2);
  1795. vis_faligndata(TMP8, TMP10, REF_S4);
  1797. if (off != 0x7) {
  1798. vis_alignaddr_g0((void *)off_plus_1);
  1799. vis_faligndata(TMP0, TMP2, REF_2);
  1800. vis_faligndata(TMP2, TMP4, REF_6);
  1801. vis_faligndata(TMP6, TMP8, REF_S2);
  1802. vis_faligndata(TMP8, TMP10, REF_S6);
  1803. } else {
  1804. vis_src1(TMP2, REF_2);
  1805. vis_src1(TMP4, REF_6);
  1806. vis_src1(TMP8, REF_S2);
  1807. vis_src1(TMP10, REF_S6);
  1808. }
  1810. vis_mul8x16al(DST_0,   CONST_1024, TMP30);
  1811. vis_pmerge(ZERO, REF_0, TMP0);
  1813. vis_mul8x16al(DST_1,   CONST_1024, TMP32);
  1814. vis_pmerge(ZERO,      REF_0_1,  TMP2);
  1816. vis_mul8x16au(REF_2, CONST_256, TMP4);
  1817. vis_pmerge(ZERO,      REF_2_1,  TMP6);
  1819. vis_mul8x16al(DST_2,   CONST_1024, REF_0);
  1820. vis_padd16(TMP0, CONST_6, TMP0);
  1822. vis_mul8x16al(DST_3,   CONST_1024, REF_2);
  1823. vis_padd16(TMP2, CONST_6, TMP2);
  1825. vis_padd16(TMP0, TMP4, TMP0);
  1826. vis_mul8x16au(REF_4, CONST_256, TMP4);
  1828. vis_padd16(TMP2, TMP6, TMP2);
  1829. vis_mul8x16au(REF_4_1, CONST_256, TMP6);
  1831. vis_padd16(TMP12, TMP0, TMP12);
  1832. vis_mul8x16au(REF_6, CONST_256, TMP8);
  1834. vis_padd16(TMP14, TMP2, TMP14);
  1835. vis_mul8x16au(REF_6_1, CONST_256, TMP10);
  1837. vis_padd16(TMP12, TMP16, TMP12);
  1838. vis_mul8x16au(REF_S0, CONST_256, REF_4);
  1840. vis_padd16(TMP14, TMP18, TMP14);
  1841. vis_mul8x16au(REF_S0_1, CONST_256, REF_6);
  1843. vis_padd16(TMP12, TMP30, TMP12);
  1845. vis_padd16(TMP14, TMP32, TMP14);
  1846. vis_pack16(TMP12, DST_0);
  1848. vis_pack16(TMP14, DST_1);
  1849. vis_st64(DST_0, dest[0]);
  1850. vis_padd16(TMP4, CONST_6, TMP4);
  1852. vis_ld64_2(dest, stride, DST_0);
  1853. vis_padd16(TMP6, CONST_6, TMP6);
  1854. vis_mul8x16au(REF_S2, CONST_256, TMP12);
  1856. vis_padd16(TMP4, TMP8, TMP4);
  1857. vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);
  1859. vis_padd16(TMP6, TMP10, TMP6);
  1861. vis_padd16(TMP20, TMP4, TMP20);
  1863. vis_padd16(TMP22, TMP6, TMP22);
  1865. vis_padd16(TMP20, TMP24, TMP20);
  1867. vis_padd16(TMP22, TMP26, TMP22);
  1869. vis_padd16(TMP20, REF_0, TMP20);
  1870. vis_mul8x16au(REF_S4, CONST_256, REF_0);
  1872. vis_padd16(TMP22, REF_2, TMP22);
  1873. vis_pack16(TMP20, DST_2);
  1875. vis_pack16(TMP22, DST_3);
  1876. vis_st64_2(DST_2, dest, 8);
  1877. dest += stride;
  1879. vis_ld64_2(dest, 8, DST_2);
  1880. vis_mul8x16al(DST_0,   CONST_1024, TMP30);
  1881. vis_pmerge(ZERO,      REF_S4_1,  REF_2);
  1883. vis_mul8x16al(DST_1,   CONST_1024, TMP32);
  1884. vis_padd16(REF_4, TMP0, TMP8);
  1886. vis_mul8x16au(REF_S6, CONST_256, REF_4);
  1887. vis_padd16(REF_6, TMP2, TMP10);
  1889. vis_mul8x16au(REF_S6_1, CONST_256, REF_6);
  1890. vis_padd16(TMP8, TMP12, TMP8);
  1892. vis_padd16(TMP10, TMP14, TMP10);
  1894. vis_padd16(TMP8, TMP30, TMP8);
  1896. vis_padd16(TMP10, TMP32, TMP10);
  1897. vis_pack16(TMP8, DST_0);
  1899. vis_pack16(TMP10, DST_1);
  1900. vis_st64(DST_0, dest[0]);
  1902. vis_padd16(REF_0, TMP4, REF_0);
  1904. vis_mul8x16al(DST_2,   CONST_1024, TMP30);
  1905. vis_padd16(REF_2, TMP6, REF_2);
  1907. vis_mul8x16al(DST_3,   CONST_1024, TMP32);
  1908. vis_padd16(REF_0, REF_4, REF_0);
  1910. vis_padd16(REF_2, REF_6, REF_2);
  1912. vis_padd16(REF_0, TMP30, REF_0);
  1914. /* stall */
  1916. vis_padd16(REF_2, TMP32, REF_2);
  1917. vis_pack16(REF_0, DST_2);
  1919. vis_pack16(REF_2, DST_3);
  1920. vis_st64_2(DST_2, dest, 8);
  1921. dest += stride;
  1922. } while (--height);
  1923. }
  1925. static void MC_avg_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
  1926.      const int stride, int height)
  1927. {
  1928. uint8_t *ref = (uint8_t *) _ref;
  1929. unsigned long off = (unsigned long) ref & 0x7;
  1930. unsigned long off_plus_1 = off + 1;
  1931. int stride_8 = stride + 8;
  1933. vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
  1935. ref = vis_alignaddr(ref);
  1937. vis_ld64(ref[0], TMP0);
  1938. vis_fzero(ZERO);
  1940. vis_ld64_2(ref, 8, TMP2);
  1942. vis_ld64(constants6[0], CONST_6);
  1944. vis_ld64(constants256_1024[0], CONST_256);
  1945. vis_faligndata(TMP0, TMP2, REF_S0);
  1947. if (off != 0x7) {
  1948. vis_alignaddr_g0((void *)off_plus_1);
  1949. vis_faligndata(TMP0, TMP2, REF_S2);
  1950. } else {
  1951. vis_src1(TMP2, REF_S2);
  1952. }
  1954. height >>= 1;
  1955. do { /* 31 cycles */
  1956. vis_ld64_2(ref, stride, TMP0);
  1957. vis_mul8x16au(REF_S0, CONST_256, TMP8);
  1958. vis_pmerge(ZERO,      REF_S0_1,  TMP10);
  1960. vis_ld64_2(ref, stride_8, TMP2);
  1961. ref += stride;
  1962. vis_mul8x16au(REF_S2, CONST_256, TMP12);
  1963. vis_pmerge(ZERO,      REF_S2_1,  TMP14);
  1965. vis_alignaddr_g0((void *)off);
  1967. vis_ld64_2(ref, stride, TMP4);
  1968. vis_faligndata(TMP0, TMP2, REF_S4);
  1970. vis_ld64_2(ref, stride_8, TMP6);
  1971. ref += stride;
  1973. vis_ld64(dest[0], DST_0);
  1974. vis_faligndata(TMP4, TMP6, REF_S0);
  1976. vis_ld64_2(dest, stride, DST_2);
  1978. if (off != 0x7) {
  1979. vis_alignaddr_g0((void *)off_plus_1);
  1980. vis_faligndata(TMP0, TMP2, REF_S6);
  1981. vis_faligndata(TMP4, TMP6, REF_S2);
  1982. } else {
  1983. vis_src1(TMP2, REF_S6);
  1984. vis_src1(TMP6, REF_S2);
  1985. }
  1987. vis_mul8x16al(DST_0,   CONST_1024, TMP30);
  1988. vis_pmerge(ZERO, REF_S4, TMP22);
  1990. vis_mul8x16al(DST_1,   CONST_1024, TMP32);
  1991. vis_pmerge(ZERO,      REF_S4_1,  TMP24);
  1993. vis_mul8x16au(REF_S6, CONST_256, TMP26);
  1994. vis_pmerge(ZERO,      REF_S6_1,  TMP28);
  1996. vis_mul8x16au(REF_S0, CONST_256, REF_S4);
  1997. vis_padd16(TMP22, CONST_6, TMP22);
  1999. vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);
  2000. vis_padd16(TMP24, CONST_6, TMP24);
  2002. vis_mul8x16al(DST_2,   CONST_1024, REF_0);
  2003. vis_padd16(TMP22, TMP26, TMP22);
  2005. vis_mul8x16al(DST_3,   CONST_1024, REF_2);
  2006. vis_padd16(TMP24, TMP28, TMP24);
  2008. vis_mul8x16au(REF_S2, CONST_256, TMP26);
  2009. vis_padd16(TMP8, TMP22, TMP8);
  2011. vis_mul8x16au(REF_S2_1, CONST_256, TMP28);
  2012. vis_padd16(TMP10, TMP24, TMP10);
  2014. vis_padd16(TMP8, TMP12, TMP8);
  2016. vis_padd16(TMP10, TMP14, TMP10);
  2018. vis_padd16(TMP8, TMP30, TMP8);
  2020. vis_padd16(TMP10, TMP32, TMP10);
  2021. vis_pack16(TMP8, DST_0);
  2023. vis_pack16(TMP10, DST_1);
  2024. vis_st64(DST_0, dest[0]);
  2025. dest += stride;
  2027. vis_padd16(REF_S4, TMP22, TMP12);
  2029. vis_padd16(REF_S6, TMP24, TMP14);
  2031. vis_padd16(TMP12, TMP26, TMP12);
  2033. vis_padd16(TMP14, TMP28, TMP14);
  2035. vis_padd16(TMP12, REF_0, TMP12);
  2037. vis_padd16(TMP14, REF_2, TMP14);
  2038. vis_pack16(TMP12, DST_2);
  2040. vis_pack16(TMP14, DST_3);
  2041. vis_st64(DST_2, dest[0]);
  2042. dest += stride;
  2043. } while (--height);
  2044. }
  2046. /* End of rounding code */
  2048. /* Start of no rounding code */
  2049. /* The trick used in some of this file is the formula from the MMX
  2050.  * motion comp code, which is:
  2051.  *
  2052.  * (x+y)>>1 == (x&y)+((x^y)>>1)
  2053.  *
  2054.  * This allows us to average 8 bytes at a time in a 64-bit FPU reg.
  2055.  * We avoid overflows by masking before we do the shift, and we
  2056.  * implement the shift by multiplying by 1/2 using mul8x16.  So in
  2057.  * VIS this is (assume 'x' is in f0, 'y' is in f2, a repeating mask
  2058.  * of '0xfe' is in f4, a repeating mask of '0x7f' is in f6, and
  2059.  * the value 0x80808080 is in f8):
  2060.  *
  2061.  * fxor f0, f2, f10
  2062.  * fand f10, f4, f10
  2063.  * fmul8x16 f8, f10, f10
  2064.  * fand f10, f6, f10
  2065.  * fand f0, f2, f12
  2066.  * fpadd16 f12, f10, f10
  2067.  */
  2069. static void MC_put_no_round_o_16_vis (uint8_t * dest, const uint8_t * _ref,
  2070.       const int stride, int height)
  2071. {
  2072. uint8_t *ref = (uint8_t *) _ref;
  2074. ref = vis_alignaddr(ref);
  2075. do { /* 5 cycles */
  2076. vis_ld64(ref[0], TMP0);
  2078. vis_ld64_2(ref, 8, TMP2);
  2080. vis_ld64_2(ref, 16, TMP4);
  2081. ref += stride;
  2083. vis_faligndata(TMP0, TMP2, REF_0);
  2084. vis_st64(REF_0, dest[0]);
  2086. vis_faligndata(TMP2, TMP4, REF_2);
  2087. vis_st64_2(REF_2, dest, 8);
  2088. dest += stride;
  2089. } while (--height);
  2090. }
  2092. static void MC_put_no_round_o_8_vis (uint8_t * dest, const uint8_t * _ref,
  2093.     const int stride, int height)
  2094. {
  2095. uint8_t *ref = (uint8_t *) _ref;
  2097. ref = vis_alignaddr(ref);
  2098. do { /* 4 cycles */
  2099. vis_ld64(ref[0], TMP0);
  2101. vis_ld64(ref[8], TMP2);
  2102. ref += stride;
  2104. /* stall */
  2106. vis_faligndata(TMP0, TMP2, REF_0);
  2107. vis_st64(REF_0, dest[0]);
  2108. dest += stride;
  2109. } while (--height);
  2110. }
  2113. static void MC_avg_no_round_o_16_vis (uint8_t * dest, const uint8_t * _ref,
  2114.      const int stride, int height)
  2115. {
  2116. uint8_t *ref = (uint8_t *) _ref;
  2117. int stride_8 = stride + 8;
  2119. ref = vis_alignaddr(ref);
  2121. vis_ld64(ref[0], TMP0);
  2123. vis_ld64(ref[8], TMP2);
  2125. vis_ld64(ref[16], TMP4);
  2127. vis_ld64(dest[0], DST_0);
  2129. vis_ld64(dest[8], DST_2);
  2131. vis_ld64(constants_fe[0], MASK_fe);
  2132. vis_faligndata(TMP0, TMP2, REF_0);
  2134. vis_ld64(constants_7f[0], MASK_7f);
  2135. vis_faligndata(TMP2, TMP4, REF_2);
  2137. vis_ld64(constants128[0], CONST_128);
  2139. ref += stride;
  2140. height = (height >> 1) - 1;
  2142. do { /* 24 cycles */
  2143. vis_ld64(ref[0], TMP0);
  2144. vis_xor(DST_0, REF_0, TMP6);
  2146. vis_ld64_2(ref, 8, TMP2);
  2147. vis_and(TMP6, MASK_fe, TMP6);
  2149. vis_ld64_2(ref, 16, TMP4);
  2150. ref += stride;
  2151. vis_mul8x16(CONST_128, TMP6, TMP6);
  2152. vis_xor(DST_2, REF_2, TMP8);
  2154. vis_and(TMP8, MASK_fe, TMP8);
  2156. vis_and(DST_0, REF_0, TMP10);
  2157. vis_ld64_2(dest, stride, DST_0);
  2158. vis_mul8x16(CONST_128, TMP8, TMP8);
  2160. vis_and(DST_2, REF_2, TMP12);
  2161. vis_ld64_2(dest, stride_8, DST_2);
  2163. vis_ld64(ref[0], TMP14);
  2164. vis_and(TMP6, MASK_7f, TMP6);
  2166. vis_and(TMP8, MASK_7f, TMP8);
  2168. vis_padd16(TMP10, TMP6, TMP6);
  2169. vis_st64(TMP6, dest[0]);
  2171. vis_padd16(TMP12, TMP8, TMP8);
  2172. vis_st64_2(TMP8, dest, 8);
  2174. dest += stride;
  2175. vis_ld64_2(ref, 8, TMP16);
  2176. vis_faligndata(TMP0, TMP2, REF_0);
  2178. vis_ld64_2(ref, 16, TMP18);
  2179. vis_faligndata(TMP2, TMP4, REF_2);
  2180. ref += stride;
  2182. vis_xor(DST_0, REF_0, TMP20);
  2184. vis_and(TMP20, MASK_fe, TMP20);
  2186. vis_xor(DST_2, REF_2, TMP22);
  2187. vis_mul8x16(CONST_128, TMP20, TMP20);
  2189. vis_and(TMP22, MASK_fe, TMP22);
  2191. vis_and(DST_0, REF_0, TMP24);
  2192. vis_mul8x16(CONST_128, TMP22, TMP22);
  2194. vis_and(DST_2, REF_2, TMP26);
  2196. vis_ld64_2(dest, stride, DST_0);
  2197. vis_faligndata(TMP14, TMP16, REF_0);
  2199. vis_ld64_2(dest, stride_8, DST_2);
  2200. vis_faligndata(TMP16, TMP18, REF_2);
  2202. vis_and(TMP20, MASK_7f, TMP20);
  2204. vis_and(TMP22, MASK_7f, TMP22);
  2206. vis_padd16(TMP24, TMP20, TMP20);
  2207. vis_st64(TMP20, dest[0]);
  2209. vis_padd16(TMP26, TMP22, TMP22);
  2210. vis_st64_2(TMP22, dest, 8);
  2211. dest += stride;
  2212. } while (--height);
  2214. vis_ld64(ref[0], TMP0);
  2215. vis_xor(DST_0, REF_0, TMP6);
  2217. vis_ld64_2(ref, 8, TMP2);
  2218. vis_and(TMP6, MASK_fe, TMP6);
  2220. vis_ld64_2(ref, 16, TMP4);
  2221. vis_mul8x16(CONST_128, TMP6, TMP6);
  2222. vis_xor(DST_2, REF_2, TMP8);
  2224. vis_and(TMP8, MASK_fe, TMP8);
  2226. vis_and(DST_0, REF_0, TMP10);
  2227. vis_ld64_2(dest, stride, DST_0);
  2228. vis_mul8x16(CONST_128, TMP8, TMP8);
  2230. vis_and(DST_2, REF_2, TMP12);
  2231. vis_ld64_2(dest, stride_8, DST_2);
  2233. vis_ld64(ref[0], TMP14);
  2234. vis_and(TMP6, MASK_7f, TMP6);
  2236. vis_and(TMP8, MASK_7f, TMP8);
  2238. vis_padd16(TMP10, TMP6, TMP6);
  2239. vis_st64(TMP6, dest[0]);
  2241. vis_padd16(TMP12, TMP8, TMP8);
  2242. vis_st64_2(TMP8, dest, 8);
  2244. dest += stride;
  2245. vis_faligndata(TMP0, TMP2, REF_0);
  2247. vis_faligndata(TMP2, TMP4, REF_2);
  2249. vis_xor(DST_0, REF_0, TMP20);
  2251. vis_and(TMP20, MASK_fe, TMP20);
  2253. vis_xor(DST_2, REF_2, TMP22);
  2254. vis_mul8x16(CONST_128, TMP20, TMP20);
  2256. vis_and(TMP22, MASK_fe, TMP22);
  2258. vis_and(DST_0, REF_0, TMP24);
  2259. vis_mul8x16(CONST_128, TMP22, TMP22);
  2261. vis_and(DST_2, REF_2, TMP26);
  2263. vis_and(TMP20, MASK_7f, TMP20);
  2265. vis_and(TMP22, MASK_7f, TMP22);
  2267. vis_padd16(TMP24, TMP20, TMP20);
  2268. vis_st64(TMP20, dest[0]);
  2270. vis_padd16(TMP26, TMP22, TMP22);
  2271. vis_st64_2(TMP22, dest, 8);
  2272. }
  2274. static void MC_avg_no_round_o_8_vis (uint8_t * dest, const uint8_t * _ref,
  2275.     const int stride, int height)
  2276. {
  2277. uint8_t *ref = (uint8_t *) _ref;
  2279. ref = vis_alignaddr(ref);
  2281. vis_ld64(ref[0], TMP0);
  2283. vis_ld64(ref[8], TMP2);
  2285. vis_ld64(dest[0], DST_0);
  2287. vis_ld64(constants_fe[0], MASK_fe);
  2289. vis_ld64(constants_7f[0], MASK_7f);
  2290. vis_faligndata(TMP0, TMP2, REF_0);
  2292. vis_ld64(constants128[0], CONST_128);
  2294. ref += stride;
  2295. height = (height >> 1) - 1;
  2297. do { /* 12 cycles */
  2298. vis_ld64(ref[0], TMP0);
  2299. vis_xor(DST_0, REF_0, TMP4);
  2301. vis_ld64(ref[8], TMP2);
  2302. vis_and(TMP4, MASK_fe, TMP4);
  2304. vis_and(DST_0, REF_0, TMP6);
  2305. vis_ld64_2(dest, stride, DST_0);
  2306. ref += stride;
  2307. vis_mul8x16(CONST_128, TMP4, TMP4);
  2309. vis_ld64(ref[0], TMP12);
  2310. vis_faligndata(TMP0, TMP2, REF_0);
  2312. vis_ld64(ref[8], TMP2);
  2313. vis_xor(DST_0, REF_0, TMP0);
  2314. ref += stride;
  2316. vis_and(TMP0, MASK_fe, TMP0);
  2318. vis_and(TMP4, MASK_7f, TMP4);
  2320. vis_padd16(TMP6, TMP4, TMP4);
  2321. vis_st64(TMP4, dest[0]);
  2322. dest += stride;
  2323. vis_mul8x16(CONST_128, TMP0, TMP0);
  2325. vis_and(DST_0, REF_0, TMP6);
  2326. vis_ld64_2(dest, stride, DST_0);
  2328. vis_faligndata(TMP12, TMP2, REF_0);
  2330. vis_and(TMP0, MASK_7f, TMP0);
  2332. vis_padd16(TMP6, TMP0, TMP4);
  2333. vis_st64(TMP4, dest[0]);
  2334. dest += stride;
  2335. } while (--height);
  2337. vis_ld64(ref[0], TMP0);
  2338. vis_xor(DST_0, REF_0, TMP4);
  2340. vis_ld64(ref[8], TMP2);
  2341. vis_and(TMP4, MASK_fe, TMP4);
  2343. vis_and(DST_0, REF_0, TMP6);
  2344. vis_ld64_2(dest, stride, DST_0);
  2345. vis_mul8x16(CONST_128, TMP4, TMP4);
  2347. vis_faligndata(TMP0, TMP2, REF_0);
  2349. vis_xor(DST_0, REF_0, TMP0);
  2351. vis_and(TMP0, MASK_fe, TMP0);
  2353. vis_and(TMP4, MASK_7f, TMP4);
  2355. vis_padd16(TMP6, TMP4, TMP4);
  2356. vis_st64(TMP4, dest[0]);
  2357. dest += stride;
  2358. vis_mul8x16(CONST_128, TMP0, TMP0);
  2360. vis_and(DST_0, REF_0, TMP6);
  2362. vis_and(TMP0, MASK_7f, TMP0);
  2364. vis_padd16(TMP6, TMP0, TMP4);
  2365. vis_st64(TMP4, dest[0]);
  2366. }
  2368. static void MC_put_no_round_x_16_vis (uint8_t * dest, const uint8_t * _ref,
  2369.      const int stride, int height)
  2370. {
  2371. uint8_t *ref = (uint8_t *) _ref;
  2372. unsigned long off = (unsigned long) ref & 0x7;
  2373. unsigned long off_plus_1 = off + 1;
  2375. ref = vis_alignaddr(ref);
  2377. vis_ld64(ref[0],    TMP0);
  2379. vis_ld64_2(ref, 8,  TMP2);
  2381. vis_ld64_2(ref, 16, TMP4);
  2383. vis_ld64(constants_fe[0], MASK_fe);
  2385. vis_ld64(constants_7f[0], MASK_7f);
  2386. vis_faligndata(TMP0, TMP2, REF_0);
  2388. vis_ld64(constants128[0], CONST_128);
  2389. vis_faligndata(TMP2, TMP4, REF_4);
  2391. if (off != 0x7) {
  2392. vis_alignaddr_g0((void *)off_plus_1);
  2393. vis_faligndata(TMP0, TMP2, REF_2);
  2394. vis_faligndata(TMP2, TMP4, REF_6);
  2395. } else {
  2396. vis_src1(TMP2, REF_2);
  2397. vis_src1(TMP4, REF_6);
  2398. }
  2400. ref += stride;
  2401. height = (height >> 1) - 1;
  2403. do { /* 34 cycles */
  2404. vis_ld64(ref[0],    TMP0);
  2405. vis_xor(REF_0, REF_2, TMP6);
  2407. vis_ld64_2(ref, 8,  TMP2);
  2408. vis_xor(REF_4, REF_6, TMP8);
  2410. vis_ld64_2(ref, 16, TMP4);
  2411. vis_and(TMP6, MASK_fe, TMP6);
  2412. ref += stride;
  2414. vis_ld64(ref[0],    TMP14);
  2415. vis_mul8x16(CONST_128, TMP6, TMP6);
  2416. vis_and(TMP8, MASK_fe, TMP8);
  2418. vis_ld64_2(ref, 8,  TMP16);
  2419. vis_mul8x16(CONST_128, TMP8, TMP8);
  2420. vis_and(REF_0, REF_2, TMP10);
  2422. vis_ld64_2(ref, 16, TMP18);
  2423. ref += stride;
  2424. vis_and(REF_4, REF_6, TMP12);
  2426. vis_alignaddr_g0((void *)off);
  2428. vis_faligndata(TMP0, TMP2, REF_0);
  2430. vis_faligndata(TMP2, TMP4, REF_4);
  2432. if (off != 0x7) {
  2433. vis_alignaddr_g0((void *)off_plus_1);
  2434. vis_faligndata(TMP0, TMP2, REF_2);
  2435. vis_faligndata(TMP2, TMP4, REF_6);
  2436. } else {
  2437. vis_src1(TMP2, REF_2);
  2438. vis_src1(TMP4, REF_6);
  2439. }
  2441. vis_and(TMP6, MASK_7f, TMP6);
  2443. vis_and(TMP8, MASK_7f, TMP8);
  2445. vis_padd16(TMP10, TMP6, TMP6);
  2446. vis_st64(TMP6, dest[0]);
  2448. vis_padd16(TMP12, TMP8, TMP8);
  2449. vis_st64_2(TMP8, dest, 8);
  2450. dest += stride;
  2452. vis_xor(REF_0, REF_2, TMP6);
  2454. vis_xor(REF_4, REF_6, TMP8);
  2456. vis_and(TMP6, MASK_fe, TMP6);
  2458. vis_mul8x16(CONST_128, TMP6, TMP6);
  2459. vis_and(TMP8, MASK_fe, TMP8);
  2461. vis_mul8x16(CONST_128, TMP8, TMP8);
  2462. vis_and(REF_0, REF_2, TMP10);
  2464. vis_and(REF_4, REF_6, TMP12);
  2466. vis_alignaddr_g0((void *)off);
  2468. vis_faligndata(TMP14, TMP16, REF_0);
  2470. vis_faligndata(TMP16, TMP18, REF_4);
  2472. if (off != 0x7) {
  2473. vis_alignaddr_g0((void *)off_plus_1);
  2474. vis_faligndata(TMP14, TMP16, REF_2);
  2475. vis_faligndata(TMP16, TMP18, REF_6);
  2476. } else {
  2477. vis_src1(TMP16, REF_2);
  2478. vis_src1(TMP18, REF_6);
  2479. }
  2481. vis_and(TMP6, MASK_7f, TMP6);
  2483. vis_and(TMP8, MASK_7f, TMP8);
  2485. vis_padd16(TMP10, TMP6, TMP6);
  2486. vis_st64(TMP6, dest[0]);
  2488. vis_padd16(TMP12, TMP8, TMP8);
  2489. vis_st64_2(TMP8, dest, 8);
  2490. dest += stride;
  2491. } while (--height);
  2493. vis_ld64(ref[0],    TMP0);
  2494. vis_xor(REF_0, REF_2, TMP6);
  2496. vis_ld64_2(ref, 8,  TMP2);
  2497. vis_xor(REF_4, REF_6, TMP8);
  2499. vis_ld64_2(ref, 16, TMP4);
  2500. vis_and(TMP6, MASK_fe, TMP6);
  2502. vis_mul8x16(CONST_128, TMP6, TMP6);
  2503. vis_and(TMP8, MASK_fe, TMP8);
  2505. vis_mul8x16(CONST_128, TMP8, TMP8);
  2506. vis_and(REF_0, REF_2, TMP10);
  2508. vis_and(REF_4, REF_6, TMP12);
  2510. vis_alignaddr_g0((void *)off);
  2512. vis_faligndata(TMP0, TMP2, REF_0);
  2514. vis_faligndata(TMP2, TMP4, REF_4);
  2516. if (off != 0x7) {
  2517. vis_alignaddr_g0((void *)off_plus_1);
  2518. vis_faligndata(TMP0, TMP2, REF_2);
  2519. vis_faligndata(TMP2, TMP4, REF_6);
  2520. } else {
  2521. vis_src1(TMP2, REF_2);
  2522. vis_src1(TMP4, REF_6);
  2523. }
  2525. vis_and(TMP6, MASK_7f, TMP6);
  2527. vis_and(TMP8, MASK_7f, TMP8);
  2529. vis_padd16(TMP10, TMP6, TMP6);
  2530. vis_st64(TMP6, dest[0]);
  2532. vis_padd16(TMP12, TMP8, TMP8);
  2533. vis_st64_2(TMP8, dest, 8);
  2534. dest += stride;
  2536. vis_xor(REF_0, REF_2, TMP6);
  2538. vis_xor(REF_4, REF_6, TMP8);
  2540. vis_and(TMP6, MASK_fe, TMP6);
  2542. vis_mul8x16(CONST_128, TMP6, TMP6);
  2543. vis_and(TMP8, MASK_fe, TMP8);
  2545. vis_mul8x16(CONST_128, TMP8, TMP8);
  2546. vis_and(REF_0, REF_2, TMP10);
  2548. vis_and(REF_4, REF_6, TMP12);
  2550. vis_and(TMP6, MASK_7f, TMP6);
  2552. vis_and(TMP8, MASK_7f, TMP8);
  2554. vis_padd16(TMP10, TMP6, TMP6);
  2555. vis_st64(TMP6, dest[0]);
  2557. vis_padd16(TMP12, TMP8, TMP8);
  2558. vis_st64_2(TMP8, dest, 8);
  2559. }
  2561. static void MC_put_no_round_x_8_vis (uint8_t * dest, const uint8_t * _ref,
  2562.     const int stride, int height)
  2563. {
  2564. uint8_t *ref = (uint8_t *) _ref;
  2565. unsigned long off = (unsigned long) ref & 0x7;
  2566. unsigned long off_plus_1 = off + 1;
  2568. ref = vis_alignaddr(ref);
  2570. vis_ld64(ref[0], TMP0);
  2572. vis_ld64(ref[8], TMP2);
  2574. vis_ld64(constants_fe[0], MASK_fe);
  2576. vis_ld64(constants_7f[0], MASK_7f);
  2578. vis_ld64(constants128[0], CONST_128);
  2579. vis_faligndata(TMP0, TMP2, REF_0);
  2581. if (off != 0x7) {
  2582. vis_alignaddr_g0((void *)off_plus_1);
  2583. vis_faligndata(TMP0, TMP2, REF_2);
  2584. } else {
  2585. vis_src1(TMP2, REF_2);
  2586. }
  2588. ref += stride;
  2589. height = (height >> 1) - 1;
  2591. do { /* 20 cycles */
  2592. vis_ld64(ref[0], TMP0);
  2593. vis_xor(REF_0, REF_2, TMP4);
  2595. vis_ld64_2(ref, 8, TMP2);
  2596. vis_and(TMP4, MASK_fe, TMP4);
  2597. ref += stride;
  2599. vis_ld64(ref[0], TMP8);
  2600. vis_and(REF_0, REF_2, TMP6);
  2601. vis_mul8x16(CONST_128, TMP4, TMP4);
  2603. vis_alignaddr_g0((void *)off);
  2605. vis_ld64_2(ref, 8, TMP10);
  2606. ref += stride;
  2607. vis_faligndata(TMP0, TMP2, REF_0);
  2609. if (off != 0x7) {
  2610. vis_alignaddr_g0((void *)off_plus_1);
  2611. vis_faligndata(TMP0, TMP2, REF_2);
  2612. } else {
  2613. vis_src1(TMP2, REF_2);
  2614. }
  2616. vis_and(TMP4, MASK_7f, TMP4);
  2618. vis_padd16(TMP6, TMP4, DST_0);
  2619. vis_st64(DST_0, dest[0]);
  2620. dest += stride;
  2622. vis_xor(REF_0, REF_2, TMP12);
  2624. vis_and(TMP12, MASK_fe, TMP12);
  2626. vis_and(REF_0, REF_2, TMP14);
  2627. vis_mul8x16(CONST_128, TMP12, TMP12);
  2629. vis_alignaddr_g0((void *)off);
  2630. vis_faligndata(TMP8, TMP10, REF_0);
  2631. if (off != 0x7) {
  2632. vis_alignaddr_g0((void *)off_plus_1);
  2633. vis_faligndata(TMP8, TMP10, REF_2);
  2634. } else {
  2635. vis_src1(TMP10, REF_2);
  2636. }
  2638. vis_and(TMP12, MASK_7f, TMP12);
  2640. vis_padd16(TMP14, TMP12, DST_0);
  2641. vis_st64(DST_0, dest[0]);
  2642. dest += stride;
  2643. } while (--height);
  2645. vis_ld64(ref[0], TMP0);
  2646. vis_xor(REF_0, REF_2, TMP4);
  2648. vis_ld64_2(ref, 8, TMP2);
  2649. vis_and(TMP4, MASK_fe, TMP4);
  2651. vis_and(REF_0, REF_2, TMP6);
  2652. vis_mul8x16(CONST_128, TMP4, TMP4);
  2654. vis_alignaddr_g0((void *)off);
  2656. vis_faligndata(TMP0, TMP2, REF_0);
  2658. if (off != 0x7) {
  2659. vis_alignaddr_g0((void *)off_plus_1);
  2660. vis_faligndata(TMP0, TMP2, REF_2);
  2661. } else {
  2662. vis_src1(TMP2, REF_2);
  2663. }
  2665. vis_and(TMP4, MASK_7f, TMP4);
  2667. vis_padd16(TMP6, TMP4, DST_0);
  2668. vis_st64(DST_0, dest[0]);
  2669. dest += stride;
  2671. vis_xor(REF_0, REF_2, TMP12);
  2673. vis_and(TMP12, MASK_fe, TMP12);
  2675. vis_and(REF_0, REF_2, TMP14);
  2676. vis_mul8x16(CONST_128, TMP12, TMP12);
  2678. vis_and(TMP12, MASK_7f, TMP12);
  2680. vis_padd16(TMP14, TMP12, DST_0);
  2681. vis_st64(DST_0, dest[0]);
  2682. dest += stride;
  2683. }
  2685. static void MC_avg_no_round_x_16_vis (uint8_t * dest, const uint8_t * _ref,
  2686.      const int stride, int height)
  2687. {
  2688. uint8_t *ref = (uint8_t *) _ref;
  2689. unsigned long off = (unsigned long) ref & 0x7;
  2690. unsigned long off_plus_1 = off + 1;
  2692. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  2694. vis_ld64(constants3[0], CONST_3);
  2695. vis_fzero(ZERO);
  2696. vis_ld64(constants256_512[0], CONST_256);
  2698. ref = vis_alignaddr(ref);
  2699. do { /* 26 cycles */
  2700. vis_ld64(ref[0], TMP0);
  2702. vis_ld64(ref[8], TMP2);
  2704. vis_alignaddr_g0((void *)off);
  2706. vis_ld64(ref[16], TMP4);
  2708. vis_ld64(dest[0], DST_0);
  2709. vis_faligndata(TMP0, TMP2, REF_0);
  2711. vis_ld64(dest[8], DST_2);
  2712. vis_faligndata(TMP2, TMP4, REF_4);
  2714. if (off != 0x7) {
  2715. vis_alignaddr_g0((void *)off_plus_1);
  2716. vis_faligndata(TMP0, TMP2, REF_2);
  2717. vis_faligndata(TMP2, TMP4, REF_6);
  2718. } else {
  2719. vis_src1(TMP2, REF_2);
  2720. vis_src1(TMP4, REF_6);
  2721. }
  2723. vis_mul8x16au(REF_0,   CONST_256, TMP0);
  2725. vis_pmerge(ZERO,     REF_2,     TMP4);
  2726. vis_mul8x16au(REF_0_1, CONST_256, TMP2);
  2728. vis_pmerge(ZERO, REF_2_1, TMP6);
  2730. vis_padd16(TMP0, TMP4, TMP0);
  2732. vis_mul8x16al(DST_0,   CONST_512, TMP4);
  2733. vis_padd16(TMP2, TMP6, TMP2);
  2735. vis_mul8x16al(DST_1,   CONST_512, TMP6);
  2737. vis_mul8x16au(REF_6,   CONST_256, TMP12);
  2739. vis_padd16(TMP0, TMP4, TMP0);
  2740. vis_mul8x16au(REF_6_1, CONST_256, TMP14);
  2742. vis_padd16(TMP2, TMP6, TMP2);
  2743. vis_mul8x16au(REF_4,   CONST_256, TMP16);
  2745. vis_padd16(TMP0, CONST_3, TMP8);
  2746. vis_mul8x16au(REF_4_1, CONST_256, TMP18);
  2748. vis_padd16(TMP2, CONST_3, TMP10);
  2749. vis_pack16(TMP8, DST_0);
  2751. vis_pack16(TMP10, DST_1);
  2752. vis_padd16(TMP16, TMP12, TMP0);
  2754. vis_st64(DST_0, dest[0]);
  2755. vis_mul8x16al(DST_2,   CONST_512, TMP4);
  2756. vis_padd16(TMP18, TMP14, TMP2);
  2758. vis_mul8x16al(DST_3,   CONST_512, TMP6);
  2759. vis_padd16(TMP0, CONST_3, TMP0);
  2761. vis_padd16(TMP2, CONST_3, TMP2);
  2763. vis_padd16(TMP0, TMP4, TMP0);
  2765. vis_padd16(TMP2, TMP6, TMP2);
  2766. vis_pack16(TMP0, DST_2);
  2768. vis_pack16(TMP2, DST_3);
  2769. vis_st64(DST_2, dest[8]);
  2771. ref += stride;
  2772. dest += stride;
  2773. } while (--height);
  2774. }
  2776. static void MC_avg_no_round_x_8_vis (uint8_t * dest, const uint8_t * _ref,
  2777.     const int stride, int height)
  2778. {
  2779. uint8_t *ref = (uint8_t *) _ref;
  2780. unsigned long off = (unsigned long) ref & 0x7;
  2781. unsigned long off_plus_1 = off + 1;
  2782. int stride_times_2 = stride << 1;
  2784. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  2786. vis_ld64(constants3[0], CONST_3);
  2787. vis_fzero(ZERO);
  2788. vis_ld64(constants256_512[0], CONST_256);
  2790. ref = vis_alignaddr(ref);
  2791. height >>= 2;
  2792. do { /* 47 cycles */
  2793. vis_ld64(ref[0],   TMP0);
  2795. vis_ld64_2(ref, 8, TMP2);
  2796. ref += stride;
  2798. vis_alignaddr_g0((void *)off);
  2800. vis_ld64(ref[0],   TMP4);
  2801. vis_faligndata(TMP0, TMP2, REF_0);
  2803. vis_ld64_2(ref, 8, TMP6);
  2804. ref += stride;
  2806. vis_ld64(ref[0],   TMP8);
  2808. vis_ld64_2(ref, 8, TMP10);
  2809. ref += stride;
  2810. vis_faligndata(TMP4, TMP6, REF_4);
  2812. vis_ld64(ref[0],   TMP12);
  2814. vis_ld64_2(ref, 8, TMP14);
  2815. ref += stride;
  2816. vis_faligndata(TMP8, TMP10, REF_S0);
  2818. vis_faligndata(TMP12, TMP14, REF_S4);
  2820. if (off != 0x7) {
  2821. vis_alignaddr_g0((void *)off_plus_1);
  2823. vis_ld64(dest[0], DST_0);
  2824. vis_faligndata(TMP0, TMP2, REF_2);
  2826. vis_ld64_2(dest, stride, DST_2);
  2827. vis_faligndata(TMP4, TMP6, REF_6);
  2829. vis_faligndata(TMP8, TMP10, REF_S2);
  2831. vis_faligndata(TMP12, TMP14, REF_S6);
  2832. } else {
  2833. vis_ld64(dest[0], DST_0);
  2834. vis_src1(TMP2, REF_2);
  2836. vis_ld64_2(dest, stride, DST_2);
  2837. vis_src1(TMP6, REF_6);
  2839. vis_src1(TMP10, REF_S2);
  2841. vis_src1(TMP14, REF_S6);
  2842. }
  2844. vis_pmerge(ZERO,     REF_0,     TMP0);
  2845. vis_mul8x16au(REF_0_1, CONST_256, TMP2);
  2847. vis_pmerge(ZERO,     REF_2,     TMP4);
  2848. vis_mul8x16au(REF_2_1, CONST_256, TMP6);
  2850. vis_padd16(TMP0, CONST_3, TMP0);
  2851. vis_mul8x16al(DST_0,   CONST_512, TMP16);
  2853. vis_padd16(TMP2, CONST_3, TMP2);
  2854. vis_mul8x16al(DST_1,   CONST_512, TMP18);
  2856. vis_padd16(TMP0, TMP4, TMP0);
  2857. vis_mul8x16au(REF_4, CONST_256, TMP8);
  2859. vis_padd16(TMP2, TMP6, TMP2);
  2860. vis_mul8x16au(REF_4_1, CONST_256, TMP10);
  2862. vis_padd16(TMP0, TMP16, TMP0);
  2863. vis_mul8x16au(REF_6, CONST_256, TMP12);
  2865. vis_padd16(TMP2, TMP18, TMP2);
  2866. vis_mul8x16au(REF_6_1, CONST_256, TMP14);
  2868. vis_padd16(TMP8, CONST_3, TMP8);
  2869. vis_mul8x16al(DST_2, CONST_512, TMP16);
  2871. vis_padd16(TMP8, TMP12, TMP8);
  2872. vis_mul8x16al(DST_3, CONST_512, TMP18);
  2874. vis_padd16(TMP10, TMP14, TMP10);
  2875. vis_pack16(TMP0, DST_0);
  2877. vis_pack16(TMP2, DST_1);
  2878. vis_st64(DST_0, dest[0]);
  2879. dest += stride;
  2880. vis_padd16(TMP10, CONST_3, TMP10);
  2882. vis_ld64_2(dest, stride, DST_0);
  2883. vis_padd16(TMP8, TMP16, TMP8);
  2885. vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
  2886. vis_padd16(TMP10, TMP18, TMP10);
  2887. vis_pack16(TMP8, DST_2);
  2889. vis_pack16(TMP10, DST_3);
  2890. vis_st64(DST_2, dest[0]);
  2891. dest += stride;
  2893. vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
  2894. vis_pmerge(ZERO,     REF_S0,     TMP0);
  2896. vis_pmerge(ZERO,     REF_S2,     TMP24);
  2897. vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
  2899. vis_padd16(TMP0, CONST_3, TMP0);
  2900. vis_mul8x16au(REF_S4, CONST_256, TMP8);
  2902. vis_padd16(TMP2, CONST_3, TMP2);
  2903. vis_mul8x16au(REF_S4_1, CONST_256, TMP10);
  2905. vis_padd16(TMP0, TMP24, TMP0);
  2906. vis_mul8x16au(REF_S6, CONST_256, TMP12);
  2908. vis_padd16(TMP2, TMP6, TMP2);
  2909. vis_mul8x16au(REF_S6_1, CONST_256, TMP14);
  2911. vis_padd16(TMP8, CONST_3, TMP8);
  2912. vis_mul8x16al(DST_0,   CONST_512, TMP16);
  2914. vis_padd16(TMP10, CONST_3, TMP10);
  2915. vis_mul8x16al(DST_1,   CONST_512, TMP18);
  2917. vis_padd16(TMP8, TMP12, TMP8);
  2918. vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);
  2920. vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
  2921. vis_padd16(TMP0, TMP16, TMP0);
  2923. vis_padd16(TMP2, TMP18, TMP2);
  2924. vis_pack16(TMP0, DST_0);
  2926. vis_padd16(TMP10, TMP14, TMP10);
  2927. vis_pack16(TMP2, DST_1);
  2928. vis_st64(DST_0, dest[0]);
  2929. dest += stride;
  2931. vis_padd16(TMP8, TMP20, TMP8);
  2933. vis_padd16(TMP10, TMP22, TMP10);
  2934. vis_pack16(TMP8, DST_2);
  2936. vis_pack16(TMP10, DST_3);
  2937. vis_st64(DST_2, dest[0]);
  2938. dest += stride;
  2939. } while (--height);
  2940. }
  2942. static void MC_put_no_round_y_16_vis (uint8_t * dest, const uint8_t * _ref,
  2943.      const int stride, int height)
  2944. {
  2945. uint8_t *ref = (uint8_t *) _ref;
  2947. ref = vis_alignaddr(ref);
  2948. vis_ld64(ref[0], TMP0);
  2950. vis_ld64_2(ref, 8, TMP2);
  2952. vis_ld64_2(ref, 16, TMP4);
  2953. ref += stride;
  2955. vis_ld64(ref[0], TMP6);
  2956. vis_faligndata(TMP0, TMP2, REF_0);
  2958. vis_ld64_2(ref, 8, TMP8);
  2959. vis_faligndata(TMP2, TMP4, REF_4);
  2961. vis_ld64_2(ref, 16, TMP10);
  2962. ref += stride;
  2964. vis_ld64(constants_fe[0], MASK_fe);
  2965. vis_faligndata(TMP6, TMP8, REF_2);
  2967. vis_ld64(constants_7f[0], MASK_7f);
  2968. vis_faligndata(TMP8, TMP10, REF_6);
  2970. vis_ld64(constants128[0], CONST_128);
  2971. height = (height >> 1) - 1;
  2972. do { /* 24 cycles */
  2973. vis_ld64(ref[0], TMP0);
  2974. vis_xor(REF_0, REF_2, TMP12);
  2976. vis_ld64_2(ref, 8, TMP2);
  2977. vis_xor(REF_4, REF_6, TMP16);
  2979. vis_ld64_2(ref, 16, TMP4);
  2980. ref += stride;
  2981. vis_and(REF_0, REF_2, TMP14);
  2983. vis_ld64(ref[0], TMP6);
  2984. vis_and(REF_4, REF_6, TMP18);
  2986. vis_ld64_2(ref, 8, TMP8);
  2987. vis_faligndata(TMP0, TMP2, REF_0);
  2989. vis_ld64_2(ref, 16, TMP10);
  2990. ref += stride;
  2991. vis_faligndata(TMP2, TMP4, REF_4);
  2993. vis_and(TMP12, MASK_fe, TMP12);
  2995. vis_and(TMP16, MASK_fe, TMP16);
  2996. vis_mul8x16(CONST_128, TMP12, TMP12);
  2998. vis_mul8x16(CONST_128, TMP16, TMP16);
  2999. vis_xor(REF_0, REF_2, TMP0);
  3001. vis_xor(REF_4, REF_6, TMP2);
  3003. vis_and(REF_0, REF_2, TMP20);
  3005. vis_and(TMP12, MASK_7f, TMP12);
  3007. vis_and(TMP16, MASK_7f, TMP16);
  3009. vis_padd16(TMP14, TMP12, TMP12);
  3010. vis_st64(TMP12, dest[0]);
  3012. vis_padd16(TMP18, TMP16, TMP16);
  3013. vis_st64_2(TMP16, dest, 8);
  3014. dest += stride;
  3016. vis_and(REF_4, REF_6, TMP18);
  3018. vis_and(TMP0, MASK_fe, TMP0);
  3020. vis_and(TMP2, MASK_fe, TMP2);
  3021. vis_mul8x16(CONST_128, TMP0, TMP0);
  3023. vis_faligndata(TMP6, TMP8, REF_2);
  3024. vis_mul8x16(CONST_128, TMP2, TMP2);
  3026. vis_faligndata(TMP8, TMP10, REF_6);
  3028. vis_and(TMP0, MASK_7f, TMP0);
  3030. vis_and(TMP2, MASK_7f, TMP2);
  3032. vis_padd16(TMP20, TMP0, TMP0);
  3033. vis_st64(TMP0, dest[0]);
  3035. vis_padd16(TMP18, TMP2, TMP2);
  3036. vis_st64_2(TMP2, dest, 8);
  3037. dest += stride;
  3038. } while (--height);
  3040. vis_ld64(ref[0], TMP0);
  3041. vis_xor(REF_0, REF_2, TMP12);
  3043. vis_ld64_2(ref, 8, TMP2);
  3044. vis_xor(REF_4, REF_6, TMP16);
  3046. vis_ld64_2(ref, 16, TMP4);
  3047. vis_and(REF_0, REF_2, TMP14);
  3049. vis_and(REF_4, REF_6, TMP18);
  3051. vis_faligndata(TMP0, TMP2, REF_0);
  3053. vis_faligndata(TMP2, TMP4, REF_4);
  3055. vis_and(TMP12, MASK_fe, TMP12);
  3057. vis_and(TMP16, MASK_fe, TMP16);
  3058. vis_mul8x16(CONST_128, TMP12, TMP12);
  3060. vis_mul8x16(CONST_128, TMP16, TMP16);
  3061. vis_xor(REF_0, REF_2, TMP0);
  3063. vis_xor(REF_4, REF_6, TMP2);
  3065. vis_and(REF_0, REF_2, TMP20);
  3067. vis_and(TMP12, MASK_7f, TMP12);
  3069. vis_and(TMP16, MASK_7f, TMP16);
  3071. vis_padd16(TMP14, TMP12, TMP12);
  3072. vis_st64(TMP12, dest[0]);
  3074. vis_padd16(TMP18, TMP16, TMP16);
  3075. vis_st64_2(TMP16, dest, 8);
  3076. dest += stride;
  3078. vis_and(REF_4, REF_6, TMP18);
  3080. vis_and(TMP0, MASK_fe, TMP0);
  3082. vis_and(TMP2, MASK_fe, TMP2);
  3083. vis_mul8x16(CONST_128, TMP0, TMP0);
  3085. vis_mul8x16(CONST_128, TMP2, TMP2);
  3087. vis_and(TMP0, MASK_7f, TMP0);
  3089. vis_and(TMP2, MASK_7f, TMP2);
  3091. vis_padd16(TMP20, TMP0, TMP0);
  3092. vis_st64(TMP0, dest[0]);
  3094. vis_padd16(TMP18, TMP2, TMP2);
  3095. vis_st64_2(TMP2, dest, 8);
  3096. }
  3098. static void MC_put_no_round_y_8_vis (uint8_t * dest, const uint8_t * _ref,
  3099.     const int stride, int height)
  3100. {
  3101. uint8_t *ref = (uint8_t *) _ref;
  3103. ref = vis_alignaddr(ref);
  3104. vis_ld64(ref[0], TMP0);
  3106. vis_ld64_2(ref, 8, TMP2);
  3107. ref += stride;
  3109. vis_ld64(ref[0], TMP4);
  3111. vis_ld64_2(ref, 8, TMP6);
  3112. ref += stride;
  3114. vis_ld64(constants_fe[0], MASK_fe);
  3115. vis_faligndata(TMP0, TMP2, REF_0);
  3117. vis_ld64(constants_7f[0], MASK_7f);
  3118. vis_faligndata(TMP4, TMP6, REF_2);
  3120. vis_ld64(constants128[0], CONST_128);
  3121. height = (height >> 1) - 1;
  3122. do { /* 12 cycles */
  3123. vis_ld64(ref[0], TMP0);
  3124. vis_xor(REF_0, REF_2, TMP4);
  3126. vis_ld64_2(ref, 8, TMP2);
  3127. ref += stride;
  3128. vis_and(TMP4, MASK_fe, TMP4);
  3130. vis_and(REF_0, REF_2, TMP6);
  3131. vis_mul8x16(CONST_128, TMP4, TMP4);
  3133. vis_faligndata(TMP0, TMP2, REF_0);
  3134. vis_ld64(ref[0], TMP0);
  3136. vis_ld64_2(ref, 8, TMP2);
  3137. ref += stride;
  3138. vis_xor(REF_0, REF_2, TMP12);
  3140. vis_and(TMP4, MASK_7f, TMP4);
  3142. vis_and(TMP12, MASK_fe, TMP12);
  3144. vis_mul8x16(CONST_128, TMP12, TMP12);
  3145. vis_and(REF_0, REF_2, TMP14);
  3147. vis_padd16(TMP6, TMP4, DST_0);
  3148. vis_st64(DST_0, dest[0]);
  3149. dest += stride;
  3151. vis_faligndata(TMP0, TMP2, REF_2);
  3153. vis_and(TMP12, MASK_7f, TMP12);
  3155. vis_padd16(TMP14, TMP12, DST_0);
  3156. vis_st64(DST_0, dest[0]);
  3157. dest += stride;
  3158. } while (--height);
  3160. vis_ld64(ref[0], TMP0);
  3161. vis_xor(REF_0, REF_2, TMP4);
  3163. vis_ld64_2(ref, 8, TMP2);
  3164. vis_and(TMP4, MASK_fe, TMP4);
  3166. vis_and(REF_0, REF_2, TMP6);
  3167. vis_mul8x16(CONST_128, TMP4, TMP4);
  3169. vis_faligndata(TMP0, TMP2, REF_0);
  3171. vis_xor(REF_0, REF_2, TMP12);
  3173. vis_and(TMP4, MASK_7f, TMP4);
  3175. vis_and(TMP12, MASK_fe, TMP12);
  3177. vis_mul8x16(CONST_128, TMP12, TMP12);
  3178. vis_and(REF_0, REF_2, TMP14);
  3180. vis_padd16(TMP6, TMP4, DST_0);
  3181. vis_st64(DST_0, dest[0]);
  3182. dest += stride;
  3184. vis_and(TMP12, MASK_7f, TMP12);
  3186. vis_padd16(TMP14, TMP12, DST_0);
  3187. vis_st64(DST_0, dest[0]);
  3188. }
  3190. static void MC_avg_no_round_y_16_vis (uint8_t * dest, const uint8_t * _ref,
  3191.      const int stride, int height)
  3192. {
  3193. uint8_t *ref = (uint8_t *) _ref;
  3194. int stride_8 = stride + 8;
  3195. int stride_16 = stride + 16;
  3197. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  3199. ref = vis_alignaddr(ref);
  3201. vis_ld64(ref[ 0], TMP0);
  3202. vis_fzero(ZERO);
  3204. vis_ld64(ref[ 8], TMP2);
  3206. vis_ld64(ref[16], TMP4);
  3208. vis_ld64(constants3[0], CONST_3);
  3209. vis_faligndata(TMP0, TMP2, REF_2);
  3211. vis_ld64(constants256_512[0], CONST_256);
  3212. vis_faligndata(TMP2, TMP4, REF_6);
  3213. height >>= 1;
  3215. do { /* 31 cycles */
  3216. vis_ld64_2(ref, stride, TMP0);
  3217. vis_pmerge(ZERO,       REF_2,     TMP12);
  3218. vis_mul8x16au(REF_2_1, CONST_256, TMP14);
  3220. vis_ld64_2(ref, stride_8, TMP2);
  3221. vis_pmerge(ZERO,       REF_6,     TMP16);
  3222. vis_mul8x16au(REF_6_1, CONST_256, TMP18);
  3224. vis_ld64_2(ref, stride_16, TMP4);
  3225. ref += stride;
  3227. vis_ld64(dest[0], DST_0);
  3228. vis_faligndata(TMP0, TMP2, REF_0);
  3230. vis_ld64_2(dest, 8, DST_2);
  3231. vis_faligndata(TMP2, TMP4, REF_4);
  3233. vis_ld64_2(ref, stride, TMP6);
  3234. vis_pmerge(ZERO,     REF_0,     TMP0);
  3235. vis_mul8x16au(REF_0_1, CONST_256, TMP2);
  3237. vis_ld64_2(ref, stride_8, TMP8);
  3238. vis_pmerge(ZERO,     REF_4,     TMP4);
  3240. vis_ld64_2(ref, stride_16, TMP10);
  3241. ref += stride;
  3243. vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
  3244. vis_faligndata(TMP6, TMP8, REF_2);
  3245. vis_mul8x16au(REF_4_1, CONST_256, TMP6);
  3247. vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
  3248. vis_faligndata(TMP8, TMP10, REF_6);
  3249. vis_mul8x16al(DST_0,   CONST_512, TMP20);
  3251. vis_padd16(TMP0, CONST_3, TMP0);
  3252. vis_mul8x16al(DST_1,   CONST_512, TMP22);
  3254. vis_padd16(TMP2, CONST_3, TMP2);
  3255. vis_mul8x16al(DST_2,   CONST_512, TMP24);
  3257. vis_padd16(TMP4, CONST_3, TMP4);
  3258. vis_mul8x16al(DST_3,   CONST_512, TMP26);
  3260. vis_padd16(TMP6, CONST_3, TMP6);
  3262. vis_padd16(TMP12, TMP20, TMP12);
  3263. vis_mul8x16al(REF_S0,   CONST_512, TMP20);
  3265. vis_padd16(TMP14, TMP22, TMP14);
  3266. vis_mul8x16al(REF_S0_1, CONST_512, TMP22);
  3268. vis_padd16(TMP16, TMP24, TMP16);
  3269. vis_mul8x16al(REF_S2,   CONST_512, TMP24);
  3271. vis_padd16(TMP18, TMP26, TMP18);
  3272. vis_mul8x16al(REF_S2_1, CONST_512, TMP26);
  3274. vis_padd16(TMP12, TMP0, TMP12);
  3275. vis_mul8x16au(REF_2,   CONST_256, TMP28);
  3277. vis_padd16(TMP14, TMP2, TMP14);
  3278. vis_mul8x16au(REF_2_1, CONST_256, TMP30);
  3280. vis_padd16(TMP16, TMP4, TMP16);
  3281. vis_mul8x16au(REF_6,   CONST_256, REF_S4);
  3283. vis_padd16(TMP18, TMP6, TMP18);
  3284. vis_mul8x16au(REF_6_1, CONST_256, REF_S6);
  3286. vis_pack16(TMP12, DST_0);
  3287. vis_padd16(TMP28, TMP0, TMP12);
  3289. vis_pack16(TMP14, DST_1);
  3290. vis_st64(DST_0, dest[0]);
  3291. vis_padd16(TMP30, TMP2, TMP14);
  3293. vis_pack16(TMP16, DST_2);
  3294. vis_padd16(REF_S4, TMP4, TMP16);
  3296. vis_pack16(TMP18, DST_3);
  3297. vis_st64_2(DST_2, dest, 8);
  3298. dest += stride;
  3299. vis_padd16(REF_S6, TMP6, TMP18);
  3301. vis_padd16(TMP12, TMP20, TMP12);
  3303. vis_padd16(TMP14, TMP22, TMP14);
  3304. vis_pack16(TMP12, DST_0);
  3306. vis_padd16(TMP16, TMP24, TMP16);
  3307. vis_pack16(TMP14, DST_1);
  3308. vis_st64(DST_0, dest[0]);
  3310. vis_padd16(TMP18, TMP26, TMP18);
  3311. vis_pack16(TMP16, DST_2);
  3313. vis_pack16(TMP18, DST_3);
  3314. vis_st64_2(DST_2, dest, 8);
  3315. dest += stride;
  3316. } while (--height);
  3317. }
  3319. static void MC_avg_no_round_y_8_vis (uint8_t * dest, const uint8_t * _ref,
  3320.     const int stride, int height)
  3321. {
  3322. uint8_t *ref = (uint8_t *) _ref;
  3323. int stride_8 = stride + 8;
  3325. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  3327. ref = vis_alignaddr(ref);
  3329. vis_ld64(ref[ 0], TMP0);
  3330. vis_fzero(ZERO);
  3332. vis_ld64(ref[ 8], TMP2);
  3334. vis_ld64(constants3[0], CONST_3);
  3335. vis_faligndata(TMP0, TMP2, REF_2);
  3337. vis_ld64(constants256_512[0], CONST_256);
  3339. height >>= 1;
  3340. do { /* 20 cycles */
  3341. vis_ld64_2(ref, stride, TMP0);
  3342. vis_pmerge(ZERO,       REF_2,     TMP8);
  3343. vis_mul8x16au(REF_2_1, CONST_256, TMP10);
  3345. vis_ld64_2(ref, stride_8, TMP2);
  3346. ref += stride;
  3348. vis_ld64(dest[0], DST_0);
  3350. vis_ld64_2(dest, stride, DST_2);
  3351. vis_faligndata(TMP0, TMP2, REF_0);
  3353. vis_ld64_2(ref, stride, TMP4);
  3354. vis_mul8x16al(DST_0,   CONST_512, TMP16);
  3355. vis_pmerge(ZERO,       REF_0,     TMP12);
  3357. vis_ld64_2(ref, stride_8, TMP6);
  3358. ref += stride;
  3359. vis_mul8x16al(DST_1,   CONST_512, TMP18);
  3360. vis_pmerge(ZERO,       REF_0_1,   TMP14);
  3362. vis_padd16(TMP12, CONST_3, TMP12);
  3363. vis_mul8x16al(DST_2,   CONST_512, TMP24);
  3365. vis_padd16(TMP14, CONST_3, TMP14);
  3366. vis_mul8x16al(DST_3,   CONST_512, TMP26);
  3368. vis_faligndata(TMP4, TMP6, REF_2);
  3370. vis_padd16(TMP8, TMP12, TMP8);
  3372. vis_padd16(TMP10, TMP14, TMP10);
  3373. vis_mul8x16au(REF_2,   CONST_256, TMP20);
  3375. vis_padd16(TMP8, TMP16, TMP0);
  3376. vis_mul8x16au(REF_2_1, CONST_256, TMP22);
  3378. vis_padd16(TMP10, TMP18, TMP2);
  3379. vis_pack16(TMP0, DST_0);
  3381. vis_pack16(TMP2, DST_1);
  3382. vis_st64(DST_0, dest[0]);
  3383. dest += stride;
  3384. vis_padd16(TMP12, TMP20, TMP12);
  3386. vis_padd16(TMP14, TMP22, TMP14);
  3388. vis_padd16(TMP12, TMP24, TMP0);
  3390. vis_padd16(TMP14, TMP26, TMP2);
  3391. vis_pack16(TMP0, DST_2);
  3393. vis_pack16(TMP2, DST_3);
  3394. vis_st64(DST_2, dest[0]);
  3395. dest += stride;
  3396. } while (--height);
  3397. }
  3399. static void MC_put_no_round_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
  3400.        const int stride, int height)
  3401. {
  3402. uint8_t *ref = (uint8_t *) _ref;
  3403. unsigned long off = (unsigned long) ref & 0x7;
  3404. unsigned long off_plus_1 = off + 1;
  3405. int stride_8 = stride + 8;
  3406. int stride_16 = stride + 16;
  3408. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  3410. ref = vis_alignaddr(ref);
  3412. vis_ld64(ref[ 0], TMP0);
  3413. vis_fzero(ZERO);
  3415. vis_ld64(ref[ 8], TMP2);
  3417. vis_ld64(ref[16], TMP4);
  3419. vis_ld64(constants1[0], CONST_1);
  3420. vis_faligndata(TMP0, TMP2, REF_S0);
  3422. vis_ld64(constants256_512[0], CONST_256);
  3423. vis_faligndata(TMP2, TMP4, REF_S4);
  3425. if (off != 0x7) {
  3426. vis_alignaddr_g0((void *)off_plus_1);
  3427. vis_faligndata(TMP0, TMP2, REF_S2);
  3428. vis_faligndata(TMP2, TMP4, REF_S6);
  3429. } else {
  3430. vis_src1(TMP2, REF_S2);
  3431. vis_src1(TMP4, REF_S6);
  3432. }
  3434. height >>= 1;
  3435. do {
  3436. vis_ld64_2(ref, stride, TMP0);
  3437. vis_mul8x16au(REF_S0, CONST_256, TMP12);
  3438. vis_pmerge(ZERO,      REF_S0_1,  TMP14);
  3440. vis_alignaddr_g0((void *)off);
  3442. vis_ld64_2(ref, stride_8, TMP2);
  3443. vis_mul8x16au(REF_S2, CONST_256, TMP16);
  3444. vis_pmerge(ZERO,      REF_S2_1,  TMP18);
  3446. vis_ld64_2(ref, stride_16, TMP4);
  3447. ref += stride;
  3448. vis_mul8x16au(REF_S4, CONST_256, TMP20);
  3449. vis_pmerge(ZERO,      REF_S4_1,  TMP22);
  3451. vis_ld64_2(ref, stride, TMP6);
  3452. vis_mul8x16au(REF_S6, CONST_256, TMP24);
  3453. vis_pmerge(ZERO,      REF_S6_1,  TMP26);
  3455. vis_ld64_2(ref, stride_8, TMP8);
  3456. vis_faligndata(TMP0, TMP2, REF_0);
  3458. vis_ld64_2(ref, stride_16, TMP10);
  3459. ref += stride;
  3460. vis_faligndata(TMP2, TMP4, REF_4);
  3462. vis_faligndata(TMP6, TMP8, REF_S0);
  3464. vis_faligndata(TMP8, TMP10, REF_S4);
  3466. if (off != 0x7) {
  3467. vis_alignaddr_g0((void *)off_plus_1);
  3468. vis_faligndata(TMP0, TMP2, REF_2);
  3469. vis_faligndata(TMP2, TMP4, REF_6);
  3470. vis_faligndata(TMP6, TMP8, REF_S2);
  3471. vis_faligndata(TMP8, TMP10, REF_S6);
  3472. } else {
  3473. vis_src1(TMP2, REF_2);
  3474. vis_src1(TMP4, REF_6);
  3475. vis_src1(TMP8, REF_S2);
  3476. vis_src1(TMP10, REF_S6);
  3477. }
  3479. vis_mul8x16au(REF_0, CONST_256, TMP0);
  3480. vis_pmerge(ZERO,      REF_0_1,  TMP2);
  3482. vis_mul8x16au(REF_2, CONST_256, TMP4);
  3483. vis_pmerge(ZERO,      REF_2_1,  TMP6);
  3485. vis_padd16(TMP0, CONST_2, TMP8);
  3486. vis_mul8x16au(REF_4, CONST_256, TMP0);
  3488. vis_padd16(TMP2, CONST_1, TMP10);
  3489. vis_mul8x16au(REF_4_1, CONST_256, TMP2);
  3491. vis_padd16(TMP8, TMP4, TMP8);
  3492. vis_mul8x16au(REF_6, CONST_256, TMP4);
  3494. vis_padd16(TMP10, TMP6, TMP10);
  3495. vis_mul8x16au(REF_6_1, CONST_256, TMP6);
  3497. vis_padd16(TMP12, TMP8, TMP12);
  3499. vis_padd16(TMP14, TMP10, TMP14);
  3501. vis_padd16(TMP12, TMP16, TMP12);
  3503. vis_padd16(TMP14, TMP18, TMP14);
  3504. vis_pack16(TMP12, DST_0);
  3506. vis_pack16(TMP14, DST_1);
  3507. vis_st64(DST_0, dest[0]);
  3508. vis_padd16(TMP0, CONST_1, TMP12);
  3510. vis_mul8x16au(REF_S0, CONST_256, TMP0);
  3511. vis_padd16(TMP2, CONST_1, TMP14);
  3513. vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
  3514. vis_padd16(TMP12, TMP4, TMP12);
  3516. vis_mul8x16au(REF_S2, CONST_256, TMP4);
  3517. vis_padd16(TMP14, TMP6, TMP14);
  3519. vis_mul8x16au(REF_S2_1, CONST_256, TMP6);
  3520. vis_padd16(TMP20, TMP12, TMP20);
  3522. vis_padd16(TMP22, TMP14, TMP22);
  3524. vis_padd16(TMP20, TMP24, TMP20);
  3526. vis_padd16(TMP22, TMP26, TMP22);
  3527. vis_pack16(TMP20, DST_2);
  3529. vis_pack16(TMP22, DST_3);
  3530. vis_st64_2(DST_2, dest, 8);
  3531. dest += stride;
  3532. vis_padd16(TMP0, TMP4, TMP24);
  3534. vis_mul8x16au(REF_S4, CONST_256, TMP0);
  3535. vis_padd16(TMP2, TMP6, TMP26);
  3537. vis_mul8x16au(REF_S4_1, CONST_256, TMP2);
  3538. vis_padd16(TMP24, TMP8, TMP24);
  3540. vis_padd16(TMP26, TMP10, TMP26);
  3541. vis_pack16(TMP24, DST_0);
  3543. vis_pack16(TMP26, DST_1);
  3544. vis_st64(DST_0, dest[0]);
  3545. vis_pmerge(ZERO, REF_S6, TMP4);
  3547. vis_pmerge(ZERO,      REF_S6_1,  TMP6);
  3549. vis_padd16(TMP0, TMP4, TMP0);
  3551. vis_padd16(TMP2, TMP6, TMP2);
  3553. vis_padd16(TMP0, TMP12, TMP0);
  3555. vis_padd16(TMP2, TMP14, TMP2);
  3556. vis_pack16(TMP0, DST_2);
  3558. vis_pack16(TMP2, DST_3);
  3559. vis_st64_2(DST_2, dest, 8);
  3560. dest += stride;
  3561. } while (--height);
  3562. }
  3564. static void MC_put_no_round_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
  3565.       const int stride, int height)
  3566. {
  3567. uint8_t *ref = (uint8_t *) _ref;
  3568. unsigned long off = (unsigned long) ref & 0x7;
  3569. unsigned long off_plus_1 = off + 1;
  3570. int stride_8 = stride + 8;
  3572. vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);
  3574. ref = vis_alignaddr(ref);
  3576. vis_ld64(ref[ 0], TMP0);
  3577. vis_fzero(ZERO);
  3579. vis_ld64(ref[ 8], TMP2);
  3581. vis_ld64(constants1[0], CONST_1);
  3583. vis_ld64(constants256_512[0], CONST_256);
  3584. vis_faligndata(TMP0, TMP2, REF_S0);
  3586. if (off != 0x7) {
  3587. vis_alignaddr_g0((void *)off_plus_1);
  3588. vis_faligndata(TMP0, TMP2, REF_S2);
  3589. } else {
  3590. vis_src1(TMP2, REF_S2);
  3591. }
  3593. height >>= 1;
  3594. do { /* 26 cycles */
  3595. vis_ld64_2(ref, stride, TMP0);
  3596. vis_mul8x16au(REF_S0,   CONST_256, TMP8);
  3597. vis_pmerge(ZERO,        REF_S2,    TMP12);
  3599. vis_alignaddr_g0((void *)off);
  3601. vis_ld64_2(ref, stride_8, TMP2);
  3602. ref += stride;
  3603. vis_mul8x16au(REF_S0_1, CONST_256, TMP10);
  3604. vis_pmerge(ZERO,        REF_S2_1,  TMP14);
  3606. vis_ld64_2(ref, stride, TMP4);
  3608. vis_ld64_2(ref, stride_8, TMP6);
  3609. ref += stride;
  3610. vis_faligndata(TMP0, TMP2, REF_S4);
  3612. vis_pmerge(ZERO, REF_S4, TMP18);
  3614. vis_pmerge(ZERO, REF_S4_1, TMP20);
  3616. vis_faligndata(TMP4, TMP6, REF_S0);
  3618. if (off != 0x7) {
  3619. vis_alignaddr_g0((void *)off_plus_1);
  3620. vis_faligndata(TMP0, TMP2, REF_S6);
  3621. vis_faligndata(TMP4, TMP6, REF_S2);
  3622. } else {
  3623. vis_src1(TMP2, REF_S6);
  3624. vis_src1(TMP6, REF_S2);
  3625. }
  3627. vis_padd16(TMP18, CONST_1, TMP18);
  3628. vis_mul8x16au(REF_S6,   CONST_256, TMP22);
  3630. vis_padd16(TMP20, CONST_1, TMP20);
  3631. vis_mul8x16au(REF_S6_1, CONST_256, TMP24);
  3633. vis_mul8x16au(REF_S0,   CONST_256, TMP26);
  3634. vis_pmerge(ZERO, REF_S0_1, TMP28);
  3636. vis_mul8x16au(REF_S2,   CONST_256, TMP30);
  3637. vis_padd16(TMP18, TMP22, TMP18);
  3639. vis_mul8x16au(REF_S2_1, CONST_256, TMP32);
  3640. vis_padd16(TMP20, TMP24, TMP20);
  3642. vis_padd16(TMP8,  TMP18, TMP8);
  3644. vis_padd16(TMP10, TMP20, TMP10);
  3646. vis_padd16(TMP8,  TMP12, TMP8);
  3648. vis_padd16(TMP10, TMP14, TMP10);
  3649. vis_pack16(TMP8,  DST_0);
  3651. vis_pack16(TMP10, DST_1);
  3652. vis_st64(DST_0, dest[0]);
  3653. dest += stride;
  3654. vis_padd16(TMP18, TMP26, TMP18);
  3656. vis_padd16(TMP20, TMP28, TMP20);
  3658. vis_padd16(TMP18, TMP30, TMP18);
  3660. vis_padd16(TMP20, TMP32, TMP20);
  3661. vis_pack16(TMP18, DST_2);
  3663. vis_pack16(TMP20, DST_3);
  3664. vis_st64(DST_2, dest[0]);
  3665. dest += stride;
  3666. } while (--height);
  3667. }
  3669. static void MC_avg_no_round_xy_16_vis (uint8_t * dest, const uint8_t * _ref,
  3670.        const int stride, int height)
  3671. {
  3672. uint8_t *ref = (uint8_t *) _ref;
  3673. unsigned long off = (unsigned long) ref & 0x7;
  3674. unsigned long off_plus_1 = off + 1;
  3675. int stride_8 = stride + 8;
  3676. int stride_16 = stride + 16;
  3678. vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
  3680. ref = vis_alignaddr(ref);
  3682. vis_ld64(ref[ 0], TMP0);
  3683. vis_fzero(ZERO);
  3685. vis_ld64(ref[ 8], TMP2);
  3687. vis_ld64(ref[16], TMP4);
  3689. vis_ld64(constants6[0], CONST_6);
  3690. vis_faligndata(TMP0, TMP2, REF_S0);
  3692. vis_ld64(constants256_1024[0], CONST_256);
  3693. vis_faligndata(TMP2, TMP4, REF_S4);
  3695. if (off != 0x7) {
  3696. vis_alignaddr_g0((void *)off_plus_1);
  3697. vis_faligndata(TMP0, TMP2, REF_S2);
  3698. vis_faligndata(TMP2, TMP4, REF_S6);
  3699. } else {
  3700. vis_src1(TMP2, REF_S2);
  3701. vis_src1(TMP4, REF_S6);
  3702. }
  3704. height >>= 1;
  3705. do { /* 55 cycles */
  3706. vis_ld64_2(ref, stride, TMP0);
  3707. vis_mul8x16au(REF_S0, CONST_256, TMP12);
  3708. vis_pmerge(ZERO,      REF_S0_1,  TMP14);
  3710. vis_alignaddr_g0((void *)off);
  3712. vis_ld64_2(ref, stride_8, TMP2);
  3713. vis_mul8x16au(REF_S2, CONST_256, TMP16);
  3714. vis_pmerge(ZERO,      REF_S2_1,  TMP18);
  3716. vis_ld64_2(ref, stride_16, TMP4);
  3717. ref += stride;
  3718. vis_mul8x16au(REF_S4, CONST_256, TMP20);
  3719. vis_pmerge(ZERO,      REF_S4_1,  TMP22);
  3721. vis_ld64_2(ref, stride, TMP6);
  3722. vis_mul8x16au(REF_S6, CONST_256, TMP24);
  3723. vis_pmerge(ZERO,      REF_S6_1,  TMP26);
  3725. vis_ld64_2(ref, stride_8, TMP8);
  3726. vis_faligndata(TMP0, TMP2, REF_0);
  3728. vis_ld64_2(ref, stride_16, TMP10);
  3729. ref += stride;
  3730. vis_faligndata(TMP2, TMP4, REF_4);
  3732. vis_ld64(dest[0], DST_0);
  3733. vis_faligndata(TMP6, TMP8, REF_S0);
  3735. vis_ld64_2(dest, 8, DST_2);
  3736. vis_faligndata(TMP8, TMP10, REF_S4);
  3738. if (off != 0x7) {
  3739. vis_alignaddr_g0((void *)off_plus_1);
  3740. vis_faligndata(TMP0, TMP2, REF_2);
  3741. vis_faligndata(TMP2, TMP4, REF_6);
  3742. vis_faligndata(TMP6, TMP8, REF_S2);
  3743. vis_faligndata(TMP8, TMP10, REF_S6);
  3744. } else {
  3745. vis_src1(TMP2, REF_2);
  3746. vis_src1(TMP4, REF_6);
  3747. vis_src1(TMP8, REF_S2);
  3748. vis_src1(TMP10, REF_S6);
  3749. }
  3751. vis_mul8x16al(DST_0,   CONST_1024, TMP30);
  3752. vis_pmerge(ZERO, REF_0, TMP0);
  3754. vis_mul8x16al(DST_1,   CONST_1024, TMP32);
  3755. vis_pmerge(ZERO,      REF_0_1,  TMP2);
  3757. vis_mul8x16au(REF_2, CONST_256, TMP4);
  3758. vis_pmerge(ZERO,      REF_2_1,  TMP6);
  3760. vis_mul8x16al(DST_2,   CONST_1024, REF_0);
  3761. vis_padd16(TMP0, CONST_6, TMP0);
  3763. vis_mul8x16al(DST_3,   CONST_1024, REF_2);
  3764. vis_padd16(TMP2, CONST_6, TMP2);
  3766. vis_padd16(TMP0, TMP4, TMP0);
  3767. vis_mul8x16au(REF_4, CONST_256, TMP4);
  3769. vis_padd16(TMP2, TMP6, TMP2);
  3770. vis_mul8x16au(REF_4_1, CONST_256, TMP6);
  3772. vis_padd16(TMP12, TMP0, TMP12);
  3773. vis_mul8x16au(REF_6, CONST_256, TMP8);
  3775. vis_padd16(TMP14, TMP2, TMP14);
  3776. vis_mul8x16au(REF_6_1, CONST_256, TMP10);
  3778. vis_padd16(TMP12, TMP16, TMP12);
  3779. vis_mul8x16au(REF_S0, CONST_256, REF_4);
  3781. vis_padd16(TMP14, TMP18, TMP14);
  3782. vis_mul8x16au(REF_S0_1, CONST_256, REF_6);
  3784. vis_padd16(TMP12, TMP30, TMP12);
  3786. vis_padd16(TMP14, TMP32, TMP14);
  3787. vis_pack16(TMP12, DST_0);
  3789. vis_pack16(TMP14, DST_1);
  3790. vis_st64(DST_0, dest[0]);
  3791. vis_padd16(TMP4, CONST_6, TMP4);
  3793. vis_ld64_2(dest, stride, DST_0);
  3794. vis_padd16(TMP6, CONST_6, TMP6);
  3795. vis_mul8x16au(REF_S2, CONST_256, TMP12);
  3797. vis_padd16(TMP4, TMP8, TMP4);
  3798. vis_mul8x16au(REF_S2_1, CONST_256,  TMP14);
  3800. vis_padd16(TMP6, TMP10, TMP6);
  3802. vis_padd16(TMP20, TMP4, TMP20);
  3804. vis_padd16(TMP22, TMP6, TMP22);
  3806. vis_padd16(TMP20, TMP24, TMP20);
  3808. vis_padd16(TMP22, TMP26, TMP22);
  3810. vis_padd16(TMP20, REF_0, TMP20);
  3811. vis_mul8x16au(REF_S4, CONST_256, REF_0);
  3813. vis_padd16(TMP22, REF_2, TMP22);
  3814. vis_pack16(TMP20, DST_2);
  3816. vis_pack16(TMP22, DST_3);
  3817. vis_st64_2(DST_2, dest, 8);
  3818. dest += stride;
  3820. vis_ld64_2(dest, 8, DST_2);
  3821. vis_mul8x16al(DST_0,   CONST_1024, TMP30);
  3822. vis_pmerge(ZERO,      REF_S4_1,  REF_2);
  3824. vis_mul8x16al(DST_1,   CONST_1024, TMP32);
  3825. vis_padd16(REF_4, TMP0, TMP8);
  3827. vis_mul8x16au(REF_S6, CONST_256, REF_4);
  3828. vis_padd16(REF_6, TMP2, TMP10);
  3830. vis_mul8x16au(REF_S6_1, CONST_256, REF_6);
  3831. vis_padd16(TMP8, TMP12, TMP8);
  3833. vis_padd16(TMP10, TMP14, TMP10);
  3835. vis_padd16(TMP8, TMP30, TMP8);
  3837. vis_padd16(TMP10, TMP32, TMP10);
  3838. vis_pack16(TMP8, DST_0);
  3840. vis_pack16(TMP10, DST_1);
  3841. vis_st64(DST_0, dest[0]);
  3843. vis_padd16(REF_0, TMP4, REF_0);
  3845. vis_mul8x16al(DST_2,   CONST_1024, TMP30);
  3846. vis_padd16(REF_2, TMP6, REF_2);
  3848. vis_mul8x16al(DST_3,   CONST_1024, TMP32);
  3849. vis_padd16(REF_0, REF_4, REF_0);
  3851. vis_padd16(REF_2, REF_6, REF_2);
  3853. vis_padd16(REF_0, TMP30, REF_0);
  3855. /* stall */
  3857. vis_padd16(REF_2, TMP32, REF_2);
  3858. vis_pack16(REF_0, DST_2);
  3860. vis_pack16(REF_2, DST_3);
  3861. vis_st64_2(DST_2, dest, 8);
  3862. dest += stride;
  3863. } while (--height);
  3864. }
  3866. static void MC_avg_no_round_xy_8_vis (uint8_t * dest, const uint8_t * _ref,
  3867.       const int stride, int height)
  3868. {
  3869. uint8_t *ref = (uint8_t *) _ref;
  3870. unsigned long off = (unsigned long) ref & 0x7;
  3871. unsigned long off_plus_1 = off + 1;
  3872. int stride_8 = stride + 8;
  3874. vis_set_gsr(4 << VIS_GSR_SCALEFACT_SHIFT);
  3876. ref = vis_alignaddr(ref);
  3878. vis_ld64(ref[0], TMP0);
  3879. vis_fzero(ZERO);
  3881. vis_ld64_2(ref, 8, TMP2);
  3883. vis_ld64(constants6[0], CONST_6);
  3885. vis_ld64(constants256_1024[0], CONST_256);
  3886. vis_faligndata(TMP0, TMP2, REF_S0);
  3888. if (off != 0x7) {
  3889. vis_alignaddr_g0((void *)off_plus_1);
  3890. vis_faligndata(TMP0, TMP2, REF_S2);
  3891. } else {
  3892. vis_src1(TMP2, REF_S2);
  3893. }
  3895. height >>= 1;
  3896. do { /* 31 cycles */
  3897. vis_ld64_2(ref, stride, TMP0);
  3898. vis_mul8x16au(REF_S0, CONST_256, TMP8);
  3899. vis_pmerge(ZERO,      REF_S0_1,  TMP10);
  3901. vis_ld64_2(ref, stride_8, TMP2);
  3902. ref += stride;
  3903. vis_mul8x16au(REF_S2, CONST_256, TMP12);
  3904. vis_pmerge(ZERO,      REF_S2_1,  TMP14);
  3906. vis_alignaddr_g0((void *)off);
  3908. vis_ld64_2(ref, stride, TMP4);
  3909. vis_faligndata(TMP0, TMP2, REF_S4);
  3911. vis_ld64_2(ref, stride_8, TMP6);
  3912. ref += stride;
  3914. vis_ld64(dest[0], DST_0);
  3915. vis_faligndata(TMP4, TMP6, REF_S0);
  3917. vis_ld64_2(dest, stride, DST_2);
  3919. if (off != 0x7) {
  3920. vis_alignaddr_g0((void *)off_plus_1);
  3921. vis_faligndata(TMP0, TMP2, REF_S6);
  3922. vis_faligndata(TMP4, TMP6, REF_S2);
  3923. } else {
  3924. vis_src1(TMP2, REF_S6);
  3925. vis_src1(TMP6, REF_S2);
  3926. }
  3928. vis_mul8x16al(DST_0,   CONST_1024, TMP30);
  3929. vis_pmerge(ZERO, REF_S4, TMP22);
  3931. vis_mul8x16al(DST_1,   CONST_1024, TMP32);
  3932. vis_pmerge(ZERO,      REF_S4_1,  TMP24);
  3934. vis_mul8x16au(REF_S6, CONST_256, TMP26);
  3935. vis_pmerge(ZERO,      REF_S6_1,  TMP28);
  3937. vis_mul8x16au(REF_S0, CONST_256, REF_S4);
  3938. vis_padd16(TMP22, CONST_6, TMP22);
  3940. vis_mul8x16au(REF_S0_1, CONST_256, REF_S6);
  3941. vis_padd16(TMP24, CONST_6, TMP24);
  3943. vis_mul8x16al(DST_2,   CONST_1024, REF_0);
  3944. vis_padd16(TMP22, TMP26, TMP22);
  3946. vis_mul8x16al(DST_3,   CONST_1024, REF_2);
  3947. vis_padd16(TMP24, TMP28, TMP24);
  3949. vis_mul8x16au(REF_S2, CONST_256, TMP26);
  3950. vis_padd16(TMP8, TMP22, TMP8);
  3952. vis_mul8x16au(REF_S2_1, CONST_256, TMP28);
  3953. vis_padd16(TMP10, TMP24, TMP10);
  3955. vis_padd16(TMP8, TMP12, TMP8);
  3957. vis_padd16(TMP10, TMP14, TMP10);
  3959. vis_padd16(TMP8, TMP30, TMP8);
  3961. vis_padd16(TMP10, TMP32, TMP10);
  3962. vis_pack16(TMP8, DST_0);
  3964. vis_pack16(TMP10, DST_1);
  3965. vis_st64(DST_0, dest[0]);
  3966. dest += stride;
  3968. vis_padd16(REF_S4, TMP22, TMP12);
  3970. vis_padd16(REF_S6, TMP24, TMP14);
  3972. vis_padd16(TMP12, TMP26, TMP12);
  3974. vis_padd16(TMP14, TMP28, TMP14);
  3976. vis_padd16(TMP12, REF_0, TMP12);
  3978. vis_padd16(TMP14, REF_2, TMP14);
  3979. vis_pack16(TMP12, DST_2);
  3981. vis_pack16(TMP14, DST_3);
  3982. vis_st64(DST_2, dest[0]);
  3983. dest += stride;
  3984. } while (--height);
  3985. }
  3987. /* End of no rounding code */
  3989. static sigjmp_buf jmpbuf;
  3990. static volatile sig_atomic_t canjump = 0;
  3991.  
  3992. static void sigill_handler (int sig)
  3993. {
  3994.     if (!canjump) {
  3995.         signal (sig, SIG_DFL);
  3996.         raise (sig);
  3997.     }
  3999.     canjump = 0;
  4000.     siglongjmp (jmpbuf, 1);
  4001. }
  4003. #define ACCEL_SPARC_VIS 1
  4004. #define ACCEL_SPARC_VIS2 2
  4006. static int vis_level ()
  4007. {
  4008.     int accel = 0;
  4010.     signal (SIGILL, sigill_handler);
  4011.     if (sigsetjmp (jmpbuf, 1)) {
  4012.         signal (SIGILL, SIG_DFL);
  4013.         return accel;
  4014.     }
  4015.  
  4016.     canjump = 1;
  4017.  
  4018.     /* pdist %f0, %f0, %f0 */
  4019.     __asm__ __volatile__(".wordt0x81b007c0");
  4021.     canjump = 0;
  4022.     accel |= ACCEL_SPARC_VIS;
  4024.     if (sigsetjmp (jmpbuf, 1)) {
  4025.         signal (SIGILL, SIG_DFL);
  4026.         return accel;
  4027.     }
  4029.     canjump = 1;
  4031.     /* edge8n %g0, %g0, %g0 */
  4032.     __asm__ __volatile__(".wordt0x81b00020");
  4034.     canjump = 0;
  4035.     accel |= ACCEL_SPARC_VIS2;
  4037.     signal (SIGILL, SIG_DFL);
  4039.     return accel;
  4040. }
  4042. /* libavcodec initialization code */
  4043. void dsputil_init_vis(DSPContext* c, AVCodecContext *avctx)
  4044. {
  4045.   /* VIS specific optimisations */
  4046.   int accel = vis_level ();
  4048.   if (accel & ACCEL_SPARC_VIS) {
  4049.       c->put_pixels_tab[0][0] = MC_put_o_16_vis;
  4050.       c->put_pixels_tab[0][1] = MC_put_x_16_vis;
  4051.       c->put_pixels_tab[0][2] = MC_put_y_16_vis;
  4052.       c->put_pixels_tab[0][3] = MC_put_xy_16_vis;
  4053.       
  4054.       c->put_pixels_tab[1][0] = MC_put_o_8_vis;
  4055.       c->put_pixels_tab[1][1] = MC_put_x_8_vis;
  4056.       c->put_pixels_tab[1][2] = MC_put_y_8_vis;
  4057.       c->put_pixels_tab[1][3] = MC_put_xy_8_vis;
  4058.       
  4059.       c->avg_pixels_tab[0][0] = MC_avg_o_16_vis;
  4060.       c->avg_pixels_tab[0][1] = MC_avg_x_16_vis;
  4061.       c->avg_pixels_tab[0][2] = MC_avg_y_16_vis;
  4062.       c->avg_pixels_tab[0][3] = MC_avg_xy_16_vis;
  4063.   
  4064.       c->avg_pixels_tab[1][0] = MC_avg_o_8_vis;
  4065.       c->avg_pixels_tab[1][1] = MC_avg_x_8_vis;
  4066.       c->avg_pixels_tab[1][2] = MC_avg_y_8_vis;
  4067.       c->avg_pixels_tab[1][3] = MC_avg_xy_8_vis;
  4068.   
  4069.       c->put_no_rnd_pixels_tab[0][0] = MC_put_no_round_o_16_vis;
  4070.       c->put_no_rnd_pixels_tab[0][1] = MC_put_no_round_x_16_vis;
  4071.       c->put_no_rnd_pixels_tab[0][2] = MC_put_no_round_y_16_vis;
  4072.       c->put_no_rnd_pixels_tab[0][3] = MC_put_no_round_xy_16_vis;
  4073.       
  4074.       c->put_no_rnd_pixels_tab[1][0] = MC_put_no_round_o_8_vis;
  4075.       c->put_no_rnd_pixels_tab[1][1] = MC_put_no_round_x_8_vis;
  4076.       c->put_no_rnd_pixels_tab[1][2] = MC_put_no_round_y_8_vis;
  4077.       c->put_no_rnd_pixels_tab[1][3] = MC_put_no_round_xy_8_vis;
  4078.   
  4079.       c->avg_no_rnd_pixels_tab[0][0] = MC_avg_no_round_o_16_vis;
  4080.       c->avg_no_rnd_pixels_tab[0][1] = MC_avg_no_round_x_16_vis;
  4081.       c->avg_no_rnd_pixels_tab[0][2] = MC_avg_no_round_y_16_vis;
  4082.       c->avg_no_rnd_pixels_tab[0][3] = MC_avg_no_round_xy_16_vis;
  4083.   
  4084.       c->avg_no_rnd_pixels_tab[1][0] = MC_avg_no_round_o_8_vis;
  4085.       c->avg_no_rnd_pixels_tab[1][1] = MC_avg_no_round_x_8_vis;
  4086.       c->avg_no_rnd_pixels_tab[1][2] = MC_avg_no_round_y_8_vis;
  4087.       c->avg_no_rnd_pixels_tab[1][3] = MC_avg_no_round_xy_8_vis;
  4088.   }
  4089. }
  4091. #endif  /* !(ARCH_SPARC) */