Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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. }
  1499.