falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
73014 Commits
32 Branches
541MB
Tree: ee3ef5fda2
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ee3ef5fda2'
${ noResults }
FFmpeg/libavcodec/mips/hpeldsp_msa.c

1499 lines
56KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2015 Parag Salasakar (Parag.Salasakar@imgtec.com)

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

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

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

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

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

  10.  *

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

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

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

  14.  * Lesser General Public License for more details.

  15.  *

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

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

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

  19.  */

  20. 

  21. #include "libavutil/mips/generic_macros_msa.h"

  22. #include "libavcodec/mips/hpeldsp_mips.h"

  23. 

  24. #define PCKEV_AVG_ST_UB(in0, in1, dst, pdst)                  \

  25. {                                                             \

  26.     v16u8 tmp_m;                                              \

  27.                                                               \

  28.     tmp_m = (v16u8) __msa_pckev_b((v16i8) in0, (v16i8) in1);  \

  29.     tmp_m = __msa_aver_u_b(tmp_m, (v16u8) dst);               \

  30.     ST_UB(tmp_m, (pdst));                                     \

  31. }

  32. 

  33. #define PCKEV_ST_SB4(in0, in1, in2, in3, in4, in5, in6, in7, pdst, stride)  \

  34. {                                                                           \

  35.     v16i8 tmp0_m, tmp1_m, tmp2_m, tmp3_m;                                   \

  36.     uint8_t *pdst_m = (uint8_t *) (pdst);                                   \

  37.                                                                             \

  38.     PCKEV_B4_SB(in0, in1, in2, in3, in4, in5, in6, in7,                     \

  39.                 tmp0_m, tmp1_m, tmp2_m, tmp3_m);                            \

  40.     ST_SB4(tmp0_m, tmp1_m, tmp2_m, tmp3_m, pdst_m, stride);                 \

  41. }

  42. 

  43. #define PCKEV_AVG_ST8x4_UB(in1, dst0, in2, dst1, in3, dst2, in4, dst3,  \

  44.                            pdst, stride)                                \

  45. {                                                                       \

  46.     v16u8 tmp0_m, tmp1_m, tmp2_m, tmp3_m;                               \

  47.     uint8_t *pdst_m = (uint8_t *) (pdst);                               \

  48.                                                                         \

  49.     PCKEV_B2_UB(in2, in1, in4, in3, tmp0_m, tmp1_m);                    \

  50.     PCKEV_D2_UB(dst1, dst0, dst3, dst2, tmp2_m, tmp3_m);                \

  51.     AVER_UB2_UB(tmp0_m, tmp2_m, tmp1_m, tmp3_m, tmp0_m, tmp1_m);        \

  52.     ST8x4_UB(tmp0_m, tmp1_m, pdst_m, stride);                           \

  53. }

  54. 

  55. static void common_hz_bil_4w_msa(const uint8_t *src, int32_t src_stride,

  56.                                  uint8_t *dst, int32_t dst_stride,

  57.                                  uint8_t height)

  58. {

  59.     uint8_t loop_cnt;

  60.     uint32_t out0, out1;

  61.     v16u8 src0, src1, src0_sld1, src1_sld1, res0, res1;

  62. 

  63.     for (loop_cnt = (height >> 1); loop_cnt--;) {

  64.         LD_UB2(src, src_stride, src0, src1);

  65.         src += (2 * src_stride);

  66. 

  67.         SLDI_B2_0_UB(src0, src1, src0_sld1, src1_sld1, 1);

  68.         AVER_UB2_UB(src0_sld1, src0, src1_sld1, src1, res0, res1);

  69. 

  70.         out0 = __msa_copy_u_w((v4i32) res0, 0);

  71.         out1 = __msa_copy_u_w((v4i32) res1, 0);

  72.         SW(out0, dst);

  73.         dst += dst_stride;

  74.         SW(out1, dst);

  75.         dst += dst_stride;

  76.     }

  77. }

  78. 

  79. static void common_hz_bil_8w_msa(const uint8_t *src, int32_t src_stride,

  80.                                  uint8_t *dst, int32_t dst_stride,

  81.                                  uint8_t height)

  82. {

  83.     uint8_t loop_cnt;

  84.     v16i8 src0, src1, src2, src3, src0_sld1, src1_sld1, src2_sld1, src3_sld1;

  85. 

  86.     for (loop_cnt = (height >> 2); loop_cnt--;) {

  87.         LD_SB4(src, src_stride, src0, src1, src2, src3);

  88.         src += (4 * src_stride);

  89. 

  90.         SLDI_B4_0_SB(src0, src1, src2, src3,

  91.                      src0_sld1, src1_sld1, src2_sld1, src3_sld1, 1);

  92.         AVER_ST8x4_UB(src0, src0_sld1, src1, src1_sld1,

  93.                       src2, src2_sld1, src3, src3_sld1, dst, dst_stride);

  94.         dst += (4 * dst_stride);

  95.     }

  96. }

  97. 

  98. static void common_hz_bil_16w_msa(const uint8_t *src, int32_t src_stride,

  99.                                   uint8_t *dst, int32_t dst_stride,

  100.                                   uint8_t height)

  101. {

  102.     uint8_t loop_cnt;

  103.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;

  104.     v16u8 src8, src9, src10, src11, src12, src13, src14, src15;

  105. 

  106.     for (loop_cnt = (height >> 3); loop_cnt--;) {

  107.         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  108.         LD_UB8((src + 1), src_stride,

  109.                src8, src9, src10, src11, src12, src13, src14, src15);

  110.         src += (8 * src_stride);

  111. 

  112.         AVER_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,

  113.                        dst, dst_stride);

  114.         dst += (4 * dst_stride);

  115. 

  116.         AVER_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,

  117.                        dst, dst_stride);

  118.         dst += (4 * dst_stride);

  119.     }

  120. }

  121. 

  122. static void common_hz_bil_no_rnd_8x8_msa(const uint8_t *src, int32_t src_stride,

  123.                                          uint8_t *dst, int32_t dst_stride)

  124. {

  125.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;

  126.     v16i8 src0_sld1, src1_sld1, src2_sld1, src3_sld1;

  127.     v16i8 src4_sld1, src5_sld1, src6_sld1, src7_sld1;

  128. 

  129.     LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  130.     src += (8 * src_stride);

  131. 

  132.     SLDI_B4_0_SB(src0, src1, src2, src3,

  133.                  src0_sld1, src1_sld1, src2_sld1, src3_sld1, 1);

  134.     SLDI_B4_0_SB(src4, src5, src6, src7,

  135.                  src4_sld1, src5_sld1, src6_sld1, src7_sld1, 1);

  136. 

  137.     AVE_ST8x4_UB(src0, src0_sld1, src1, src1_sld1,

  138.                  src2, src2_sld1, src3, src3_sld1, dst, dst_stride);

  139.     dst += (4 * dst_stride);

  140.     AVE_ST8x4_UB(src4, src4_sld1, src5, src5_sld1,

  141.                  src6, src6_sld1, src7, src7_sld1, dst, dst_stride);

  142. }

  143. 

  144. static void common_hz_bil_no_rnd_4x8_msa(const uint8_t *src, int32_t src_stride,

  145.                                          uint8_t *dst, int32_t dst_stride)

  146. {

  147.     v16i8 src0, src1, src2, src3, src0_sld1, src1_sld1, src2_sld1, src3_sld1;

  148. 

  149.     LD_SB4(src, src_stride, src0, src1, src2, src3);

  150.     SLDI_B4_0_SB(src0, src1, src2, src3,

  151.                  src0_sld1, src1_sld1, src2_sld1, src3_sld1, 1);

  152.     AVE_ST8x4_UB(src0, src0_sld1, src1, src1_sld1,

  153.                  src2, src2_sld1, src3, src3_sld1, dst, dst_stride);

  154. }

  155. 

  156. static void common_hz_bil_no_rnd_16x16_msa(const uint8_t *src,

  157.                                            int32_t src_stride,

  158.                                            uint8_t *dst, int32_t dst_stride)

  159. {

  160.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  161.     v16u8 src9, src10, src11, src12, src13, src14, src15;

  162. 

  163.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  164.     LD_UB8((src + 1), src_stride,

  165.            src8, src9, src10, src11, src12, src13, src14, src15);

  166.     src += (8 * src_stride);

  167. 

  168.     AVE_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,

  169.                   dst, dst_stride);

  170.     dst += (4 * dst_stride);

  171. 

  172.     LD_UB4(src, src_stride, src0, src1, src2, src3);

  173.     LD_UB4((src + 1), src_stride, src8, src9, src10, src11);

  174.     src += (4 * src_stride);

  175. 

  176.     AVE_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,

  177.                   dst, dst_stride);

  178.     dst += (4 * dst_stride);

  179. 

  180.     LD_UB4(src, src_stride, src4, src5, src6, src7);

  181.     LD_UB4((src + 1), src_stride, src12, src13, src14, src15);

  182.     src += (4 * src_stride);

  183. 

  184.     AVE_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,

  185.                   dst, dst_stride);

  186.     dst += (4 * dst_stride);

  187.     AVE_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,

  188.                   dst, dst_stride);

  189. }

  190. 

  191. static void common_hz_bil_no_rnd_8x16_msa(const uint8_t *src,

  192.                                           int32_t src_stride,

  193.                                           uint8_t *dst, int32_t dst_stride)

  194. {

  195.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  196.     v16u8 src9, src10, src11, src12, src13, src14, src15;

  197. 

  198.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  199.     LD_UB8((src + 1), src_stride,

  200.            src8, src9, src10, src11, src12, src13, src14, src15);

  201. 

  202.     AVE_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,

  203.                   dst, dst_stride);

  204.     dst += (4 * dst_stride);

  205.     AVE_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,

  206.                   dst, dst_stride);

  207. }

  208. 

  209. static void common_hz_bil_and_aver_dst_4w_msa(const uint8_t *src,

  210.                                               int32_t src_stride,

  211.                                               uint8_t *dst, int32_t dst_stride,

  212.                                               uint8_t height)

  213. {

  214.     uint8_t loop_cnt;

  215.     uint32_t dst0, dst1, out0, out1;

  216.     v16u8 src0, src1, src0_sld1, src1_sld1, res0, res1;

  217.     v16u8 tmp0 = { 0 };

  218.     v16u8 tmp1 = { 0 };

  219. 

  220.     for (loop_cnt = (height >> 1); loop_cnt--;) {

  221.         LD_UB2(src, src_stride, src0, src1);

  222.         src += (2 * src_stride);

  223. 

  224.         SLDI_B2_0_UB(src0, src1, src0_sld1, src1_sld1, 1);

  225. 

  226.         dst0 = LW(dst);

  227.         dst1 = LW(dst + dst_stride);

  228.         tmp0 = (v16u8) __msa_insert_w((v4i32) tmp0, 0, dst0);

  229.         tmp1 = (v16u8) __msa_insert_w((v4i32) tmp1, 0, dst1);

  230. 

  231.         AVER_UB2_UB(src0_sld1, src0, src1_sld1, src1, res0, res1);

  232.         AVER_UB2_UB(res0, tmp0, res1, tmp1, res0, res1);

  233. 

  234.         out0 = __msa_copy_u_w((v4i32) res0, 0);

  235.         out1 = __msa_copy_u_w((v4i32) res1, 0);

  236.         SW(out0, dst);

  237.         dst += dst_stride;

  238.         SW(out1, dst);

  239.         dst += dst_stride;

  240.     }

  241. }

  242. 

  243. static void common_hz_bil_and_aver_dst_8w_msa(const uint8_t *src,

  244.                                               int32_t src_stride,

  245.                                               uint8_t *dst, int32_t dst_stride,

  246.                                               uint8_t height)

  247. {

  248.     uint8_t loop_cnt;

  249.     v16i8 src0, src1, src2, src3, src0_sld1, src1_sld1, src2_sld1, src3_sld1;

  250. 

  251.     for (loop_cnt = (height >> 2); loop_cnt--;) {

  252.         LD_SB4(src, src_stride, src0, src1, src2, src3);

  253.         src += (4 * src_stride);

  254. 

  255.         SLDI_B4_0_SB(src0, src1, src2, src3,

  256.                      src0_sld1, src1_sld1, src2_sld1, src3_sld1, 1);

  257. 

  258.         AVER_DST_ST8x4_UB(src0, src0_sld1, src1, src1_sld1, src2, src2_sld1,

  259.                           src3, src3_sld1, dst, dst_stride);

  260.         dst += (4 * dst_stride);

  261.     }

  262. }

  263. 

  264. static void common_hz_bil_and_aver_dst_16w_msa(const uint8_t *src,

  265.                                                int32_t src_stride,

  266.                                                uint8_t *dst, int32_t dst_stride,

  267.                                                uint8_t height)

  268. {

  269.     uint8_t loop_cnt;

  270.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  271.     v16u8 src9, src10, src11, src12, src13, src14, src15;

  272. 

  273.     for (loop_cnt = (height >> 3); loop_cnt--;) {

  274.         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  275.         LD_UB8((src + 1), src_stride,

  276.                src8, src9, src10, src11, src12, src13, src14, src15);

  277.         src += (8 * src_stride);

  278. 

  279.         AVER_DST_ST16x4_UB(src0, src8, src1, src9, src2, src10, src3, src11,

  280.                            dst, dst_stride);

  281.         dst += (4 * dst_stride);

  282.         AVER_DST_ST16x4_UB(src4, src12, src5, src13, src6, src14, src7, src15,

  283.                            dst, dst_stride);

  284.         dst += (4 * dst_stride);

  285.     }

  286. }

  287. 

  288. static void common_vt_bil_4w_msa(const uint8_t *src, int32_t src_stride,

  289.                                  uint8_t *dst, int32_t dst_stride,

  290.                                  uint8_t height)

  291. {

  292.     uint8_t loop_cnt;

  293.     uint32_t out0, out1;

  294.     v16u8 src0, src1, src2, res0, res1;

  295. 

  296.     src0 = LD_UB(src);

  297.     src += src_stride;

  298. 

  299.     for (loop_cnt = (height >> 1); loop_cnt--;) {

  300.         LD_UB2(src, src_stride, src1, src2);

  301.         src += (2 * src_stride);

  302. 

  303.         AVER_UB2_UB(src0, src1, src1, src2, res0, res1);

  304. 

  305.         out0 = __msa_copy_u_w((v4i32) res0, 0);

  306.         out1 = __msa_copy_u_w((v4i32) res1, 0);

  307.         SW(out0, dst);

  308.         dst += dst_stride;

  309.         SW(out1, dst);

  310.         dst += dst_stride;

  311. 

  312.         src0 = src2;

  313.     }

  314. }

  315. 

  316. static void common_vt_bil_8w_msa(const uint8_t *src, int32_t src_stride,

  317.                                  uint8_t *dst, int32_t dst_stride,

  318.                                  uint8_t height)

  319. {

  320.     uint8_t loop_cnt;

  321.     v16u8 src0, src1, src2, src3, src4;

  322. 

  323.     src0 = LD_UB(src);

  324.     src += src_stride;

  325. 

  326.     for (loop_cnt = (height >> 2); loop_cnt--;) {

  327.         LD_UB4(src, src_stride, src1, src2, src3, src4);

  328.         src += (4 * src_stride);

  329. 

  330.         AVER_ST8x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,

  331.                       dst, dst_stride);

  332.         dst += (4 * dst_stride);

  333. 

  334.         src0 = src4;

  335.     }

  336. }

  337. 

  338. static void common_vt_bil_16w_msa(const uint8_t *src, int32_t src_stride,

  339.                                   uint8_t *dst, int32_t dst_stride,

  340.                                   uint8_t height)

  341. {

  342.     uint8_t loop_cnt;

  343.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  344. 

  345.     src0 = LD_UB(src);

  346.     src += src_stride;

  347. 

  348.     for (loop_cnt = (height >> 3); loop_cnt--;) {

  349.         LD_UB8(src, src_stride, src1, src2, src3, src4, src5, src6, src7, src8);

  350.         src += (8 * src_stride);

  351. 

  352.         AVER_ST16x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,

  353.                        dst, dst_stride);

  354.         dst += (4 * dst_stride);

  355.         AVER_ST16x4_UB(src4, src5, src5, src6, src6, src7, src7, src8,

  356.                        dst, dst_stride);

  357.         dst += (4 * dst_stride);

  358. 

  359.         src0 = src8;

  360.     }

  361. }

  362. 

  363. static void common_vt_bil_no_rnd_8x8_msa(const uint8_t *src, int32_t src_stride,

  364.                                          uint8_t *dst, int32_t dst_stride)

  365. {

  366.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  367. 

  368.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  369.     src += (8 * src_stride);

  370.     src8 = LD_UB(src);

  371. 

  372.     AVE_ST8x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,

  373.                  dst, dst_stride);

  374.     dst += (4 * dst_stride);

  375. 

  376.     AVE_ST8x4_UB(src4, src5, src5, src6, src6, src7, src7, src8,

  377.                  dst, dst_stride);

  378. }

  379. 

  380. static void common_vt_bil_no_rnd_4x8_msa(const uint8_t *src, int32_t src_stride,

  381.                                          uint8_t *dst, int32_t dst_stride)

  382. {

  383.     v16u8 src0, src1, src2, src3, src4;

  384. 

  385.     LD_UB5(src, src_stride, src0, src1, src2, src3, src4);

  386.     AVE_ST8x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,

  387.                  dst, dst_stride);

  388. }

  389. 

  390. static void common_vt_bil_no_rnd_16x16_msa(const uint8_t *src,

  391.                                            int32_t src_stride,

  392.                                            uint8_t *dst, int32_t dst_stride)

  393. {

  394.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  395.     v16u8 src9, src10, src11, src12, src13, src14, src15, src16;

  396. 

  397.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  398.     src += (8 * src_stride);

  399.     LD_UB8(src, src_stride,

  400.            src8, src9, src10, src11, src12, src13, src14, src15);

  401.     src += (8 * src_stride);

  402.     src16 = LD_UB(src);

  403. 

  404.     AVE_ST16x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,

  405.                   dst, dst_stride);

  406.     dst += (4 * dst_stride);

  407.     AVE_ST16x4_UB(src4, src5, src5, src6, src6, src7, src7, src8,

  408.                   dst, dst_stride);

  409.     dst += (4 * dst_stride);

  410.     AVE_ST16x4_UB(src8, src9, src9, src10, src10, src11, src11, src12,

  411.                   dst, dst_stride);

  412.     dst += (4 * dst_stride);

  413.     AVE_ST16x4_UB(src12, src13, src13, src14,

  414.                   src14, src15, src15, src16, dst, dst_stride);

  415. }

  416. 

  417. static void common_vt_bil_no_rnd_8x16_msa(const uint8_t *src,

  418.                                           int32_t src_stride,

  419.                                           uint8_t *dst, int32_t dst_stride)

  420. {

  421.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  422. 

  423.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  424.     src += (8 * src_stride);

  425.     src8 = LD_UB(src);

  426. 

  427.     AVE_ST16x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,

  428.                   dst, dst_stride);

  429.     dst += (4 * dst_stride);

  430.     AVE_ST16x4_UB(src4, src5, src5, src6, src6, src7, src7, src8,

  431.                   dst, dst_stride);

  432. }

  433. 

  434. static void common_vt_bil_and_aver_dst_4w_msa(const uint8_t *src,

  435.                                               int32_t src_stride,

  436.                                               uint8_t *dst, int32_t dst_stride,

  437.                                               uint8_t height)

  438. {

  439.     uint8_t loop_cnt;

  440.     uint32_t out0, out1, dst0, dst1;

  441.     v16u8 src0, src1, src2;

  442.     v16u8 tmp0 = { 0 };

  443.     v16u8 tmp1 = { 0 };

  444.     v16u8 res0, res1;

  445. 

  446.     src0 = LD_UB(src);

  447.     src += src_stride;

  448. 

  449.     for (loop_cnt = (height >> 1); loop_cnt--;) {

  450.         LD_UB2(src, src_stride, src1, src2);

  451.         src += (2 * src_stride);

  452.         dst0 = LW(dst);

  453.         dst1 = LW(dst + dst_stride);

  454.         tmp0 = (v16u8) __msa_insert_w((v4i32) tmp0, 0, dst0);

  455.         tmp1 = (v16u8) __msa_insert_w((v4i32) tmp1, 0, dst1);

  456.         AVER_UB2_UB(src0, src1, src1, src2, res0, res1);

  457.         AVER_UB2_UB(res0, tmp0, res1, tmp1, res0, res1);

  458.         out0 = __msa_copy_u_w((v4i32) res0, 0);

  459.         out1 = __msa_copy_u_w((v4i32) res1, 0);

  460.         SW(out0, dst);

  461.         dst += dst_stride;

  462.         SW(out1, dst);

  463.         dst += dst_stride;

  464.         src0 = src2;

  465.     }

  466. }

  467. 

  468. static void common_vt_bil_and_aver_dst_8w_msa(const uint8_t *src,

  469.                                               int32_t src_stride,

  470.                                               uint8_t *dst, int32_t dst_stride,

  471.                                               uint8_t height)

  472. {

  473.     uint8_t loop_cnt;

  474.     v16u8 src0, src1, src2, src3, src4;

  475. 

  476.     src0 = LD_UB(src);

  477.     src += src_stride;

  478. 

  479.     for (loop_cnt = (height >> 2); loop_cnt--;) {

  480.         LD_UB4(src, src_stride, src1, src2, src3, src4);

  481.         src += (4 * src_stride);

  482. 

  483.         AVER_DST_ST8x4_UB(src0, src1, src1, src2, src2, src3, src3, src4,

  484.                           dst, dst_stride);

  485.         dst += (4 * dst_stride);

  486.         src0 = src4;

  487.     }

  488. }

  489. 

  490. static void common_vt_bil_and_aver_dst_16w_msa(const uint8_t *src,

  491.                                                int32_t src_stride,

  492.                                                uint8_t *dst, int32_t dst_stride,

  493.                                                uint8_t height)

  494. {

  495.     uint8_t loop_cnt;

  496.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  497.     v16u8 res0, res1, res2, res3, res4, res5, res6, res7;

  498.     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;

  499. 

  500.     src0 = LD_UB(src);

  501.     src += src_stride;

  502. 

  503.     for (loop_cnt = (height >> 3); loop_cnt--;) {

  504.         LD_UB8(src, src_stride, src1, src2, src3, src4, src5, src6, src7, src8);

  505.         src += (8 * src_stride);

  506.         AVER_UB4_UB(src0, src1, src1, src2, src2, src3, src3, src4,

  507.                     res0, res1, res2, res3);

  508.         AVER_UB4_UB(src4, src5, src5, src6, src6, src7, src7, src8,

  509.                     res4, res5, res6, res7);

  510. 

  511.         LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);

  512.         AVER_UB4_UB(dst0, res0, dst1, res1, dst2, res2, dst3, res3,

  513.                     res0, res1, res2, res3);

  514.         AVER_UB4_UB(dst4, res4, dst5, res5, dst6, res6, dst7, res7,

  515.                     res4, res5, res6, res7);

  516.         ST_UB8(res0, res1, res2, res3, res4, res5, res6, res7, dst, dst_stride);

  517.         dst += (8 * dst_stride);

  518. 

  519.         src0 = src8;

  520.     }

  521. }

  522. 

  523. static void common_hv_bil_4w_msa(const uint8_t *src, int32_t src_stride,

  524.                                  uint8_t *dst, int32_t dst_stride,

  525.                                  uint8_t height)

  526. {

  527.     uint8_t loop_cnt;

  528.     uint32_t res0, res1;

  529.     v16i8 src0, src1, src2, src0_sld1, src1_sld1, src2_sld1;

  530.     v16u8 src0_r, src1_r, src2_r, res;

  531.     v8u16 add0, add1, add2, sum0, sum1;

  532. 

  533.     src0 = LD_SB(src);

  534.     src += src_stride;

  535. 

  536.     for (loop_cnt = (height >> 1); loop_cnt--;) {

  537.         LD_SB2(src, src_stride, src1, src2);

  538.         src += (2 * src_stride);

  539. 

  540.         SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);

  541.         ILVR_B3_UB(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2,

  542.                    src0_r, src1_r, src2_r);

  543.         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);

  544.         ADD2(add0, add1, add1, add2, sum0, sum1);

  545.         SRARI_H2_UH(sum0, sum1, 2);

  546.         res = (v16u8) __msa_pckev_b((v16i8) sum1, (v16i8) sum0);

  547.         res0 = __msa_copy_u_w((v4i32) res, 0);

  548.         res1 = __msa_copy_u_w((v4i32) res, 2);

  549.         SW(res0, dst);

  550.         dst += dst_stride;

  551.         SW(res1, dst);

  552.         dst += dst_stride;

  553. 

  554.         src0 = src2;

  555.     }

  556. }

  557. 

  558. static void common_hv_bil_8w_msa(const uint8_t *src, int32_t src_stride,

  559.                                  uint8_t *dst, int32_t dst_stride,

  560.                                  uint8_t height)

  561. {

  562.     uint8_t loop_cnt;

  563.     v16i8 src0, src1, src2, src3, src4;

  564.     v16i8 src0_sld1, src1_sld1, src2_sld1, src3_sld1, src4_sld1;

  565.     v16u8 src0_r, src1_r, src2_r, src3_r, src4_r;

  566.     v8u16 add0, add1, add2, add3, add4;

  567.     v8u16 sum0, sum1, sum2, sum3;

  568. 

  569.     src0 = LD_SB(src);

  570.     src += src_stride;

  571. 

  572.     for (loop_cnt = (height >> 2); loop_cnt--;) {

  573.         LD_SB4(src, src_stride, src1, src2, src3, src4);

  574.         src += (4 * src_stride);

  575. 

  576.         SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);

  577.         SLDI_B2_0_SB(src3, src4, src3_sld1, src4_sld1, 1);

  578.         ILVR_B3_UB(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src0_r,

  579.                    src1_r, src2_r);

  580.         ILVR_B2_UB(src3_sld1, src3, src4_sld1, src4, src3_r, src4_r);

  581.         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);

  582.         HADD_UB2_UH(src3_r, src4_r, add3, add4);

  583.         ADD4(add0, add1, add1, add2, add2, add3, add3, add4,

  584.              sum0, sum1, sum2, sum3);

  585.         SRARI_H4_UH(sum0, sum1, sum2, sum3, 2);

  586.         PCKEV_B2_SB(sum1, sum0, sum3, sum2, src0, src1);

  587.         ST8x4_UB(src0, src1, dst, dst_stride);

  588.         dst += (4 * dst_stride);

  589.         src0 = src4;

  590.     }

  591. }

  592. 

  593. static void common_hv_bil_16w_msa(const uint8_t *src, int32_t src_stride,

  594.                                   uint8_t *dst, int32_t dst_stride,

  595.                                   uint8_t height)

  596. {

  597.     uint8_t loop_cnt;

  598.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;

  599.     v16u8 src10, src11, src12, src13, src14, src15, src16, src17;

  600.     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;

  601.     v8u16 src8_r, src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l;

  602.     v8u16 src7_l, src8_l;

  603.     v8u16 sum0_r, sum1_r, sum2_r, sum3_r, sum4_r, sum5_r, sum6_r, sum7_r;

  604.     v8u16 sum0_l, sum1_l, sum2_l, sum3_l, sum4_l, sum5_l, sum6_l, sum7_l;

  605. 

  606.     for (loop_cnt = (height >> 3); loop_cnt--;) {

  607.         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  608.         LD_UB8((src + 1), src_stride,

  609.                src9, src10, src11, src12, src13, src14, src15, src16);

  610.         src += (8 * src_stride);

  611. 

  612.         src8 = LD_UB(src);

  613.         src17 = LD_UB(src + 1);

  614. 

  615.         ILVRL_B2_UH(src9, src0, src0_r, src0_l);

  616.         ILVRL_B2_UH(src10, src1, src1_r, src1_l);

  617.         ILVRL_B2_UH(src11, src2, src2_r, src2_l);

  618.         ILVRL_B2_UH(src12, src3, src3_r, src3_l);

  619.         ILVRL_B2_UH(src13, src4, src4_r, src4_l);

  620.         ILVRL_B2_UH(src14, src5, src5_r, src5_l);

  621.         ILVRL_B2_UH(src15, src6, src6_r, src6_l);

  622.         ILVRL_B2_UH(src16, src7, src7_r, src7_l);

  623.         ILVRL_B2_UH(src17, src8, src8_r, src8_l);

  624.         HADD_UB3_UH(src0_r, src1_r, src2_r, src0_r, src1_r, src2_r);

  625.         HADD_UB3_UH(src3_r, src4_r, src5_r, src3_r, src4_r, src5_r);

  626.         HADD_UB3_UH(src6_r, src7_r, src8_r, src6_r, src7_r, src8_r);

  627.         HADD_UB3_UH(src0_l, src1_l, src2_l, src0_l, src1_l, src2_l);

  628.         HADD_UB3_UH(src3_l, src4_l, src5_l, src3_l, src4_l, src5_l);

  629.         HADD_UB3_UH(src6_l, src7_l, src8_l, src6_l, src7_l, src8_l);

  630.         ADD4(src0_r, src1_r, src1_r, src2_r, src2_r, src3_r, src3_r, src4_r,

  631.              sum0_r, sum1_r, sum2_r, sum3_r);

  632.         ADD4(src4_r, src5_r, src5_r, src6_r, src6_r, src7_r, src7_r, src8_r,

  633.              sum4_r, sum5_r, sum6_r, sum7_r);

  634.         ADD4(src0_l, src1_l, src1_l, src2_l, src2_l, src3_l, src3_l, src4_l,

  635.              sum0_l, sum1_l, sum2_l, sum3_l);

  636.         ADD4(src4_l, src5_l, src5_l, src6_l, src6_l, src7_l, src7_l, src8_l,

  637.              sum4_l, sum5_l, sum6_l, sum7_l);

  638.         SRARI_H4_UH(sum0_r, sum1_r, sum2_r, sum3_r, 2);

  639.         SRARI_H4_UH(sum4_r, sum5_r, sum6_r, sum7_r, 2);

  640.         SRARI_H4_UH(sum0_l, sum1_l, sum2_l, sum3_l, 2);

  641.         SRARI_H4_UH(sum4_l, sum5_l, sum6_l, sum7_l, 2);

  642.         PCKEV_ST_SB4(sum0_l, sum0_r, sum1_l, sum1_r, sum2_l, sum2_r,

  643.                      sum3_l, sum3_r, dst, dst_stride);

  644.         dst += (4 * dst_stride);

  645.         PCKEV_ST_SB4(sum4_l, sum4_r, sum5_l, sum5_r, sum6_l, sum6_r,

  646.                      sum7_l, sum7_r, dst, dst_stride);

  647.         dst += (4 * dst_stride);

  648.     }

  649. }

  650. 

  651. static void common_hv_bil_no_rnd_8x8_msa(const uint8_t *src, int32_t src_stride,

  652.                                          uint8_t *dst, int32_t dst_stride)

  653. {

  654.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;

  655.     v16u8 src0_sld1, src1_sld1, src2_sld1, src3_sld1;

  656.     v16u8 src4_sld1, src5_sld1, src6_sld1, src7_sld1, src8_sld1;

  657.     v8u16 src0_r, src1_r, src2_r, src3_r;

  658.     v8u16 src4_r, src5_r, src6_r, src7_r, src8_r;

  659.     v8u16 add0, add1, add2, add3, add4, add5, add6, add7, add8;

  660.     v8u16 sum0, sum1, sum2, sum3, sum4, sum5, sum6, sum7;

  661.     v16i8 out0, out1;

  662. 

  663.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  664.     src += (8 * src_stride);

  665.     src8 = LD_UB(src);

  666. 

  667.     SLDI_B4_0_UB(src0, src1, src2, src3, src0_sld1, src1_sld1, src2_sld1,

  668.                  src3_sld1, 1);

  669.     SLDI_B3_0_UB(src4, src5, src6, src4_sld1, src5_sld1, src6_sld1, 1);

  670.     SLDI_B2_0_UB(src7, src8, src7_sld1, src8_sld1, 1);

  671.     ILVR_B4_UH(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src3_sld1,

  672.                src3, src0_r, src1_r, src2_r, src3_r);

  673.     ILVR_B3_UH(src4_sld1, src4, src5_sld1, src5, src6_sld1, src6, src4_r,

  674.                src5_r, src6_r);

  675.     ILVR_B2_UH(src7_sld1, src7, src8_sld1, src8, src7_r, src8_r);

  676.     HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);

  677.     HADD_UB3_UH(src3_r, src4_r, src5_r, add3, add4, add5);

  678.     HADD_UB3_UH(src6_r, src7_r, src8_r, add6, add7, add8);

  679. 

  680.     sum0 = add0 + add1 + 1;

  681.     sum1 = add1 + add2 + 1;

  682.     sum2 = add2 + add3 + 1;

  683.     sum3 = add3 + add4 + 1;

  684.     sum4 = add4 + add5 + 1;

  685.     sum5 = add5 + add6 + 1;

  686.     sum6 = add6 + add7 + 1;

  687.     sum7 = add7 + add8 + 1;

  688. 

  689.     SRA_4V(sum0, sum1, sum2, sum3, 2);

  690.     SRA_4V(sum4, sum5, sum6, sum7, 2);

  691.     PCKEV_B2_SB(sum1, sum0, sum3, sum2, out0, out1);

  692.     ST8x4_UB(out0, out1, dst, dst_stride);

  693.     PCKEV_B2_SB(sum5, sum4, sum7, sum6, out0, out1);

  694.     ST8x4_UB(out0, out1, dst + 4 * dst_stride, dst_stride);

  695. }

  696. 

  697. static void common_hv_bil_no_rnd_4x8_msa(const uint8_t *src, int32_t src_stride,

  698.                                          uint8_t *dst, int32_t dst_stride)

  699. {

  700.     v16i8 src0, src1, src2, src3, src4;

  701.     v16i8 src0_sld1, src1_sld1, src2_sld1, src3_sld1, src4_sld1;

  702.     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r;

  703.     v8u16 add0, add1, add2, add3, add4;

  704.     v8u16 sum0, sum1, sum2, sum3;

  705.     v16i8 out0, out1;

  706. 

  707.     LD_SB4(src, src_stride, src0, src1, src2, src3);

  708.     src += (4 * src_stride);

  709.     src4 = LD_SB(src);

  710. 

  711.     SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);

  712.     SLDI_B2_0_SB(src3, src4, src3_sld1, src4_sld1, 1);

  713.     ILVR_B3_UH(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src0_r,

  714.                src1_r, src2_r);

  715.     ILVR_B2_UH(src3_sld1, src3, src4_sld1, src4, src3_r, src4_r);

  716.     HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);

  717.     HADD_UB2_UH(src3_r, src4_r, add3, add4);

  718. 

  719.     sum0 = add0 + add1 + 1;

  720.     sum1 = add1 + add2 + 1;

  721.     sum2 = add2 + add3 + 1;

  722.     sum3 = add3 + add4 + 1;

  723. 

  724.     SRA_4V(sum0, sum1, sum2, sum3, 2);

  725.     PCKEV_B2_SB(sum1, sum0, sum3, sum2, out0, out1);

  726.     ST8x4_UB(out0, out1, dst, dst_stride);

  727. }

  728. 

  729. static void common_hv_bil_no_rnd_16x16_msa(const uint8_t *src,

  730.                                            int32_t src_stride,

  731.                                            uint8_t *dst, int32_t dst_stride)

  732. {

  733.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;

  734.     v16u8 src10, src11, src12, src13, src14, src15, src16, src17;

  735.     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;

  736.     v8u16 src8_r, src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l;

  737.     v8u16 src7_l, src8_l;

  738.     v8u16 sum0_r, sum1_r, sum2_r, sum3_r, sum4_r, sum5_r, sum6_r, sum7_r;

  739.     v8u16 sum0_l, sum1_l, sum2_l, sum3_l, sum4_l, sum5_l, sum6_l, sum7_l;

  740. 

  741.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  742.     LD_UB8((src + 1), src_stride,

  743.            src9, src10, src11, src12, src13, src14, src15, src16);

  744.     src += (8 * src_stride);

  745.     src8 = LD_UB(src);

  746.     src17 = LD_UB(src + 1);

  747. 

  748.     ILVRL_B2_UH(src9, src0, src0_r, src0_l);

  749.     ILVRL_B2_UH(src10, src1, src1_r, src1_l);

  750.     ILVRL_B2_UH(src11, src2, src2_r, src2_l);

  751.     ILVRL_B2_UH(src12, src3, src3_r, src3_l);

  752.     ILVRL_B2_UH(src13, src4, src4_r, src4_l);

  753.     ILVRL_B2_UH(src14, src5, src5_r, src5_l);

  754.     ILVRL_B2_UH(src15, src6, src6_r, src6_l);

  755.     ILVRL_B2_UH(src16, src7, src7_r, src7_l);

  756.     ILVRL_B2_UH(src17, src8, src8_r, src8_l);

  757. 

  758.     HADD_UB3_UH(src0_r, src1_r, src2_r, src0_r, src1_r, src2_r);

  759.     HADD_UB3_UH(src3_r, src4_r, src5_r, src3_r, src4_r, src5_r);

  760.     HADD_UB3_UH(src6_r, src7_r, src8_r, src6_r, src7_r, src8_r);

  761.     HADD_UB3_UH(src0_l, src1_l, src2_l, src0_l, src1_l, src2_l);

  762.     HADD_UB3_UH(src3_l, src4_l, src5_l, src3_l, src4_l, src5_l);

  763.     HADD_UB3_UH(src6_l, src7_l, src8_l, src6_l, src7_l, src8_l);

  764. 

  765.     sum0_r = src0_r + src1_r + 1;

  766.     sum1_r = src1_r + src2_r + 1;

  767.     sum2_r = src2_r + src3_r + 1;

  768.     sum3_r = src3_r + src4_r + 1;

  769.     sum4_r = src4_r + src5_r + 1;

  770.     sum5_r = src5_r + src6_r + 1;

  771.     sum6_r = src6_r + src7_r + 1;

  772.     sum7_r = src7_r + src8_r + 1;

  773.     sum0_l = src0_l + src1_l + 1;

  774.     sum1_l = src1_l + src2_l + 1;

  775.     sum2_l = src2_l + src3_l + 1;

  776.     sum3_l = src3_l + src4_l + 1;

  777.     sum4_l = src4_l + src5_l + 1;

  778.     sum5_l = src5_l + src6_l + 1;

  779.     sum6_l = src6_l + src7_l + 1;

  780.     sum7_l = src7_l + src8_l + 1;

  781. 

  782.     SRA_4V(sum0_r, sum1_r, sum2_r, sum3_r, 2);

  783.     SRA_4V(sum4_r, sum5_r, sum6_r, sum7_r, 2);

  784.     SRA_4V(sum0_l, sum1_l, sum2_l, sum3_l, 2);

  785.     SRA_4V(sum4_l, sum5_l, sum6_l, sum7_l, 2);

  786.     PCKEV_ST_SB4(sum0_l, sum0_r, sum1_l, sum1_r,

  787.                  sum2_l, sum2_r, sum3_l, sum3_r, dst, dst_stride);

  788.     dst += (4 * dst_stride);

  789. 

  790.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  791.     LD_UB8((src + 1), src_stride,

  792.            src9, src10, src11, src12, src13, src14, src15, src16);

  793.     src += (8 * src_stride);

  794.     src8 = LD_UB(src);

  795.     src17 = LD_UB(src + 1);

  796. 

  797.     PCKEV_ST_SB4(sum4_l, sum4_r, sum5_l, sum5_r,

  798.                  sum6_l, sum6_r, sum7_l, sum7_r, dst, dst_stride);

  799.     dst += (4 * dst_stride);

  800. 

  801.     ILVRL_B2_UH(src9, src0, src0_r, src0_l);

  802.     ILVRL_B2_UH(src10, src1, src1_r, src1_l);

  803.     ILVRL_B2_UH(src11, src2, src2_r, src2_l);

  804.     ILVRL_B2_UH(src12, src3, src3_r, src3_l);

  805.     ILVRL_B2_UH(src13, src4, src4_r, src4_l);

  806.     ILVRL_B2_UH(src14, src5, src5_r, src5_l);

  807.     ILVRL_B2_UH(src15, src6, src6_r, src6_l);

  808.     ILVRL_B2_UH(src16, src7, src7_r, src7_l);

  809.     ILVRL_B2_UH(src17, src8, src8_r, src8_l);

  810. 

  811.     HADD_UB3_UH(src0_r, src1_r, src2_r, src0_r, src1_r, src2_r);

  812.     HADD_UB3_UH(src3_r, src4_r, src5_r, src3_r, src4_r, src5_r);

  813.     HADD_UB3_UH(src6_r, src7_r, src8_r, src6_r, src7_r, src8_r);

  814.     HADD_UB3_UH(src0_l, src1_l, src2_l, src0_l, src1_l, src2_l);

  815.     HADD_UB3_UH(src3_l, src4_l, src5_l, src3_l, src4_l, src5_l);

  816.     HADD_UB3_UH(src6_l, src7_l, src8_l, src6_l, src7_l, src8_l);

  817. 

  818.     sum0_r = src0_r + src1_r + 1;

  819.     sum1_r = src1_r + src2_r + 1;

  820.     sum2_r = src2_r + src3_r + 1;

  821.     sum3_r = src3_r + src4_r + 1;

  822.     sum4_r = src4_r + src5_r + 1;

  823.     sum5_r = src5_r + src6_r + 1;

  824.     sum6_r = src6_r + src7_r + 1;

  825.     sum7_r = src7_r + src8_r + 1;

  826.     sum0_l = src0_l + src1_l + 1;

  827.     sum1_l = src1_l + src2_l + 1;

  828.     sum2_l = src2_l + src3_l + 1;

  829.     sum3_l = src3_l + src4_l + 1;

  830.     sum4_l = src4_l + src5_l + 1;

  831.     sum5_l = src5_l + src6_l + 1;

  832.     sum6_l = src6_l + src7_l + 1;

  833.     sum7_l = src7_l + src8_l + 1;

  834. 

  835.     SRA_4V(sum0_r, sum1_r, sum2_r, sum3_r, 2);

  836.     SRA_4V(sum4_r, sum5_r, sum6_r, sum7_r, 2);

  837.     SRA_4V(sum0_l, sum1_l, sum2_l, sum3_l, 2);

  838.     SRA_4V(sum4_l, sum5_l, sum6_l, sum7_l, 2);

  839.     PCKEV_ST_SB4(sum0_l, sum0_r, sum1_l, sum1_r,

  840.                  sum2_l, sum2_r, sum3_l, sum3_r, dst, dst_stride);

  841.     dst += (4 * dst_stride);

  842.     PCKEV_ST_SB4(sum4_l, sum4_r, sum5_l, sum5_r,

  843.                  sum6_l, sum6_r, sum7_l, sum7_r, dst, dst_stride);

  844. }

  845. 

  846. static void common_hv_bil_no_rnd_8x16_msa(const uint8_t *src,

  847.                                           int32_t src_stride,

  848.                                           uint8_t *dst, int32_t dst_stride)

  849. {

  850.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;

  851.     v16u8 src10, src11, src12, src13, src14, src15, src16, src17;

  852.     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;

  853.     v8u16 src8_r, src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l;

  854.     v8u16 src7_l, src8_l;

  855.     v8u16 sum0_r, sum1_r, sum2_r, sum3_r, sum4_r, sum5_r, sum6_r, sum7_r;

  856.     v8u16 sum0_l, sum1_l, sum2_l, sum3_l, sum4_l, sum5_l, sum6_l, sum7_l;

  857. 

  858.     LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  859.     LD_UB8((src + 1), src_stride,

  860.            src9, src10, src11, src12, src13, src14, src15, src16);

  861.     src += (8 * src_stride);

  862.     src8 = LD_UB(src);

  863.     src17 = LD_UB(src + 1);

  864. 

  865.     ILVRL_B2_UH(src9, src0, src0_r, src0_l);

  866.     ILVRL_B2_UH(src10, src1, src1_r, src1_l);

  867.     ILVRL_B2_UH(src11, src2, src2_r, src2_l);

  868.     ILVRL_B2_UH(src12, src3, src3_r, src3_l);

  869.     ILVRL_B2_UH(src13, src4, src4_r, src4_l);

  870.     ILVRL_B2_UH(src14, src5, src5_r, src5_l);

  871.     ILVRL_B2_UH(src15, src6, src6_r, src6_l);

  872.     ILVRL_B2_UH(src16, src7, src7_r, src7_l);

  873.     ILVRL_B2_UH(src17, src8, src8_r, src8_l);

  874. 

  875.     HADD_UB3_UH(src0_r, src1_r, src2_r, src0_r, src1_r, src2_r);

  876.     HADD_UB3_UH(src3_r, src4_r, src5_r, src3_r, src4_r, src5_r);

  877.     HADD_UB3_UH(src6_r, src7_r, src8_r, src6_r, src7_r, src8_r);

  878.     HADD_UB3_UH(src0_l, src1_l, src2_l, src0_l, src1_l, src2_l);

  879.     HADD_UB3_UH(src3_l, src4_l, src5_l, src3_l, src4_l, src5_l);

  880.     HADD_UB3_UH(src6_l, src7_l, src8_l, src6_l, src7_l, src8_l);

  881. 

  882.     sum0_r = src0_r + src1_r + 1;

  883.     sum1_r = src1_r + src2_r + 1;

  884.     sum2_r = src2_r + src3_r + 1;

  885.     sum3_r = src3_r + src4_r + 1;

  886.     sum4_r = src4_r + src5_r + 1;

  887.     sum5_r = src5_r + src6_r + 1;

  888.     sum6_r = src6_r + src7_r + 1;

  889.     sum7_r = src7_r + src8_r + 1;

  890.     sum0_l = src0_l + src1_l + 1;

  891.     sum1_l = src1_l + src2_l + 1;

  892.     sum2_l = src2_l + src3_l + 1;

  893.     sum3_l = src3_l + src4_l + 1;

  894.     sum4_l = src4_l + src5_l + 1;

  895.     sum5_l = src5_l + src6_l + 1;

  896.     sum6_l = src6_l + src7_l + 1;

  897.     sum7_l = src7_l + src8_l + 1;

  898. 

  899.     SRA_4V(sum0_r, sum1_r, sum2_r, sum3_r, 2);

  900.     SRA_4V(sum4_r, sum5_r, sum6_r, sum7_r, 2);

  901.     SRA_4V(sum0_l, sum1_l, sum2_l, sum3_l, 2);

  902.     SRA_4V(sum4_l, sum5_l, sum6_l, sum7_l, 2);

  903.     PCKEV_ST_SB4(sum0_l, sum0_r, sum1_l, sum1_r,

  904.                  sum2_l, sum2_r, sum3_l, sum3_r, dst, dst_stride);

  905.     dst += (4 * dst_stride);

  906.     PCKEV_ST_SB4(sum4_l, sum4_r, sum5_l, sum5_r,

  907.                  sum6_l, sum6_r, sum7_l, sum7_r, dst, dst_stride);

  908. }

  909. 

  910. static void common_hv_bil_and_aver_dst_4w_msa(const uint8_t *src,

  911.                                               int32_t src_stride,

  912.                                               uint8_t *dst, int32_t dst_stride,

  913.                                               uint8_t height)

  914. {

  915.     uint8_t loop_cnt;

  916.     uint32_t out0, out1;

  917.     v16i8 src0, src1, src2, src0_sld1, src1_sld1, src2_sld1;

  918.     v16u8 src0_r, src1_r, src2_r;

  919.     v8u16 add0, add1, add2, sum0, sum1;

  920.     v16u8 dst0, dst1, res0, res1;

  921. 

  922.     src0 = LD_SB(src);

  923.     src += src_stride;

  924. 

  925.     for (loop_cnt = (height >> 1); loop_cnt--;) {

  926.         LD_SB2(src, src_stride, src1, src2);

  927.         src += (2 * src_stride);

  928. 

  929.         LD_UB2(dst, dst_stride, dst0, dst1);

  930.         SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);

  931.         ILVR_B3_UB(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src0_r,

  932.                    src1_r, src2_r);

  933.         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);

  934.         ADD2(add0, add1, add1, add2, sum0, sum1);

  935.         SRARI_H2_UH(sum0, sum1, 2);

  936.         PCKEV_B2_UB(sum0, sum0, sum1, sum1, res0, res1);

  937.         AVER_UB2_UB(dst0, res0, dst1, res1, res0, res1);

  938. 

  939.         out0 = __msa_copy_u_w((v4i32) res0, 0);

  940.         out1 = __msa_copy_u_w((v4i32) res1, 0);

  941.         SW(out0, dst);

  942.         dst += dst_stride;

  943.         SW(out1, dst);

  944.         dst += dst_stride;

  945. 

  946.         src0 = src2;

  947.     }

  948. }

  949. 

  950. static void common_hv_bil_and_aver_dst_8w_msa(const uint8_t *src,

  951.                                               int32_t src_stride,

  952.                                               uint8_t *dst, int32_t dst_stride,

  953.                                               uint8_t height)

  954. {

  955.     uint8_t loop_cnt;

  956.     v16i8 src0, src1, src2, src3, src4;

  957.     v16i8 src0_sld1, src1_sld1, src2_sld1, src3_sld1, src4_sld1;

  958.     v16u8 dst0, dst1, dst2, dst3;

  959.     v16u8 src0_r, src1_r, src2_r, src3_r, src4_r;

  960.     v8u16 add0, add1, add2, add3, add4;

  961.     v8u16 sum0, sum1, sum2, sum3;

  962. 

  963.     src0 = LD_SB(src);

  964.     src += src_stride;

  965. 

  966.     for (loop_cnt = (height >> 2); loop_cnt--;) {

  967.         LD_SB4(src, src_stride, src1, src2, src3, src4);

  968.         src += (4 * src_stride);

  969. 

  970.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);

  971.         SLDI_B3_0_SB(src0, src1, src2, src0_sld1, src1_sld1, src2_sld1, 1);

  972.         SLDI_B2_0_SB(src3, src4, src3_sld1, src4_sld1, 1);

  973.         ILVR_B3_UB(src0_sld1, src0, src1_sld1, src1, src2_sld1, src2, src0_r,

  974.                    src1_r, src2_r);

  975.         ILVR_B2_UB(src3_sld1, src3, src4_sld1, src4, src3_r, src4_r);

  976.         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);

  977.         HADD_UB2_UH(src3_r, src4_r, add3, add4);

  978.         ADD4(add0, add1, add1, add2, add2, add3, add3, add4,

  979.              sum0, sum1, sum2, sum3);

  980.         SRARI_H4_UH(sum0, sum1, sum2, sum3, 2);

  981.         PCKEV_AVG_ST8x4_UB(sum0, dst0, sum1, dst1,

  982.                            sum2, dst2, sum3, dst3, dst, dst_stride);

  983.         dst += (4 * dst_stride);

  984.         src0 = src4;

  985.     }

  986. }

  987. 

  988. static void common_hv_bil_and_aver_dst_16w_msa(const uint8_t *src,

  989.                                                int32_t src_stride,

  990.                                                uint8_t *dst, int32_t dst_stride,

  991.                                                uint8_t height)

  992. {

  993.     uint8_t loop_cnt;

  994.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;

  995.     v16u8 src11, src12, src13, src14, src15, src16, src17;

  996.     v16u8 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;

  997.     v16u8 src8_r, src0_l, src1_l, src2_l, src3_l, src4_l, src5_l, src6_l;

  998.     v16u8 src7_l, src8_l;

  999.     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;

  1000.     v8u16 sum0_r, sum1_r, sum2_r, sum3_r, sum4_r, sum5_r, sum6_r, sum7_r;

  1001.     v8u16 sum0_l, sum1_l, sum2_l, sum3_l, sum4_l, sum5_l, sum6_l, sum7_l;

  1002.     v8u16 add0, add1, add2, add3, add4, add5, add6, add7, add8;

  1003. 

  1004.     for (loop_cnt = (height >> 3); loop_cnt--;) {

  1005.         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  1006.         LD_UB8((src + 1), src_stride,

  1007.                src9, src10, src11, src12, src13, src14, src15, src16);

  1008.         src += (8 * src_stride);

  1009. 

  1010.         src8 = LD_UB(src);

  1011.         src17 = LD_UB(src + 1);

  1012. 

  1013.         ILVRL_B2_UB(src9, src0, src0_r, src0_l);

  1014.         ILVRL_B2_UB(src10, src1, src1_r, src1_l);

  1015.         ILVRL_B2_UB(src11, src2, src2_r, src2_l);

  1016.         ILVRL_B2_UB(src12, src3, src3_r, src3_l);

  1017.         ILVRL_B2_UB(src13, src4, src4_r, src4_l);

  1018.         ILVRL_B2_UB(src14, src5, src5_r, src5_l);

  1019.         ILVRL_B2_UB(src15, src6, src6_r, src6_l);

  1020.         ILVRL_B2_UB(src16, src7, src7_r, src7_l);

  1021.         ILVRL_B2_UB(src17, src8, src8_r, src8_l);

  1022.         HADD_UB3_UH(src0_r, src1_r, src2_r, add0, add1, add2);

  1023.         HADD_UB3_UH(src3_r, src4_r, src5_r, add3, add4, add5);

  1024.         HADD_UB3_UH(src6_r, src7_r, src8_r, add6, add7, add8);

  1025.         ADD4(add0, add1, add1, add2, add2, add3, add3, add4, sum0_r, sum1_r,

  1026.              sum2_r, sum3_r);

  1027.         ADD4(add4, add5, add5, add6, add6, add7, add7, add8, sum4_r, sum5_r,

  1028.              sum6_r, sum7_r);

  1029.         HADD_UB3_UH(src0_l, src1_l, src2_l, add0, add1, add2);

  1030.         HADD_UB3_UH(src3_l, src4_l, src5_l, add3, add4, add5);

  1031.         HADD_UB3_UH(src6_l, src7_l, src8_l, add6, add7, add8);

  1032.         ADD4(add0, add1, add1, add2, add2, add3, add3, add4, sum0_l, sum1_l,

  1033.              sum2_l, sum3_l);

  1034.         ADD4(add4, add5, add5, add6, add6, add7, add7, add8, sum4_l, sum5_l,

  1035.              sum6_l, sum7_l);

  1036.         SRARI_H4_UH(sum0_r, sum1_r, sum2_r, sum3_r, 2);

  1037.         SRARI_H4_UH(sum4_r, sum5_r, sum6_r, sum7_r, 2);

  1038.         SRARI_H4_UH(sum0_l, sum1_l, sum2_l, sum3_l, 2);

  1039.         SRARI_H4_UH(sum4_l, sum5_l, sum6_l, sum7_l, 2);

  1040.         LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);

  1041.         PCKEV_AVG_ST_UB(sum0_l, sum0_r, dst0, dst);

  1042.         dst += dst_stride;

  1043.         PCKEV_AVG_ST_UB(sum1_l, sum1_r, dst1, dst);

  1044.         dst += dst_stride;

  1045.         PCKEV_AVG_ST_UB(sum2_l, sum2_r, dst2, dst);

  1046.         dst += dst_stride;

  1047.         PCKEV_AVG_ST_UB(sum3_l, sum3_r, dst3, dst);

  1048.         dst += dst_stride;

  1049.         PCKEV_AVG_ST_UB(sum4_l, sum4_r, dst4, dst);

  1050.         dst += dst_stride;

  1051.         PCKEV_AVG_ST_UB(sum5_l, sum5_r, dst5, dst);

  1052.         dst += dst_stride;

  1053.         PCKEV_AVG_ST_UB(sum6_l, sum6_r, dst6, dst);

  1054.         dst += dst_stride;

  1055.         PCKEV_AVG_ST_UB(sum7_l, sum7_r, dst7, dst);

  1056.         dst += dst_stride;

  1057.     }

  1058. }

  1059. 

  1060. static void copy_width8_msa(const uint8_t *src, int32_t src_stride,

  1061.                             uint8_t *dst, int32_t dst_stride,

  1062.                             int32_t height)

  1063. {

  1064.     int32_t cnt;

  1065.     uint64_t out0, out1, out2, out3, out4, out5, out6, out7;

  1066.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;

  1067. 

  1068.     if (0 == height % 12) {

  1069.         for (cnt = (height / 12); cnt--;) {

  1070.             LD_UB8(src, src_stride,

  1071.                    src0, src1, src2, src3, src4, src5, src6, src7);

  1072.             src += (8 * src_stride);

  1073. 

  1074.             out0 = __msa_copy_u_d((v2i64) src0, 0);

  1075.             out1 = __msa_copy_u_d((v2i64) src1, 0);

  1076.             out2 = __msa_copy_u_d((v2i64) src2, 0);

  1077.             out3 = __msa_copy_u_d((v2i64) src3, 0);

  1078.             out4 = __msa_copy_u_d((v2i64) src4, 0);

  1079.             out5 = __msa_copy_u_d((v2i64) src5, 0);

  1080.             out6 = __msa_copy_u_d((v2i64) src6, 0);

  1081.             out7 = __msa_copy_u_d((v2i64) src7, 0);

  1082. 

  1083.             SD4(out0, out1, out2, out3, dst, dst_stride);

  1084.             dst += (4 * dst_stride);

  1085.             SD4(out4, out5, out6, out7, dst, dst_stride);

  1086.             dst += (4 * dst_stride);

  1087. 

  1088.             LD_UB4(src, src_stride, src0, src1, src2, src3);

  1089.             src += (4 * src_stride);

  1090. 

  1091.             out0 = __msa_copy_u_d((v2i64) src0, 0);

  1092.             out1 = __msa_copy_u_d((v2i64) src1, 0);

  1093.             out2 = __msa_copy_u_d((v2i64) src2, 0);

  1094.             out3 = __msa_copy_u_d((v2i64) src3, 0);

  1095. 

  1096.             SD4(out0, out1, out2, out3, dst, dst_stride);

  1097.             dst += (4 * dst_stride);

  1098.         }

  1099.     } else if (0 == height % 8) {

  1100.         for (cnt = height >> 3; cnt--;) {

  1101.             LD_UB8(src, src_stride,

  1102.                    src0, src1, src2, src3, src4, src5, src6, src7);

  1103.             src += (8 * src_stride);

  1104. 

  1105.             out0 = __msa_copy_u_d((v2i64) src0, 0);

  1106.             out1 = __msa_copy_u_d((v2i64) src1, 0);

  1107.             out2 = __msa_copy_u_d((v2i64) src2, 0);

  1108.             out3 = __msa_copy_u_d((v2i64) src3, 0);

  1109.             out4 = __msa_copy_u_d((v2i64) src4, 0);

  1110.             out5 = __msa_copy_u_d((v2i64) src5, 0);

  1111.             out6 = __msa_copy_u_d((v2i64) src6, 0);

  1112.             out7 = __msa_copy_u_d((v2i64) src7, 0);

  1113. 

  1114.             SD4(out0, out1, out2, out3, dst, dst_stride);

  1115.             dst += (4 * dst_stride);

  1116.             SD4(out4, out5, out6, out7, dst, dst_stride);

  1117.             dst += (4 * dst_stride);

  1118.         }

  1119.     } else if (0 == height % 4) {

  1120.         for (cnt = (height / 4); cnt--;) {

  1121.             LD_UB4(src, src_stride, src0, src1, src2, src3);

  1122.             src += (4 * src_stride);

  1123.             out0 = __msa_copy_u_d((v2i64) src0, 0);

  1124.             out1 = __msa_copy_u_d((v2i64) src1, 0);

  1125.             out2 = __msa_copy_u_d((v2i64) src2, 0);

  1126.             out3 = __msa_copy_u_d((v2i64) src3, 0);

  1127. 

  1128.             SD4(out0, out1, out2, out3, dst, dst_stride);

  1129.             dst += (4 * dst_stride);

  1130.         }

  1131.     } else if (0 == height % 2) {

  1132.         for (cnt = (height / 2); cnt--;) {

  1133.             LD_UB2(src, src_stride, src0, src1);

  1134.             src += (2 * src_stride);

  1135.             out0 = __msa_copy_u_d((v2i64) src0, 0);

  1136.             out1 = __msa_copy_u_d((v2i64) src1, 0);

  1137. 

  1138.             SD(out0, dst);

  1139.             dst += dst_stride;

  1140.             SD(out1, dst);

  1141.             dst += dst_stride;

  1142.         }

  1143.     }

  1144. }

  1145. 

  1146. static void copy_16multx8mult_msa(const uint8_t *src, int32_t src_stride,

  1147.                                   uint8_t *dst, int32_t dst_stride,

  1148.                                   int32_t height, int32_t width)

  1149. {

  1150.     int32_t cnt, loop_cnt;

  1151.     const uint8_t *src_tmp;

  1152.     uint8_t *dst_tmp;

  1153.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;

  1154. 

  1155.     for (cnt = (width >> 4); cnt--;) {

  1156.         src_tmp = src;

  1157.         dst_tmp = dst;

  1158. 

  1159.         for (loop_cnt = (height >> 3); loop_cnt--;) {

  1160.             LD_UB8(src_tmp, src_stride,

  1161.                    src0, src1, src2, src3, src4, src5, src6, src7);

  1162.             src_tmp += (8 * src_stride);

  1163. 

  1164.             ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,

  1165.                    dst_tmp, dst_stride);

  1166.             dst_tmp += (8 * dst_stride);

  1167.         }

  1168. 

  1169.         src += 16;

  1170.         dst += 16;

  1171.     }

  1172. }

  1173. 

  1174. static void copy_width16_msa(const uint8_t *src, int32_t src_stride,

  1175.                              uint8_t *dst, int32_t dst_stride,

  1176.                              int32_t height)

  1177. {

  1178.     int32_t cnt;

  1179.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;

  1180. 

  1181.     if (0 == height % 12) {

  1182.         for (cnt = (height / 12); cnt--;) {

  1183.             LD_UB8(src, src_stride,

  1184.                    src0, src1, src2, src3, src4, src5, src6, src7);

  1185.             src += (8 * src_stride);

  1186.             ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,

  1187.                    dst, dst_stride);

  1188.             dst += (8 * dst_stride);

  1189. 

  1190.             LD_UB4(src, src_stride, src0, src1, src2, src3);

  1191.             src += (4 * src_stride);

  1192.             ST_UB4(src0, src1, src2, src3, dst, dst_stride);

  1193.             dst += (4 * dst_stride);

  1194.         }

  1195.     } else if (0 == height % 8) {

  1196.         copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);

  1197.     } else if (0 == height % 4) {

  1198.         for (cnt = (height >> 2); cnt--;) {

  1199.             LD_UB4(src, src_stride, src0, src1, src2, src3);

  1200.             src += (4 * src_stride);

  1201. 

  1202.             ST_UB4(src0, src1, src2, src3, dst, dst_stride);

  1203.             dst += (4 * dst_stride);

  1204.         }

  1205.     }

  1206. }

  1207. 

  1208. static void avg_width4_msa(const uint8_t *src, int32_t src_stride,

  1209.                            uint8_t *dst, int32_t dst_stride,

  1210.                            int32_t height)

  1211. {

  1212.     int32_t cnt;

  1213.     uint32_t out0, out1, out2, out3;

  1214.     v16u8 src0, src1, src2, src3;

  1215.     v16u8 dst0, dst1, dst2, dst3;

  1216. 

  1217.     if (0 == (height % 4)) {

  1218.         for (cnt = (height / 4); cnt--;) {

  1219.             LD_UB4(src, src_stride, src0, src1, src2, src3);

  1220.             src += (4 * src_stride);

  1221. 

  1222.             LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);

  1223. 

  1224.             AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,

  1225.                         dst0, dst1, dst2, dst3);

  1226. 

  1227.             out0 = __msa_copy_u_w((v4i32) dst0, 0);

  1228.             out1 = __msa_copy_u_w((v4i32) dst1, 0);

  1229.             out2 = __msa_copy_u_w((v4i32) dst2, 0);

  1230.             out3 = __msa_copy_u_w((v4i32) dst3, 0);

  1231.             SW4(out0, out1, out2, out3, dst, dst_stride);

  1232.             dst += (4 * dst_stride);

  1233.         }

  1234.     } else if (0 == (height % 2)) {

  1235.         for (cnt = (height / 2); cnt--;) {

  1236.             LD_UB2(src, src_stride, src0, src1);

  1237.             src += (2 * src_stride);

  1238. 

  1239.             LD_UB2(dst, dst_stride, dst0, dst1);

  1240. 

  1241.             AVER_UB2_UB(src0, dst0, src1, dst1, dst0, dst1);

  1242. 

  1243.             out0 = __msa_copy_u_w((v4i32) dst0, 0);

  1244.             out1 = __msa_copy_u_w((v4i32) dst1, 0);

  1245.             SW(out0, dst);

  1246.             dst += dst_stride;

  1247.             SW(out1, dst);

  1248.             dst += dst_stride;

  1249.         }

  1250.     }

  1251. }

  1252. 

  1253. static void avg_width8_msa(const uint8_t *src, int32_t src_stride,

  1254.                            uint8_t *dst, int32_t dst_stride,

  1255.                            int32_t height)

  1256. {

  1257.     int32_t cnt;

  1258.     uint64_t out0, out1, out2, out3;

  1259.     v16u8 src0, src1, src2, src3;

  1260.     v16u8 dst0, dst1, dst2, dst3;

  1261. 

  1262.     for (cnt = (height / 4); cnt--;) {

  1263.         LD_UB4(src, src_stride, src0, src1, src2, src3);

  1264.         src += (4 * src_stride);

  1265.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);

  1266. 

  1267.         AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,

  1268.                     dst0, dst1, dst2, dst3);

  1269. 

  1270.         out0 = __msa_copy_u_d((v2i64) dst0, 0);

  1271.         out1 = __msa_copy_u_d((v2i64) dst1, 0);

  1272.         out2 = __msa_copy_u_d((v2i64) dst2, 0);

  1273.         out3 = __msa_copy_u_d((v2i64) dst3, 0);

  1274.         SD4(out0, out1, out2, out3, dst, dst_stride);

  1275.         dst += (4 * dst_stride);

  1276.     }

  1277. }

  1278. 

  1279. static void avg_width16_msa(const uint8_t *src, int32_t src_stride,

  1280.                             uint8_t *dst, int32_t dst_stride,

  1281.                             int32_t height)

  1282. {

  1283.     int32_t cnt;

  1284.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;

  1285.     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;

  1286. 

  1287.     for (cnt = (height / 8); cnt--;) {

  1288.         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);

  1289.         src += (8 * src_stride);

  1290.         LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);

  1291. 

  1292.         AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,

  1293.                     dst0, dst1, dst2, dst3);

  1294.         AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,

  1295.                     dst4, dst5, dst6, dst7);

  1296.         ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, dst_stride);

  1297.         dst += (8 * dst_stride);

  1298.     }

  1299. }

  1300. 

  1301. void ff_put_pixels16_msa(uint8_t *block, const uint8_t *pixels,

  1302.                          ptrdiff_t line_size, int h)

  1303. {

  1304.     copy_width16_msa(pixels, line_size, block, line_size, h);

  1305. }

  1306. 

  1307. void ff_put_pixels16_x2_msa(uint8_t *block, const uint8_t *pixels,

  1308.                             ptrdiff_t line_size, int h)

  1309. {

  1310.     common_hz_bil_16w_msa(pixels, line_size, block, line_size, h);

  1311. }

  1312. 

  1313. void ff_put_pixels16_y2_msa(uint8_t *block, const uint8_t *pixels,

  1314.                             ptrdiff_t line_size, int h)

  1315. {

  1316.     common_vt_bil_16w_msa(pixels, line_size, block, line_size, h);

  1317. }

  1318. 

  1319. void ff_put_pixels16_xy2_msa(uint8_t *block, const uint8_t *pixels,

  1320.                              ptrdiff_t line_size, int h)

  1321. {

  1322.     common_hv_bil_16w_msa(pixels, line_size, block, line_size, h);

  1323. }

  1324. 

  1325. void ff_put_pixels8_msa(uint8_t *block, const uint8_t *pixels,

  1326.                         ptrdiff_t line_size, int h)

  1327. {

  1328.     copy_width8_msa(pixels, line_size, block, line_size, h);

  1329. }

  1330. 

  1331. void ff_put_pixels8_x2_msa(uint8_t *block, const uint8_t *pixels,

  1332.                            ptrdiff_t line_size, int h)

  1333. {

  1334.     common_hz_bil_8w_msa(pixels, line_size, block, line_size, h);

  1335. }

  1336. 

  1337. void ff_put_pixels8_y2_msa(uint8_t *block, const uint8_t *pixels,

  1338.                            ptrdiff_t line_size, int h)

  1339. {

  1340.     common_vt_bil_8w_msa(pixels, line_size, block, line_size, h);

  1341. }

  1342. 

  1343. void ff_put_pixels8_xy2_msa(uint8_t *block, const uint8_t *pixels,

  1344.                             ptrdiff_t line_size, int h)

  1345. {

  1346.     common_hv_bil_8w_msa(pixels, line_size, block, line_size, h);

  1347. }

  1348. 

  1349. void ff_put_pixels4_x2_msa(uint8_t *block, const uint8_t *pixels,

  1350.                            ptrdiff_t line_size, int h)

  1351. {

  1352.     common_hz_bil_4w_msa(pixels, line_size, block, line_size, h);

  1353. }

  1354. 

  1355. void ff_put_pixels4_y2_msa(uint8_t *block, const uint8_t *pixels,

  1356.                            ptrdiff_t line_size, int h)

  1357. {

  1358.     common_vt_bil_4w_msa(pixels, line_size, block, line_size, h);

  1359. }

  1360. 

  1361. void ff_put_pixels4_xy2_msa(uint8_t *block, const uint8_t *pixels,

  1362.                             ptrdiff_t line_size, int h)

  1363. {

  1364.     common_hv_bil_4w_msa(pixels, line_size, block, line_size, h);

  1365. }

  1366. 

  1367. void ff_put_no_rnd_pixels16_x2_msa(uint8_t *block, const uint8_t *pixels,

  1368.                                    ptrdiff_t line_size, int h)

  1369. {

  1370.     if (h == 16) {

  1371.         common_hz_bil_no_rnd_16x16_msa(pixels, line_size, block, line_size);

  1372.     } else if (h == 8) {

  1373.         common_hz_bil_no_rnd_8x16_msa(pixels, line_size, block, line_size);

  1374.     }

  1375. }

  1376. 

  1377. void ff_put_no_rnd_pixels16_y2_msa(uint8_t *block, const uint8_t *pixels,

  1378.                                    ptrdiff_t line_size, int h)

  1379. {

  1380.     if (h == 16) {

  1381.         common_vt_bil_no_rnd_16x16_msa(pixels, line_size, block, line_size);

  1382.     } else if (h == 8) {

  1383.         common_vt_bil_no_rnd_8x16_msa(pixels, line_size, block, line_size);

  1384.     }

  1385. }

  1386. 

  1387. void ff_put_no_rnd_pixels16_xy2_msa(uint8_t *block,

  1388.                                     const uint8_t *pixels,

  1389.                                     ptrdiff_t line_size, int h)

  1390. {

  1391.     if (h == 16) {

  1392.         common_hv_bil_no_rnd_16x16_msa(pixels, line_size, block, line_size);

  1393.     } else if (h == 8) {

  1394.         common_hv_bil_no_rnd_8x16_msa(pixels, line_size, block, line_size);

  1395.     }

  1396. }

  1397. 

  1398. void ff_put_no_rnd_pixels8_x2_msa(uint8_t *block, const uint8_t *pixels,

  1399.                                   ptrdiff_t line_size, int h)

  1400. {

  1401.     if (h == 8) {

  1402.         common_hz_bil_no_rnd_8x8_msa(pixels, line_size, block, line_size);

  1403.     } else if (h == 4) {

  1404.         common_hz_bil_no_rnd_4x8_msa(pixels, line_size, block, line_size);

  1405.     }

  1406. }

  1407. 

  1408. void ff_put_no_rnd_pixels8_y2_msa(uint8_t *block, const uint8_t *pixels,

  1409.                                   ptrdiff_t line_size, int h)

  1410. {

  1411.     if (h == 8) {

  1412.         common_vt_bil_no_rnd_8x8_msa(pixels, line_size, block, line_size);

  1413.     } else if (h == 4) {

  1414.         common_vt_bil_no_rnd_4x8_msa(pixels, line_size, block, line_size);

  1415.     }

  1416. }

  1417. 

  1418. void ff_put_no_rnd_pixels8_xy2_msa(uint8_t *block, const uint8_t *pixels,

  1419.                                    ptrdiff_t line_size, int h)

  1420. {

  1421.     if (h == 8) {

  1422.         common_hv_bil_no_rnd_8x8_msa(pixels, line_size, block, line_size);

  1423.     } else if (h == 4) {

  1424.         common_hv_bil_no_rnd_4x8_msa(pixels, line_size, block, line_size);

  1425.     }

  1426. }

  1427. 

  1428. void ff_avg_pixels16_msa(uint8_t *block, const uint8_t *pixels,

  1429.                          ptrdiff_t line_size, int h)

  1430. {

  1431.     avg_width16_msa(pixels, line_size, block, line_size, h);

  1432. }

  1433. 

  1434. void ff_avg_pixels16_x2_msa(uint8_t *block, const uint8_t *pixels,

  1435.                             ptrdiff_t line_size, int h)

  1436. {

  1437.     common_hz_bil_and_aver_dst_16w_msa(pixels, line_size, block, line_size, h);

  1438. }

  1439. 

  1440. void ff_avg_pixels16_y2_msa(uint8_t *block, const uint8_t *pixels,

  1441.                             ptrdiff_t line_size, int h)

  1442. {

  1443.     common_vt_bil_and_aver_dst_16w_msa(pixels, line_size, block, line_size, h);

  1444. }

  1445. 

  1446. void ff_avg_pixels16_xy2_msa(uint8_t *block, const uint8_t *pixels,

  1447.                              ptrdiff_t line_size, int h)

  1448. {

  1449.     common_hv_bil_and_aver_dst_16w_msa(pixels, line_size, block, line_size, h);

  1450. }

  1451. 

  1452. void ff_avg_pixels8_msa(uint8_t *block, const uint8_t *pixels,

  1453.                         ptrdiff_t line_size, int h)

  1454. {

  1455.     avg_width8_msa(pixels, line_size, block, line_size, h);

  1456. }

  1457. 

  1458. void ff_avg_pixels8_x2_msa(uint8_t *block, const uint8_t *pixels,

  1459.                            ptrdiff_t line_size, int h)

  1460. {

  1461.     common_hz_bil_and_aver_dst_8w_msa(pixels, line_size, block, line_size, h);

  1462. }

  1463. 

  1464. void ff_avg_pixels8_y2_msa(uint8_t *block, const uint8_t *pixels,

  1465.                            ptrdiff_t line_size, int h)

  1466. {

  1467.     common_vt_bil_and_aver_dst_8w_msa(pixels, line_size, block, line_size, h);

  1468. }

  1469. 

  1470. void ff_avg_pixels8_xy2_msa(uint8_t *block, const uint8_t *pixels,

  1471.                             ptrdiff_t line_size, int h)

  1472. {

  1473.     common_hv_bil_and_aver_dst_8w_msa(pixels, line_size, block, line_size, h);

  1474. }

  1475. 

  1476. void ff_avg_pixels4_msa(uint8_t *block, const uint8_t *pixels,

  1477.                         ptrdiff_t line_size, int h)

  1478. {

  1479.     avg_width4_msa(pixels, line_size, block, line_size, h);

  1480. }

  1481. 

  1482. void ff_avg_pixels4_x2_msa(uint8_t *block, const uint8_t *pixels,

  1483.                            ptrdiff_t line_size, int h)

  1484. {

  1485.     common_hz_bil_and_aver_dst_4w_msa(pixels, line_size, block, line_size, h);

  1486. }

  1487. 

  1488. void ff_avg_pixels4_y2_msa(uint8_t *block, const uint8_t *pixels,

  1489.                            ptrdiff_t line_size, int h)

  1490. {

  1491.     common_vt_bil_and_aver_dst_4w_msa(pixels, line_size, block, line_size, h);

  1492. }

  1493. 

  1494. void ff_avg_pixels4_xy2_msa(uint8_t *block, const uint8_t *pixels,

  1495.                             ptrdiff_t line_size, int h)

  1496. {

  1497.     common_hv_bil_and_aver_dst_4w_msa(pixels, line_size, block, line_size, h);

  1498. }