Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2015 Manojkumar Bhosale (Manojkumar.Bhosale@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/hevcdsp_mips.h"
  23. #include "libavcodec/mips/hevc_macros_msa.h"
  24.  
  25. #define HEVC_HV_UNIW_RND_CLIP4(in0, in1, in2, in3, wgt, offset, rnd,       \
  26.                                out0, out1, out2, out3)                     \
  27. {                                                                          \
  28.     MUL4(in0, wgt, in1, wgt, in2, wgt, in3, wgt, out0, out1, out2, out3);  \
  29.     SRAR_W4_SW(out0, out1, out2, out3, rnd);                               \
  30.     ADD4(out0, offset, out1, offset, out2, offset, out3, offset,           \
  31.          out0, out1, out2, out3);                                          \
  32.     out0 = CLIP_SW_0_255(out0);                                            \
  33.     out1 = CLIP_SW_0_255(out1);                                            \
  34.     out2 = CLIP_SW_0_255(out2);                                            \
  35.     out3 = CLIP_SW_0_255(out3);                                            \
  36. }
  37.  
  38. #define HEVC_UNIW_RND_CLIP2(in0, in1, wgt, offset, rnd,              \
  39.                             out0_r, out1_r, out0_l, out1_l)          \
  40. {                                                                    \
  41.     ILVR_H2_SW(in0, in0, in1, in1, out0_r, out1_r);                  \
  42.     ILVL_H2_SW(in0, in0, in1, in1, out0_l, out1_l);                  \
  43.     DOTP_SH4_SW(out0_r, out1_r, out0_l, out1_l, wgt, wgt, wgt, wgt,  \
  44.                 out0_r, out1_r, out0_l, out1_l);                     \
  45.     SRAR_W4_SW(out0_r, out1_r, out0_l, out1_l, rnd);                 \
  46.     ADD4(out0_r, offset, out1_r, offset,                             \
  47.          out0_l, offset, out1_l, offset,                             \
  48.          out0_r, out1_r, out0_l, out1_l);                            \
  49.     out0_r = CLIP_SW_0_255(out0_r);                                  \
  50.     out1_r = CLIP_SW_0_255(out1_r);                                  \
  51.     out0_l = CLIP_SW_0_255(out0_l);                                  \
  52.     out1_l = CLIP_SW_0_255(out1_l);                                  \
  53. }
  54.  
  55. #define HEVC_UNIW_RND_CLIP4(in0, in1, in2, in3, wgt, offset, rnd,  \
  56.                             out0_r, out1_r, out2_r, out3_r,        \
  57.                             out0_l, out1_l, out2_l, out3_l)        \
  58. {                                                                  \
  59.     HEVC_UNIW_RND_CLIP2(in0, in1, wgt, offset, rnd,                \
  60.                         out0_r, out1_r, out0_l, out1_l);           \
  61.     HEVC_UNIW_RND_CLIP2(in2, in3, wgt, offset, rnd,                \
  62.                         out2_r, out3_r, out2_l, out3_l);           \
  63. }
  64.  
  65. static void hevc_uniwgt_copy_4w_msa(uint8_t *src,
  66.                                     int32_t src_stride,
  67.                                     uint8_t *dst,
  68.                                     int32_t dst_stride,
  69.                                     int32_t height,
  70.                                     int32_t weight,
  71.                                     int32_t offset,
  72.                                     int32_t rnd_val)
  73. {
  74.     v16i8 zero = { 0 };
  75.     v4i32 weight_vec, offset_vec, rnd_vec;
  76.  
  77.     weight = weight & 0x0000FFFF;
  78.     weight_vec = __msa_fill_w(weight);
  79.     offset_vec = __msa_fill_w(offset);
  80.     rnd_vec = __msa_fill_w(rnd_val);
  81.  
  82.     if (2 == height) {
  83.         v16i8 src0, src1;
  84.         v8i16 dst0;
  85.         v4i32 dst0_r, dst0_l;
  86.  
  87.         LD_SB2(src, src_stride, src0, src1);
  88.         src0 = (v16i8) __msa_ilvr_w((v4i32) src1, (v4i32) src0);
  89.         dst0 = (v8i16) __msa_ilvr_b(zero, src0);
  90.         dst0 <<= 6;
  91.  
  92.         ILVRL_H2_SW(dst0, dst0, dst0_r, dst0_l);
  93.         DOTP_SH2_SW(dst0_r, dst0_l, weight_vec, weight_vec, dst0_r, dst0_l);
  94.         SRAR_W2_SW(dst0_r, dst0_l, rnd_vec);
  95.         ADD2(dst0_r, offset_vec, dst0_l, offset_vec, dst0_r, dst0_l);
  96.         dst0_r = CLIP_SW_0_255(dst0_r);
  97.         dst0_l = CLIP_SW_0_255(dst0_l);
  98.  
  99.         HEVC_PCK_SW_SB2(dst0_l, dst0_r, dst0_r);
  100.         ST4x2_UB(dst0_r, dst, dst_stride);
  101.     } else if (4 == height) {
  102.         v16i8 src0, src1, src2, src3;
  103.         v8i16 dst0, dst1;
  104.         v4i32 dst0_r, dst1_r;
  105.         v4i32 dst0_l, dst1_l;
  106.  
  107.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  108.         ILVR_W2_SB(src1, src0, src3, src2, src0, src1);
  109.         ILVR_B2_SH(zero, src0, zero, src1, dst0, dst1);
  110.         dst0 <<= 6;
  111.         dst1 <<= 6;
  112.  
  113.         HEVC_UNIW_RND_CLIP2(dst0, dst1, weight_vec, offset_vec, rnd_vec,
  114.                             dst0_r, dst1_r, dst0_l, dst1_l);
  115.  
  116.         HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  117.         ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
  118.     } else if (0 == height % 8) {
  119.         uint32_t loop_cnt;
  120.         v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  121.         v8i16 dst0, dst1, dst2, dst3;
  122.         v4i32 dst0_r, dst1_r, dst2_r, dst3_r;
  123.         v4i32 dst0_l, dst1_l, dst2_l, dst3_l;
  124.  
  125.         for (loop_cnt = (height >> 3); loop_cnt--;) {
  126.             LD_SB8(src, src_stride,
  127.                    src0, src1, src2, src3, src4, src5, src6, src7);
  128.             src += (8 * src_stride);
  129.             ILVR_W4_SB(src1, src0, src3, src2, src5, src4, src7, src6,
  130.                        src0, src1, src2, src3);
  131.             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  132.                        dst0, dst1, dst2, dst3);
  133.  
  134.             SLLI_4V(dst0, dst1, dst2, dst3, 6);
  135.             HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  136.                                 weight_vec, offset_vec, rnd_vec,
  137.                                 dst0_r, dst1_r, dst2_r, dst3_r,
  138.                                 dst0_l, dst1_l, dst2_l, dst3_l);
  139.  
  140.             HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  141.                             dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  142.             ST4x8_UB(dst0_r, dst1_r, dst, dst_stride);
  143.             dst += (8 * dst_stride);
  144.         }
  145.     }
  146. }
  147.  
  148. static void hevc_uniwgt_copy_6w_msa(uint8_t *src,
  149.                                     int32_t src_stride,
  150.                                     uint8_t *dst,
  151.                                     int32_t dst_stride,
  152.                                     int32_t height,
  153.                                     int32_t weight,
  154.                                     int32_t offset,
  155.                                     int32_t rnd_val)
  156. {
  157.     uint32_t loop_cnt;
  158.     v16i8 zero = { 0 };
  159.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  160.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
  161.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r;
  162.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l;
  163.     v4i32 weight_vec, offset_vec, rnd_vec;
  164.  
  165.     weight = weight & 0x0000FFFF;
  166.     weight_vec = __msa_fill_w(weight);
  167.     offset_vec = __msa_fill_w(offset);
  168.     rnd_vec = __msa_fill_w(rnd_val);
  169.  
  170.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  171.         LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  172.         src += (8 * src_stride);
  173.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  174.                    dst0, dst1, dst2, dst3);
  175.         ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
  176.                    dst4, dst5, dst6, dst7);
  177.  
  178.         SLLI_4V(dst0, dst1, dst2, dst3, 6);
  179.         SLLI_4V(dst4, dst5, dst6, dst7, 6);
  180.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  181.                             weight_vec, offset_vec, rnd_vec,
  182.                             dst0_r, dst1_r, dst2_r, dst3_r,
  183.                             dst0_l, dst1_l, dst2_l, dst3_l);
  184.  
  185.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  186.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  187.         ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
  188.         dst += (4 * dst_stride);
  189.  
  190.         HEVC_UNIW_RND_CLIP4(dst4, dst5, dst6, dst7,
  191.                             weight_vec, offset_vec, rnd_vec,
  192.                             dst0_r, dst1_r, dst2_r, dst3_r,
  193.                             dst0_l, dst1_l, dst2_l, dst3_l);
  194.  
  195.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  196.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  197.         ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
  198.         dst += (4 * dst_stride);
  199.     }
  200. }
  201.  
  202. static void hevc_uniwgt_copy_8w_msa(uint8_t *src,
  203.                                     int32_t src_stride,
  204.                                     uint8_t *dst,
  205.                                     int32_t dst_stride,
  206.                                     int32_t height,
  207.                                     int32_t weight,
  208.                                     int32_t offset,
  209.                                     int32_t rnd_val)
  210. {
  211.     v16i8 zero = { 0 };
  212.     v4i32 weight_vec, offset_vec, rnd_vec;
  213.  
  214.     weight = weight & 0x0000FFFF;
  215.     weight_vec = __msa_fill_w(weight);
  216.     offset_vec = __msa_fill_w(offset);
  217.     rnd_vec = __msa_fill_w(rnd_val);
  218.  
  219.     if (2 == height) {
  220.         v16i8 src0, src1;
  221.         v8i16 dst0, dst1;
  222.         v4i32 dst0_r, dst1_r, dst0_l, dst1_l;
  223.  
  224.         LD_SB2(src, src_stride, src0, src1);
  225.         ILVR_B2_SH(zero, src0, zero, src1, dst0, dst1);
  226.  
  227.         dst0 <<= 6;
  228.         dst1 <<= 6;
  229.         HEVC_UNIW_RND_CLIP2(dst0, dst1, weight_vec, offset_vec, rnd_vec,
  230.                             dst0_r, dst1_r, dst0_l, dst1_l);
  231.  
  232.         HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  233.         ST8x2_UB(dst0_r, dst, dst_stride);
  234.     } else if (6 == height) {
  235.         v16i8 src0, src1, src2, src3, src4, src5;
  236.         v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  237.         v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  238.         v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  239.  
  240.         LD_SB6(src, src_stride, src0, src1, src2, src3, src4, src5);
  241.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  242.                    dst0, dst1, dst2, dst3);
  243.         ILVR_B2_SH(zero, src4, zero, src5, dst4, dst5);
  244.  
  245.         SLLI_4V(dst0, dst1, dst2, dst3, 6);
  246.         dst4 <<= 6;
  247.         dst5 <<= 6;
  248.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  249.                             weight_vec, offset_vec, rnd_vec,
  250.                             dst0_r, dst1_r, dst2_r, dst3_r,
  251.                             dst0_l, dst1_l, dst2_l, dst3_l);
  252.         HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
  253.                             dst4_r, dst5_r, dst4_l, dst5_l);
  254.  
  255.         HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  256.                          dst2_l, dst2_r, dst3_l, dst3_r,
  257.                          dst4_l, dst4_r, dst5_l, dst5_r,
  258.                          dst0_r, dst1_r, dst2_r);
  259.         ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  260.         dst += (4 * dst_stride);
  261.         ST8x2_UB(dst2_r, dst, dst_stride);
  262.     } else if (0 == height % 4) {
  263.         uint32_t loop_cnt;
  264.         v16i8 src0, src1, src2, src3;
  265.         v8i16 dst0, dst1, dst2, dst3;
  266.         v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  267.  
  268.         for (loop_cnt = (height >> 2); loop_cnt--;) {
  269.             LD_SB4(src, src_stride, src0, src1, src2, src3);
  270.             src += (4 * src_stride);
  271.             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  272.                        dst0, dst1, dst2, dst3);
  273.  
  274.             SLLI_4V(dst0, dst1, dst2, dst3, 6);
  275.             HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  276.                                 weight_vec, offset_vec, rnd_vec,
  277.                                 dst0_r, dst1_r, dst2_r, dst3_r,
  278.                                 dst0_l, dst1_l, dst2_l, dst3_l);
  279.  
  280.             HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  281.                             dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  282.             ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  283.             dst += (4 * dst_stride);
  284.         }
  285.     }
  286. }
  287.  
  288. static void hevc_uniwgt_copy_12w_msa(uint8_t *src,
  289.                                      int32_t src_stride,
  290.                                      uint8_t *dst,
  291.                                      int32_t dst_stride,
  292.                                      int32_t height,
  293.                                      int32_t weight,
  294.                                      int32_t offset,
  295.                                      int32_t rnd_val)
  296. {
  297.     uint32_t loop_cnt;
  298.     v16i8 src0, src1, src2, src3;
  299.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  300.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  301.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  302.     v16i8 zero = { 0 };
  303.     v4i32 weight_vec, offset_vec, rnd_vec;
  304.  
  305.     weight = weight & 0x0000FFFF;
  306.     weight_vec = __msa_fill_w(weight);
  307.     offset_vec = __msa_fill_w(offset);
  308.     rnd_vec = __msa_fill_w(rnd_val);
  309.  
  310.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  311.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  312.         src += (4 * src_stride);
  313.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  314.                    dst0, dst1, dst2, dst3);
  315.  
  316.         SLLI_4V(dst0, dst1, dst2, dst3, 6);
  317.         ILVL_W2_SB(src1, src0, src3, src2, src0, src1);
  318.         ILVR_B2_SH(zero, src0, zero, src1, dst4, dst5);
  319.         dst4 <<= 6;
  320.         dst5 <<= 6;
  321.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  322.                             weight_vec, offset_vec, rnd_vec,
  323.                             dst0_r, dst1_r, dst2_r, dst3_r,
  324.                             dst0_l, dst1_l, dst2_l, dst3_l);
  325.         HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
  326.                             dst4_r, dst5_r, dst4_l, dst5_l);
  327.  
  328.         HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  329.                          dst2_l, dst2_r, dst3_l, dst3_r,
  330.                          dst4_l, dst4_r, dst5_l, dst5_r,
  331.                          dst0_r, dst1_r, dst2_r);
  332.         ST12x4_UB(dst0_r, dst1_r, dst2_r, dst, dst_stride);
  333.         dst += (4 * dst_stride);
  334.     }
  335. }
  336.  
  337. static void hevc_uniwgt_copy_16multx4mult_msa(uint8_t *src,
  338.                                               int32_t src_stride,
  339.                                               uint8_t *dst,
  340.                                               int32_t dst_stride,
  341.                                               int32_t height,
  342.                                               int32_t weight,
  343.                                               int32_t offset,
  344.                                               int32_t rnd_val,
  345.                                               int32_t width)
  346. {
  347.     uint32_t loop_cnt, cnt;
  348.     uint8_t *src_tmp;
  349.     uint8_t *dst_tmp;
  350.     v16i8 src0, src1, src2, src3;
  351.     v8i16 tmp0, tmp1, tmp2, tmp3;
  352.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  353.     v16i8 zero = { 0 };
  354.     v4i32 weight_vec, offset_vec, rnd_vec;
  355.  
  356.     weight = weight & 0x0000FFFF;
  357.     weight_vec = __msa_fill_w(weight);
  358.     offset_vec = __msa_fill_w(offset);
  359.     rnd_vec = __msa_fill_w(rnd_val);
  360.  
  361.     for (cnt = width >> 4; cnt--;) {
  362.         src_tmp = src;
  363.         dst_tmp = dst;
  364.  
  365.         for (loop_cnt = height >> 2; loop_cnt--;) {
  366.             LD_SB4(src_tmp, src_stride, src0, src1, src2, src3);
  367.             src_tmp += (4 * src_stride);
  368.             ILVR_B2_SH(zero, src0, zero, src1, tmp0, tmp1);
  369.             ILVL_B2_SH(zero, src0, zero, src1, tmp2, tmp3);
  370.  
  371.             SLLI_4V(tmp0, tmp1, tmp2, tmp3, 6);
  372.             HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  373.                                 weight_vec, offset_vec, rnd_vec,
  374.                                 dst0_r, dst1_r, dst2_r, dst3_r,
  375.                                 dst0_l, dst1_l, dst2_l, dst3_l);
  376.  
  377.             HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
  378.                             dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
  379.  
  380.             ST_SW2(dst0_r, dst1_r, dst_tmp, dst_stride);
  381.             dst_tmp += (2 * dst_stride);
  382.  
  383.             ILVR_B2_SH(zero, src2, zero, src3, tmp0, tmp1);
  384.             ILVL_B2_SH(zero, src2, zero, src3, tmp2, tmp3);
  385.  
  386.             SLLI_4V(tmp0, tmp1, tmp2, tmp3, 6);
  387.             HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  388.                                 weight_vec, offset_vec, rnd_vec,
  389.                                 dst0_r, dst1_r, dst2_r, dst3_r,
  390.                                 dst0_l, dst1_l, dst2_l, dst3_l);
  391.  
  392.             HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
  393.                             dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
  394.  
  395.             ST_SW2(dst0_r, dst1_r, dst_tmp, dst_stride);
  396.             dst_tmp += (2 * dst_stride);
  397.         }
  398.  
  399.         src += 16;
  400.         dst += 16;
  401.     }
  402. }
  403.  
  404. static void hevc_uniwgt_copy_16w_msa(uint8_t *src,
  405.                                      int32_t src_stride,
  406.                                      uint8_t *dst,
  407.                                      int32_t dst_stride,
  408.                                      int32_t height,
  409.                                      int32_t weight,
  410.                                      int32_t offset,
  411.                                      int32_t rnd_val)
  412. {
  413.     hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
  414.                                       height, weight, offset, rnd_val, 16);
  415. }
  416.  
  417. static void hevc_uniwgt_copy_24w_msa(uint8_t *src,
  418.                                      int32_t src_stride,
  419.                                      uint8_t *dst,
  420.                                      int32_t dst_stride,
  421.                                      int32_t height,
  422.                                      int32_t weight,
  423.                                      int32_t offset,
  424.                                      int32_t rnd_val)
  425. {
  426.     hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
  427.                                       height, weight, offset, rnd_val, 16);
  428.  
  429.     hevc_uniwgt_copy_8w_msa(src + 16, src_stride, dst + 16, dst_stride,
  430.                             height, weight, offset, rnd_val);
  431. }
  432.  
  433. static void hevc_uniwgt_copy_32w_msa(uint8_t *src,
  434.                                      int32_t src_stride,
  435.                                      uint8_t *dst,
  436.                                      int32_t dst_stride,
  437.                                      int32_t height,
  438.                                      int32_t weight,
  439.                                      int32_t offset,
  440.                                      int32_t rnd_val)
  441. {
  442.     hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
  443.                                       height, weight, offset, rnd_val, 32);
  444. }
  445.  
  446. static void hevc_uniwgt_copy_48w_msa(uint8_t *src,
  447.                                      int32_t src_stride,
  448.                                      uint8_t *dst,
  449.                                      int32_t dst_stride,
  450.                                      int32_t height,
  451.                                      int32_t weight,
  452.                                      int32_t offset,
  453.                                      int32_t rnd_val)
  454. {
  455.     hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
  456.                                       height, weight, offset, rnd_val, 48);
  457. }
  458.  
  459. static void hevc_uniwgt_copy_64w_msa(uint8_t *src,
  460.                                      int32_t src_stride,
  461.                                      uint8_t *dst,
  462.                                      int32_t dst_stride,
  463.                                      int32_t height,
  464.                                      int32_t weight,
  465.                                      int32_t offset,
  466.                                      int32_t rnd_val)
  467. {
  468.     hevc_uniwgt_copy_16multx4mult_msa(src, src_stride, dst, dst_stride,
  469.                                       height, weight, offset, rnd_val, 64);
  470. }
  471.  
  472. static void hevc_hz_uniwgt_8t_4w_msa(uint8_t *src,
  473.                                      int32_t src_stride,
  474.                                      uint8_t *dst,
  475.                                      int32_t dst_stride,
  476.                                      const int8_t *filter,
  477.                                      int32_t height,
  478.                                      int32_t weight,
  479.                                      int32_t offset,
  480.                                      int32_t rnd_val)
  481. {
  482.     uint32_t loop_cnt;
  483.     v8i16 filt0, filt1, filt2, filt3;
  484.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  485.     v16i8 mask1, mask2, mask3;
  486.     v8i16 filter_vec, const_vec;
  487.     v16i8 vec0, vec1, vec2, vec3;
  488.     v8i16 dst0, dst1, dst2, dst3;
  489.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  490.     v4i32 weight_vec, offset_vec, rnd_vec;
  491.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  492.  
  493.     src -= 3;
  494.     weight = weight & 0x0000FFFF;
  495.     const_vec = __msa_ldi_h(128);
  496.     const_vec <<= 6;
  497.  
  498.     weight_vec = __msa_fill_w(weight);
  499.     offset_vec = __msa_fill_w(offset);
  500.     rnd_vec = __msa_fill_w(rnd_val);
  501.  
  502.     filter_vec = LD_SH(filter);
  503.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  504.  
  505.     mask1 = mask0 + 2;
  506.     mask2 = mask0 + 4;
  507.     mask3 = mask0 + 6;
  508.  
  509.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  510.         LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  511.         src += (8 * src_stride);
  512.         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
  513.  
  514.         VSHF_B4_SB(src0, src1, mask0, mask1, mask2, mask3,
  515.                    vec0, vec1, vec2, vec3);
  516.  
  517.         dst0 = const_vec;
  518.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  519.                      dst0, dst0, dst0, dst0);
  520.         VSHF_B4_SB(src2, src3, mask0, mask1, mask2, mask3,
  521.                    vec0, vec1, vec2, vec3);
  522.         dst1 = const_vec;
  523.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  524.                      dst1, dst1, dst1, dst1);
  525.         VSHF_B4_SB(src4, src5, mask0, mask1, mask2, mask3,
  526.                    vec0, vec1, vec2, vec3);
  527.         dst2 = const_vec;
  528.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  529.                      dst2, dst2, dst2, dst2);
  530.         VSHF_B4_SB(src6, src7, mask0, mask1, mask2, mask3,
  531.                    vec0, vec1, vec2, vec3);
  532.         dst3 = const_vec;
  533.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  534.                      dst3, dst3, dst3, dst3);
  535.  
  536.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  537.                             weight_vec, offset_vec, rnd_vec,
  538.                             dst0_r, dst1_r, dst2_r, dst3_r,
  539.                             dst0_l, dst1_l, dst2_l, dst3_l);
  540.  
  541.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  542.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  543.         ST4x8_UB(dst0_r, dst1_r, dst, dst_stride);
  544.         dst += (8 * dst_stride);
  545.     }
  546. }
  547.  
  548. static void hevc_hz_uniwgt_8t_8w_msa(uint8_t *src,
  549.                                      int32_t src_stride,
  550.                                      uint8_t *dst,
  551.                                      int32_t dst_stride,
  552.                                      const int8_t *filter,
  553.                                      int32_t height,
  554.                                      int32_t weight,
  555.                                      int32_t offset,
  556.                                      int32_t rnd_val)
  557. {
  558.     uint32_t loop_cnt;
  559.     v16i8 src0, src1, src2, src3;
  560.     v8i16 filt0, filt1, filt2, filt3;
  561.     v16i8 mask1, mask2, mask3;
  562.     v8i16 filter_vec, const_vec;
  563.     v16i8 vec0, vec1, vec2, vec3;
  564.     v8i16 dst0, dst1, dst2, dst3;
  565.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  566.     v4i32 weight_vec, offset_vec, rnd_vec;
  567.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  568.  
  569.     src -= 3;
  570.     weight = weight & 0x0000FFFF;
  571.     const_vec = __msa_ldi_h(128);
  572.     const_vec <<= 6;
  573.  
  574.     weight_vec = __msa_fill_w(weight);
  575.     offset_vec = __msa_fill_w(offset);
  576.     rnd_vec = __msa_fill_w(rnd_val);
  577.  
  578.     filter_vec = LD_SH(filter);
  579.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  580.  
  581.     mask1 = mask0 + 2;
  582.     mask2 = mask0 + 4;
  583.     mask3 = mask0 + 6;
  584.  
  585.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  586.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  587.         src += (4 * src_stride);
  588.         XORI_B4_128_SB(src0, src1, src2, src3);
  589.  
  590.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  591.                    vec0, vec1, vec2, vec3);
  592.         dst0 = const_vec;
  593.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  594.                      dst0, dst0, dst0, dst0);
  595.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  596.                    vec0, vec1, vec2, vec3);
  597.         dst1 = const_vec;
  598.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  599.                      dst1, dst1, dst1, dst1);
  600.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  601.                    vec0, vec1, vec2, vec3);
  602.         dst2 = const_vec;
  603.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  604.                      dst2, dst2, dst2, dst2);
  605.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  606.                    vec0, vec1, vec2, vec3);
  607.         dst3 = const_vec;
  608.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  609.                      dst3, dst3, dst3, dst3);
  610.  
  611.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  612.                             weight_vec, offset_vec, rnd_vec,
  613.                             dst0_r, dst1_r, dst2_r, dst3_r,
  614.                             dst0_l, dst1_l, dst2_l, dst3_l);
  615.  
  616.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  617.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  618.         ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  619.         dst += (4 * dst_stride);
  620.     }
  621. }
  622.  
  623. static void hevc_hz_uniwgt_8t_12w_msa(uint8_t *src,
  624.                                       int32_t src_stride,
  625.                                       uint8_t *dst,
  626.                                       int32_t dst_stride,
  627.                                       const int8_t *filter,
  628.                                       int32_t height,
  629.                                       int32_t weight,
  630.                                       int32_t offset,
  631.                                       int32_t rnd_val)
  632. {
  633.     hevc_hz_uniwgt_8t_8w_msa(src, src_stride, dst, dst_stride,
  634.                              filter, height, weight, offset, rnd_val);
  635.     hevc_hz_uniwgt_8t_4w_msa(src + 8, src_stride, dst + 8, dst_stride,
  636.                              filter, height, weight, offset, rnd_val);
  637. }
  638.  
  639. static void hevc_hz_uniwgt_8t_16w_msa(uint8_t *src,
  640.                                       int32_t src_stride,
  641.                                       uint8_t *dst,
  642.                                       int32_t dst_stride,
  643.                                       const int8_t *filter,
  644.                                       int32_t height,
  645.                                       int32_t weight,
  646.                                       int32_t offset,
  647.                                       int32_t rnd_val)
  648. {
  649.     uint32_t loop_cnt;
  650.     v16i8 src0, src1, src2, src3;
  651.     v8i16 filt0, filt1, filt2, filt3;
  652.     v16i8 mask1, mask2, mask3;
  653.     v8i16 filter_vec, const_vec;
  654.     v16i8 vec0, vec1, vec2, vec3;
  655.     v8i16 dst0, dst1, dst2, dst3;
  656.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  657.     v4i32 weight_vec, offset_vec, rnd_vec;
  658.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  659.  
  660.     src -= 3;
  661.     const_vec = __msa_ldi_h(128);
  662.     const_vec <<= 6;
  663.  
  664.     weight = weight & 0x0000FFFF;
  665.     weight_vec = __msa_fill_w(weight);
  666.     offset_vec = __msa_fill_w(offset);
  667.     rnd_vec = __msa_fill_w(rnd_val);
  668.  
  669.     filter_vec = LD_SH(filter);
  670.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  671.  
  672.     mask1 = mask0 + 2;
  673.     mask2 = mask0 + 4;
  674.     mask3 = mask0 + 6;
  675.  
  676.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  677.         LD_SB2(src, src_stride, src0, src2);
  678.         LD_SB2(src + 8, src_stride, src1, src3);
  679.         src += (2 * src_stride);
  680.         XORI_B4_128_SB(src0, src1, src2, src3);
  681.  
  682.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  683.                    vec0, vec1, vec2, vec3);
  684.         dst0 = const_vec;
  685.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  686.                      dst0, dst0, dst0, dst0);
  687.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  688.                    vec0, vec1, vec2, vec3);
  689.         dst1 = const_vec;
  690.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  691.                      dst1, dst1, dst1, dst1);
  692.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  693.                    vec0, vec1, vec2, vec3);
  694.         dst2 = const_vec;
  695.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  696.                      dst2, dst2, dst2, dst2);
  697.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  698.                    vec0, vec1, vec2, vec3);
  699.         dst3 = const_vec;
  700.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  701.                      dst3, dst3, dst3, dst3);
  702.  
  703.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  704.                             weight_vec, offset_vec, rnd_vec,
  705.                             dst0_r, dst1_r, dst2_r, dst3_r,
  706.                             dst0_l, dst1_l, dst2_l, dst3_l);
  707.  
  708.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  709.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  710.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  711.         dst += (2 * dst_stride);
  712.     }
  713. }
  714.  
  715. static void hevc_hz_uniwgt_8t_24w_msa(uint8_t *src,
  716.                                       int32_t src_stride,
  717.                                       uint8_t *dst,
  718.                                       int32_t dst_stride,
  719.                                       const int8_t *filter,
  720.                                       int32_t height,
  721.                                       int32_t weight,
  722.                                       int32_t offset,
  723.                                       int32_t rnd_val)
  724. {
  725.     uint32_t loop_cnt;
  726.     v16i8 src0, src1, src2, src3;
  727.     v8i16 filt0, filt1, filt2, filt3;
  728.     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
  729.     v16i8 vec0, vec1, vec2, vec3;
  730.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  731.     v8i16 filter_vec, const_vec;
  732.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  733.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  734.     v4i32 weight_vec, offset_vec, rnd_vec;
  735.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  736.  
  737.     src -= 3;
  738.     const_vec = __msa_ldi_h(128);
  739.     const_vec <<= 6;
  740.  
  741.     weight = weight & 0x0000FFFF;
  742.     weight_vec = __msa_fill_w(weight);
  743.     offset_vec = __msa_fill_w(offset);
  744.     rnd_vec = __msa_fill_w(rnd_val);
  745.  
  746.     filter_vec = LD_SH(filter);
  747.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  748.  
  749.     mask1 = mask0 + 2;
  750.     mask2 = mask0 + 4;
  751.     mask3 = mask0 + 6;
  752.     mask4 = mask0 + 8;
  753.     mask5 = mask0 + 10;
  754.     mask6 = mask0 + 12;
  755.     mask7 = mask0 + 14;
  756.  
  757.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  758.         LD_SB2(src, 16, src0, src1);
  759.         src += src_stride;
  760.         LD_SB2(src, 16, src2, src3);
  761.         src += src_stride;
  762.         XORI_B4_128_SB(src0, src1, src2, src3);
  763.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  764.                    vec0, vec1, vec2, vec3);
  765.  
  766.         dst0 = const_vec;
  767.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  768.                      dst0, dst0, dst0, dst0);
  769.         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
  770.                    vec0, vec1, vec2, vec3);
  771.         dst1 = const_vec;
  772.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  773.                      dst1, dst1, dst1, dst1);
  774.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  775.                    vec0, vec1, vec2, vec3);
  776.         dst2 = const_vec;
  777.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  778.                      dst2, dst2, dst2, dst2);
  779.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  780.                    vec0, vec1, vec2, vec3);
  781.         dst3 = const_vec;
  782.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  783.                      dst3, dst3, dst3, dst3);
  784.         VSHF_B4_SB(src2, src3, mask4, mask5, mask6, mask7,
  785.                    vec0, vec1, vec2, vec3);
  786.         dst4 = const_vec;
  787.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  788.                      dst4, dst4, dst4, dst4);
  789.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  790.                    vec0, vec1, vec2, vec3);
  791.         dst5 = const_vec;
  792.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  793.                      dst5, dst5, dst5, dst5);
  794.  
  795.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  796.                             weight_vec, offset_vec, rnd_vec,
  797.                             dst0_r, dst1_r, dst2_r, dst3_r,
  798.                             dst0_l, dst1_l, dst2_l, dst3_l);
  799.         HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
  800.                             dst4_r, dst5_r, dst4_l, dst5_l);
  801.  
  802.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  803.                         dst3_l, dst3_r, dst4_l, dst4_r, dst0_r, dst1_r);
  804.         HEVC_PCK_SW_SB4(dst2_l, dst2_r, dst5_l, dst5_r, dst2_r);
  805.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  806.         ST8x2_UB(dst2_r, dst + 16, dst_stride);
  807.         dst += (2 * dst_stride);
  808.     }
  809. }
  810.  
  811. static void hevc_hz_uniwgt_8t_32w_msa(uint8_t *src,
  812.                                       int32_t src_stride,
  813.                                       uint8_t *dst,
  814.                                       int32_t dst_stride,
  815.                                       const int8_t *filter,
  816.                                       int32_t height,
  817.                                       int32_t weight,
  818.                                       int32_t offset,
  819.                                       int32_t rnd_val)
  820. {
  821.     uint32_t loop_cnt;
  822.     v16i8 src0, src1, src2;
  823.     v8i16 filt0, filt1, filt2, filt3;
  824.     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
  825.     v16i8 vec0, vec1, vec2, vec3;
  826.     v8i16 dst0, dst1, dst2, dst3;
  827.     v8i16 filter_vec, const_vec;
  828.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  829.     v4i32 weight_vec, offset_vec, rnd_vec;
  830.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  831.  
  832.     src -= 3;
  833.     const_vec = __msa_ldi_h(128);
  834.     const_vec <<= 6;
  835.  
  836.     weight = weight & 0x0000FFFF;
  837.     weight_vec = __msa_fill_w(weight);
  838.     offset_vec = __msa_fill_w(offset);
  839.     rnd_vec = __msa_fill_w(rnd_val);
  840.  
  841.     filter_vec = LD_SH(filter);
  842.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  843.  
  844.     mask1 = mask0 + 2;
  845.     mask2 = mask0 + 4;
  846.     mask3 = mask0 + 6;
  847.     mask4 = mask0 + 8;
  848.     mask5 = mask0 + 10;
  849.     mask6 = mask0 + 12;
  850.     mask7 = mask0 + 14;
  851.  
  852.     for (loop_cnt = height; loop_cnt--;) {
  853.         LD_SB2(src, 16, src0, src1);
  854.         src2 = LD_SB(src + 24);
  855.         src += src_stride;
  856.         XORI_B3_128_SB(src0, src1, src2);
  857.  
  858.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  859.                    vec0, vec1, vec2, vec3);
  860.         dst0 = const_vec;
  861.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  862.                      dst0, dst0, dst0, dst0);
  863.         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
  864.                    vec0, vec1, vec2, vec3);
  865.         dst1 = const_vec;
  866.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  867.                      dst1, dst1, dst1, dst1);
  868.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  869.                    vec0, vec1, vec2, vec3);
  870.         dst2 = const_vec;
  871.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  872.                      dst2, dst2, dst2, dst2);
  873.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  874.                    vec0, vec1, vec2, vec3);
  875.         dst3 = const_vec;
  876.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  877.                      dst3, dst3, dst3, dst3);
  878.  
  879.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  880.                             weight_vec, offset_vec, rnd_vec,
  881.                             dst0_r, dst1_r, dst2_r, dst3_r,
  882.                             dst0_l, dst1_l, dst2_l, dst3_l);
  883.  
  884.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  885.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  886.         ST_SW2(dst0_r, dst1_r, dst, 16);
  887.         dst += dst_stride;
  888.     }
  889. }
  890.  
  891. static void hevc_hz_uniwgt_8t_48w_msa(uint8_t *src,
  892.                                       int32_t src_stride,
  893.                                       uint8_t *dst,
  894.                                       int32_t dst_stride,
  895.                                       const int8_t *filter,
  896.                                       int32_t height,
  897.                                       int32_t weight,
  898.                                       int32_t offset,
  899.                                       int32_t rnd_val)
  900. {
  901.     uint32_t loop_cnt;
  902.     v16i8 src0, src1, src2, src3;
  903.     v8i16 filt0, filt1, filt2, filt3;
  904.     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
  905.     v16i8 vec0, vec1, vec2, vec3;
  906.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  907.     v8i16 filter_vec, const_vec;
  908.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  909.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  910.     v4i32 weight_vec, offset_vec, rnd_vec;
  911.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  912.  
  913.     src -= 3;
  914.     const_vec = __msa_ldi_h(128);
  915.     const_vec <<= 6;
  916.  
  917.     weight = weight & 0x0000FFFF;
  918.     weight_vec = __msa_fill_w(weight);
  919.     offset_vec = __msa_fill_w(offset);
  920.     rnd_vec = __msa_fill_w(rnd_val);
  921.  
  922.     filter_vec = LD_SH(filter);
  923.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  924.  
  925.     mask1 = mask0 + 2;
  926.     mask2 = mask0 + 4;
  927.     mask3 = mask0 + 6;
  928.     mask4 = mask0 + 8;
  929.     mask5 = mask0 + 10;
  930.     mask6 = mask0 + 12;
  931.     mask7 = mask0 + 14;
  932.  
  933.     for (loop_cnt = height; loop_cnt--;) {
  934.         LD_SB3(src, 16, src0, src1, src2);
  935.         src3 = LD_SB(src + 40);
  936.         src += src_stride;
  937.         XORI_B4_128_SB(src0, src1, src2, src3);
  938.  
  939.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  940.                    vec0, vec1, vec2, vec3);
  941.         dst0 = const_vec;
  942.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  943.                      dst0, dst0, dst0, dst0);
  944.         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
  945.                    vec0, vec1, vec2, vec3);
  946.         dst1 = const_vec;
  947.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  948.                      dst1, dst1, dst1, dst1);
  949.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  950.                    vec0, vec1, vec2, vec3);
  951.         dst2 = const_vec;
  952.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  953.                      dst2, dst2, dst2, dst2);
  954.         VSHF_B4_SB(src1, src2, mask4, mask5, mask6, mask7,
  955.                    vec0, vec1, vec2, vec3);
  956.         dst3 = const_vec;
  957.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  958.                      dst3, dst3, dst3, dst3);
  959.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  960.                    vec0, vec1, vec2, vec3);
  961.         dst4 = const_vec;
  962.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  963.                      dst4, dst4, dst4, dst4);
  964.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  965.                    vec0, vec1, vec2, vec3);
  966.         dst5 = const_vec;
  967.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  968.                      dst5, dst5, dst5, dst5);
  969.  
  970.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  971.                             weight_vec, offset_vec, rnd_vec,
  972.                             dst0_r, dst1_r, dst2_r, dst3_r,
  973.                             dst0_l, dst1_l, dst2_l, dst3_l);
  974.  
  975.         HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
  976.                             dst4_r, dst5_r, dst4_l, dst5_l);
  977.  
  978.         HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  979.                          dst2_l, dst2_r, dst3_l, dst3_r,
  980.                          dst4_l, dst4_r, dst5_l, dst5_r,
  981.                          dst0_r, dst1_r, dst2_r);
  982.         ST_SW2(dst0_r, dst1_r, dst, 16);
  983.         ST_SW(dst2_r, dst + 32);
  984.         dst += dst_stride;
  985.     }
  986. }
  987.  
  988. static void hevc_hz_uniwgt_8t_64w_msa(uint8_t *src,
  989.                                       int32_t src_stride,
  990.                                       uint8_t *dst,
  991.                                       int32_t dst_stride,
  992.                                       const int8_t *filter,
  993.                                       int32_t height,
  994.                                       int32_t weight,
  995.                                       int32_t offset,
  996.                                       int32_t rnd_val)
  997. {
  998.     uint8_t *src_tmp;
  999.     uint8_t *dst_tmp;
  1000.     uint32_t loop_cnt, cnt;
  1001.     v16i8 src0, src1, src2;
  1002.     v8i16 filt0, filt1, filt2, filt3;
  1003.     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
  1004.     v16i8 vec0, vec1, vec2, vec3;
  1005.     v8i16 dst0, dst1, dst2, dst3;
  1006.     v8i16 filter_vec, const_vec;
  1007.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  1008.     v4i32 weight_vec, offset_vec, rnd_vec;
  1009.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1010.  
  1011.     src -= 3;
  1012.     const_vec = __msa_ldi_h(128);
  1013.     const_vec <<= 6;
  1014.  
  1015.     weight = weight & 0x0000FFFF;
  1016.     weight_vec = __msa_fill_w(weight);
  1017.     offset_vec = __msa_fill_w(offset);
  1018.     rnd_vec = __msa_fill_w(rnd_val);
  1019.  
  1020.     filter_vec = LD_SH(filter);
  1021.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1022.  
  1023.     mask1 = mask0 + 2;
  1024.     mask2 = mask0 + 4;
  1025.     mask3 = mask0 + 6;
  1026.     mask4 = mask0 + 8;
  1027.     mask5 = mask0 + 10;
  1028.     mask6 = mask0 + 12;
  1029.     mask7 = mask0 + 14;
  1030.  
  1031.     for (loop_cnt = height; loop_cnt--;) {
  1032.         src_tmp = src;
  1033.         dst_tmp = dst;
  1034.  
  1035.         for (cnt = 2; cnt--;) {
  1036.             LD_SB2(src_tmp, 16, src0, src1);
  1037.             src2 = LD_SB(src_tmp + 24);
  1038.             src_tmp += 32;
  1039.             XORI_B3_128_SB(src0, src1, src2);
  1040.  
  1041.             VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  1042.                        vec0, vec1, vec2, vec3);
  1043.             dst0 = const_vec;
  1044.             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1045.                          dst0, dst0, dst0, dst0);
  1046.             VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
  1047.                        vec0, vec1, vec2, vec3);
  1048.             dst1 = const_vec;
  1049.             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1050.                          dst1, dst1, dst1, dst1);
  1051.             VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  1052.                        vec0, vec1, vec2, vec3);
  1053.             dst2 = const_vec;
  1054.             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1055.                          dst2, dst2, dst2, dst2);
  1056.             VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  1057.                        vec0, vec1, vec2, vec3);
  1058.             dst3 = const_vec;
  1059.             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1060.                          dst3, dst3, dst3, dst3);
  1061.  
  1062.             HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  1063.                                 weight_vec, offset_vec, rnd_vec,
  1064.                                 dst0_r, dst1_r, dst2_r, dst3_r,
  1065.                                 dst0_l, dst1_l, dst2_l, dst3_l);
  1066.  
  1067.             HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  1068.                             dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  1069.             ST_SW2(dst0_r, dst1_r, dst_tmp, 16);
  1070.             dst_tmp += 32;
  1071.         }
  1072.  
  1073.         src += src_stride;
  1074.         dst += dst_stride;
  1075.     }
  1076. }
  1077.  
  1078. static void hevc_vt_uniwgt_8t_4w_msa(uint8_t *src,
  1079.                                      int32_t src_stride,
  1080.                                      uint8_t *dst,
  1081.                                      int32_t dst_stride,
  1082.                                      const int8_t *filter,
  1083.                                      int32_t height,
  1084.                                      int32_t weight,
  1085.                                      int32_t offset,
  1086.                                      int32_t rnd_val)
  1087. {
  1088.     int32_t loop_cnt;
  1089.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1090.     v16i8 src9, src10, src11, src12, src13, src14;
  1091.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  1092.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  1093.     v16i8 src1110_r, src1211_r, src1312_r, src1413_r;
  1094.     v16i8 src2110, src4332, src6554, src8776, src10998;
  1095.     v16i8 src12111110, src14131312;
  1096.     v8i16 dst10, dst32, dst54, dst76;
  1097.     v8i16 filt0, filt1, filt2, filt3;
  1098.     v8i16 filter_vec, const_vec;
  1099.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  1100.     v4i32 weight_vec, offset_vec, rnd_vec;
  1101.  
  1102.     src -= (3 * src_stride);
  1103.     const_vec = __msa_ldi_h(128);
  1104.     const_vec <<= 6;
  1105.  
  1106.     weight = weight & 0x0000FFFF;
  1107.     weight_vec = __msa_fill_w(weight);
  1108.     offset_vec = __msa_fill_w(offset);
  1109.     rnd_vec = __msa_fill_w(rnd_val);
  1110.  
  1111.     filter_vec = LD_SH(filter);
  1112.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1113.  
  1114.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1115.     src += (7 * src_stride);
  1116.  
  1117.     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  1118.                src10_r, src32_r, src54_r, src21_r);
  1119.  
  1120.     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
  1121.  
  1122.     ILVR_D3_SB(src21_r, src10_r, src43_r,
  1123.                src32_r, src65_r, src54_r, src2110, src4332, src6554);
  1124.  
  1125.     XORI_B3_128_SB(src2110, src4332, src6554);
  1126.  
  1127.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  1128.         LD_SB8(src, src_stride,
  1129.                src7, src8, src9, src10, src11, src12, src13, src14);
  1130.         src += (8 * src_stride);
  1131.         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  1132.                    src76_r, src87_r, src98_r, src109_r);
  1133.         ILVR_B4_SB(src11, src10, src12, src11, src13, src12, src14, src13,
  1134.                    src1110_r, src1211_r, src1312_r, src1413_r);
  1135.         ILVR_D4_SB(src87_r, src76_r, src109_r, src98_r, src1211_r, src1110_r,
  1136.                    src1413_r, src1312_r,
  1137.                    src8776, src10998, src12111110, src14131312);
  1138.         XORI_B4_128_SB(src8776, src10998, src12111110, src14131312);
  1139.  
  1140.         dst10 = const_vec;
  1141.         DPADD_SB4_SH(src2110, src4332, src6554, src8776, filt0, filt1,
  1142.                      filt2, filt3, dst10, dst10, dst10, dst10);
  1143.         dst32 = const_vec;
  1144.         DPADD_SB4_SH(src4332, src6554, src8776, src10998,
  1145.                      filt0, filt1, filt2, filt3, dst32, dst32, dst32, dst32);
  1146.         dst54 = const_vec;
  1147.         DPADD_SB4_SH(src6554, src8776, src10998, src12111110,
  1148.                      filt0, filt1, filt2, filt3, dst54, dst54, dst54, dst54);
  1149.         dst76 = const_vec;
  1150.         DPADD_SB4_SH(src8776, src10998, src12111110, src14131312,
  1151.                      filt0, filt1, filt2, filt3, dst76, dst76, dst76, dst76);
  1152.  
  1153.         HEVC_UNIW_RND_CLIP4(dst10, dst32, dst54, dst76,
  1154.                             weight_vec, offset_vec, rnd_vec,
  1155.                             dst0_r, dst1_r, dst2_r, dst3_r,
  1156.                             dst0_l, dst1_l, dst2_l, dst3_l);
  1157.  
  1158.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  1159.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  1160.         ST4x8_UB(dst0_r, dst1_r, dst, dst_stride);
  1161.         dst += (8 * dst_stride);
  1162.  
  1163.         src2110 = src10998;
  1164.         src4332 = src12111110;
  1165.         src6554 = src14131312;
  1166.         src6 = src14;
  1167.     }
  1168. }
  1169.  
  1170. static void hevc_vt_uniwgt_8t_8w_msa(uint8_t *src,
  1171.                                      int32_t src_stride,
  1172.                                      uint8_t *dst,
  1173.                                      int32_t dst_stride,
  1174.                                      const int8_t *filter,
  1175.                                      int32_t height,
  1176.                                      int32_t weight,
  1177.                                      int32_t offset,
  1178.                                      int32_t rnd_val)
  1179. {
  1180.     int32_t loop_cnt;
  1181.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
  1182.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  1183.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  1184.     v8i16 tmp0, tmp1, tmp2, tmp3;
  1185.     v8i16 filt0, filt1, filt2, filt3;
  1186.     v8i16 filter_vec, const_vec;
  1187.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  1188.     v4i32 weight_vec, offset_vec, rnd_vec;
  1189.  
  1190.     src -= (3 * src_stride);
  1191.     const_vec = __msa_ldi_h(128);
  1192.     const_vec <<= 6;
  1193.  
  1194.     weight = weight & 0x0000FFFF;
  1195.     weight_vec = __msa_fill_w(weight);
  1196.     offset_vec = __msa_fill_w(offset);
  1197.     rnd_vec = __msa_fill_w(rnd_val);
  1198.  
  1199.     filter_vec = LD_SH(filter);
  1200.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1201.  
  1202.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1203.     src += (7 * src_stride);
  1204.     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  1205.  
  1206.     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  1207.                src10_r, src32_r, src54_r, src21_r);
  1208.     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
  1209.  
  1210.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1211.         LD_SB4(src, src_stride, src7, src8, src9, src10);
  1212.         src += (4 * src_stride);
  1213.         XORI_B4_128_SB(src7, src8, src9, src10);
  1214.         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  1215.                    src76_r, src87_r, src98_r, src109_r);
  1216.  
  1217.         tmp0 = const_vec;
  1218.         DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
  1219.                      filt0, filt1, filt2, filt3, tmp0, tmp0, tmp0, tmp0);
  1220.         tmp1 = const_vec;
  1221.         DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
  1222.                      filt0, filt1, filt2, filt3, tmp1, tmp1, tmp1, tmp1);
  1223.         tmp2 = const_vec;
  1224.         DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
  1225.                      filt0, filt1, filt2, filt3, tmp2, tmp2, tmp2, tmp2);
  1226.         tmp3 = const_vec;
  1227.         DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
  1228.                      filt0, filt1, filt2, filt3, tmp3, tmp3, tmp3, tmp3);
  1229.  
  1230.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  1231.                             weight_vec, offset_vec, rnd_vec,
  1232.                             dst0_r, dst1_r, dst2_r, dst3_r,
  1233.                             dst0_l, dst1_l, dst2_l, dst3_l);
  1234.  
  1235.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  1236.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  1237.         ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  1238.         dst += (4 * dst_stride);
  1239.  
  1240.         src10_r = src54_r;
  1241.         src32_r = src76_r;
  1242.         src54_r = src98_r;
  1243.         src21_r = src65_r;
  1244.         src43_r = src87_r;
  1245.         src65_r = src109_r;
  1246.         src6 = src10;
  1247.     }
  1248. }
  1249.  
  1250. static void hevc_vt_uniwgt_8t_12w_msa(uint8_t *src,
  1251.                                       int32_t src_stride,
  1252.                                       uint8_t *dst,
  1253.                                       int32_t dst_stride,
  1254.                                       const int8_t *filter,
  1255.                                       int32_t height,
  1256.                                       int32_t weight,
  1257.                                       int32_t offset,
  1258.                                       int32_t rnd_val)
  1259. {
  1260.     int32_t loop_cnt;
  1261.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
  1262.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  1263.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  1264.     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
  1265.     v16i8 src10_l, src32_l, src54_l, src76_l, src98_l;
  1266.     v16i8 src21_l, src43_l, src65_l, src87_l, src109_l;
  1267.     v16i8 src2110, src4332, src6554, src8776, src10998;
  1268.     v8i16 filt0, filt1, filt2, filt3;
  1269.     v8i16 filter_vec, const_vec;
  1270.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  1271.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  1272.     v4i32 weight_vec, offset_vec, rnd_vec;
  1273.  
  1274.     src -= (3 * src_stride);
  1275.     const_vec = __msa_ldi_h(128);
  1276.     const_vec <<= 6;
  1277.  
  1278.     weight = weight & 0x0000FFFF;
  1279.     weight_vec = __msa_fill_w(weight);
  1280.     offset_vec = __msa_fill_w(offset);
  1281.     rnd_vec = __msa_fill_w(rnd_val);
  1282.  
  1283.     filter_vec = LD_SH(filter);
  1284.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1285.  
  1286.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1287.     src += (7 * src_stride);
  1288.     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  1289.  
  1290.     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  1291.                src10_r, src32_r, src54_r, src21_r);
  1292.     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
  1293.     ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  1294.                src10_l, src32_l, src54_l, src21_l);
  1295.     ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
  1296.     ILVR_D3_SB(src21_l, src10_l, src43_l, src32_l, src65_l, src54_l,
  1297.                src2110, src4332, src6554);
  1298.  
  1299.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1300.         LD_SB4(src, src_stride, src7, src8, src9, src10);
  1301.         src += (4 * src_stride);
  1302.         XORI_B4_128_SB(src7, src8, src9, src10);
  1303.  
  1304.         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  1305.                    src76_r, src87_r, src98_r, src109_r);
  1306.         ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  1307.                    src76_l, src87_l, src98_l, src109_l);
  1308.         ILVR_D2_SB(src87_l, src76_l, src109_l, src98_l, src8776, src10998);
  1309.  
  1310.         tmp0 = const_vec;
  1311.         DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
  1312.                      filt0, filt1, filt2, filt3, tmp0, tmp0, tmp0, tmp0);
  1313.         tmp1 = const_vec;
  1314.         DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
  1315.                      filt0, filt1, filt2, filt3, tmp1, tmp1, tmp1, tmp1);
  1316.         tmp2 = const_vec;
  1317.         DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
  1318.                      filt0, filt1, filt2, filt3, tmp2, tmp2, tmp2, tmp2);
  1319.         tmp3 = const_vec;
  1320.         DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
  1321.                      filt0, filt1, filt2, filt3, tmp3, tmp3, tmp3, tmp3);
  1322.         tmp4 = const_vec;
  1323.         DPADD_SB4_SH(src2110, src4332, src6554, src8776,
  1324.                      filt0, filt1, filt2, filt3, tmp4, tmp4, tmp4, tmp4);
  1325.         tmp5 = const_vec;
  1326.         DPADD_SB4_SH(src4332, src6554, src8776, src10998,
  1327.                      filt0, filt1, filt2, filt3, tmp5, tmp5, tmp5, tmp5);
  1328.  
  1329.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  1330.                             weight_vec, offset_vec, rnd_vec,
  1331.                             dst0_r, dst1_r, dst2_r, dst3_r,
  1332.                             dst0_l, dst1_l, dst2_l, dst3_l);
  1333.         HEVC_UNIW_RND_CLIP2(tmp4, tmp5, weight_vec, offset_vec, rnd_vec,
  1334.                             dst4_r, dst5_r, dst4_l, dst5_l);
  1335.  
  1336.         HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  1337.                          dst2_l, dst2_r, dst3_l, dst3_r,
  1338.                          dst4_l, dst4_r, dst5_l, dst5_r,
  1339.                          dst0_r, dst1_r, dst2_r);
  1340.         ST12x4_UB(dst0_r, dst1_r, dst2_r, dst, dst_stride);
  1341.         dst += (4 * dst_stride);
  1342.  
  1343.         src10_r = src54_r;
  1344.         src32_r = src76_r;
  1345.         src54_r = src98_r;
  1346.         src21_r = src65_r;
  1347.         src43_r = src87_r;
  1348.         src65_r = src109_r;
  1349.         src2110 = src6554;
  1350.         src4332 = src8776;
  1351.         src6554 = src10998;
  1352.         src6 = src10;
  1353.     }
  1354. }
  1355.  
  1356. static void hevc_vt_uniwgt_8t_16multx2mult_msa(uint8_t *src,
  1357.                                                int32_t src_stride,
  1358.                                                uint8_t *dst,
  1359.                                                int32_t dst_stride,
  1360.                                                const int8_t *filter,
  1361.                                                int32_t height,
  1362.                                                int32_t weight,
  1363.                                                int32_t offset,
  1364.                                                int32_t rnd_val,
  1365.                                                int32_t width)
  1366. {
  1367.     uint8_t *src_tmp;
  1368.     uint8_t *dst_tmp;
  1369.     int32_t loop_cnt, cnt;
  1370.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1371.     v16i8 src10_r, src32_r, src54_r, src76_r;
  1372.     v16i8 src21_r, src43_r, src65_r, src87_r;
  1373.     v8i16 tmp0, tmp1, tmp2, tmp3;
  1374.     v16i8 src10_l, src32_l, src54_l, src76_l;
  1375.     v16i8 src21_l, src43_l, src65_l, src87_l;
  1376.     v8i16 filt0, filt1, filt2, filt3;
  1377.     v8i16 filter_vec, const_vec;
  1378.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  1379.     v4i32 weight_vec, offset_vec, rnd_vec;
  1380.  
  1381.     src -= (3 * src_stride);
  1382.     const_vec = __msa_ldi_h(128);
  1383.     const_vec <<= 6;
  1384.  
  1385.     weight = weight & 0x0000FFFF;
  1386.     weight_vec = __msa_fill_w(weight);
  1387.     offset_vec = __msa_fill_w(offset);
  1388.     rnd_vec = __msa_fill_w(rnd_val);
  1389.  
  1390.     filter_vec = LD_SH(filter);
  1391.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1392.  
  1393.     for (cnt = (width >> 4); cnt--;) {
  1394.         src_tmp = src;
  1395.         dst_tmp = dst;
  1396.  
  1397.         LD_SB7(src_tmp, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1398.         src_tmp += (7 * src_stride);
  1399.         XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  1400.         ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  1401.                    src10_r, src32_r, src54_r, src21_r);
  1402.         ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
  1403.         ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  1404.                    src10_l, src32_l, src54_l, src21_l);
  1405.         ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
  1406.  
  1407.         for (loop_cnt = (height >> 1); loop_cnt--;) {
  1408.             LD_SB2(src_tmp, src_stride, src7, src8);
  1409.             src_tmp += (2 * src_stride);
  1410.             XORI_B2_128_SB(src7, src8);
  1411.             ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
  1412.             ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
  1413.  
  1414.             tmp0 = const_vec;
  1415.             DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
  1416.                          filt0, filt1, filt2, filt3, tmp0, tmp0, tmp0, tmp0);
  1417.             tmp1 = const_vec;
  1418.             DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
  1419.                          filt0, filt1, filt2, filt3, tmp1, tmp1, tmp1, tmp1);
  1420.             tmp2 = const_vec;
  1421.             DPADD_SB4_SH(src10_l, src32_l, src54_l, src76_l,
  1422.                          filt0, filt1, filt2, filt3, tmp2, tmp2, tmp2, tmp2);
  1423.             tmp3 = const_vec;
  1424.             DPADD_SB4_SH(src21_l, src43_l, src65_l, src87_l,
  1425.                          filt0, filt1, filt2, filt3, tmp3, tmp3, tmp3, tmp3);
  1426.  
  1427.             HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  1428.                                 weight_vec, offset_vec, rnd_vec,
  1429.                                 dst0_r, dst1_r, dst2_r, dst3_r,
  1430.                                 dst0_l, dst1_l, dst2_l, dst3_l);
  1431.  
  1432.             HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
  1433.                             dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
  1434.             ST_SW2(dst0_r, dst1_r, dst_tmp, dst_stride);
  1435.             dst_tmp += (2 * dst_stride);
  1436.  
  1437.             src10_r = src32_r;
  1438.             src32_r = src54_r;
  1439.             src54_r = src76_r;
  1440.             src21_r = src43_r;
  1441.             src43_r = src65_r;
  1442.             src65_r = src87_r;
  1443.             src10_l = src32_l;
  1444.             src32_l = src54_l;
  1445.             src54_l = src76_l;
  1446.             src21_l = src43_l;
  1447.             src43_l = src65_l;
  1448.             src65_l = src87_l;
  1449.             src6 = src8;
  1450.         }
  1451.  
  1452.         src += 16;
  1453.         dst += 16;
  1454.     }
  1455. }
  1456.  
  1457. static void hevc_vt_uniwgt_8t_16w_msa(uint8_t *src,
  1458.                                       int32_t src_stride,
  1459.                                       uint8_t *dst,
  1460.                                       int32_t dst_stride,
  1461.                                       const int8_t *filter,
  1462.                                       int32_t height,
  1463.                                       int32_t weight,
  1464.                                       int32_t offset,
  1465.                                       int32_t rnd_val)
  1466. {
  1467.     hevc_vt_uniwgt_8t_16multx2mult_msa(src, src_stride, dst, dst_stride,
  1468.                                        filter, height, weight,
  1469.                                        offset, rnd_val, 16);
  1470. }
  1471.  
  1472. static void hevc_vt_uniwgt_8t_24w_msa(uint8_t *src,
  1473.                                       int32_t src_stride,
  1474.                                       uint8_t *dst,
  1475.                                       int32_t dst_stride,
  1476.                                       const int8_t *filter,
  1477.                                       int32_t height,
  1478.                                       int32_t weight,
  1479.                                       int32_t offset,
  1480.                                       int32_t rnd_val)
  1481. {
  1482.     hevc_vt_uniwgt_8t_16multx2mult_msa(src, src_stride, dst, dst_stride,
  1483.                                        filter, height, weight,
  1484.                                        offset, rnd_val, 16);
  1485.  
  1486.     hevc_vt_uniwgt_8t_8w_msa(src + 16, src_stride, dst + 16, dst_stride,
  1487.                              filter, height, weight, offset, rnd_val);
  1488. }
  1489.  
  1490. static void hevc_vt_uniwgt_8t_32w_msa(uint8_t *src,
  1491.                                       int32_t src_stride,
  1492.                                       uint8_t *dst,
  1493.                                       int32_t dst_stride,
  1494.                                       const int8_t *filter,
  1495.                                       int32_t height,
  1496.                                       int32_t weight,
  1497.                                       int32_t offset,
  1498.                                       int32_t rnd_val)
  1499. {
  1500.     hevc_vt_uniwgt_8t_16multx2mult_msa(src, src_stride, dst, dst_stride,
  1501.                                        filter, height, weight,
  1502.                                        offset, rnd_val, 32);
  1503. }
  1504.  
  1505. static void hevc_vt_uniwgt_8t_48w_msa(uint8_t *src,
  1506.                                       int32_t src_stride,
  1507.                                       uint8_t *dst,
  1508.                                       int32_t dst_stride,
  1509.                                       const int8_t *filter,
  1510.                                       int32_t height,
  1511.                                       int32_t weight,
  1512.                                       int32_t offset,
  1513.                                       int32_t rnd_val)
  1514. {
  1515.     hevc_vt_uniwgt_8t_16multx2mult_msa(src, src_stride, dst, dst_stride,
  1516.                                        filter, height, weight,
  1517.                                        offset, rnd_val, 48);
  1518. }
  1519.  
  1520. static void hevc_vt_uniwgt_8t_64w_msa(uint8_t *src,
  1521.                                       int32_t src_stride,
  1522.                                       uint8_t *dst,
  1523.                                       int32_t dst_stride,
  1524.                                       const int8_t *filter,
  1525.                                       int32_t height,
  1526.                                       int32_t weight,
  1527.                                       int32_t offset,
  1528.                                       int32_t rnd_val)
  1529. {
  1530.     hevc_vt_uniwgt_8t_16multx2mult_msa(src, src_stride, dst, dst_stride,
  1531.                                        filter, height, weight,
  1532.                                        offset, rnd_val, 64);
  1533. }
  1534.  
  1535. static void hevc_hv_uniwgt_8t_4w_msa(uint8_t *src,
  1536.                                      int32_t src_stride,
  1537.                                      uint8_t *dst,
  1538.                                      int32_t dst_stride,
  1539.                                      const int8_t *filter_x,
  1540.                                      const int8_t *filter_y,
  1541.                                      int32_t height,
  1542.                                      int32_t weight,
  1543.                                      int32_t offset,
  1544.                                      int32_t rnd_val)
  1545. {
  1546.     uint32_t loop_cnt;
  1547.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1548.     v8i16 filt0, filt1, filt2, filt3;
  1549.     v4i32 filt_h0, filt_h1, filt_h2, filt_h3;
  1550.     v16i8 mask1, mask2, mask3;
  1551.     v8i16 filter_vec, const_vec;
  1552.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
  1553.     v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
  1554.     v8i16 dst30, dst41, dst52, dst63, dst66, dst87;
  1555.     v4i32 dst0_r, dst1_r, weight_vec, offset_vec, rnd_vec;
  1556.     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
  1557.     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
  1558.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  1559.     v8u16 mask4 = { 0, 4, 1, 5, 2, 6, 3, 7 };
  1560.  
  1561.     src -= ((3 * src_stride) + 3);
  1562.     filter_vec = LD_SH(filter_x);
  1563.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1564.  
  1565.     filter_vec = LD_SH(filter_y);
  1566.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  1567.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  1568.  
  1569.     SPLATI_W4_SW(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
  1570.  
  1571.     mask1 = mask0 + 2;
  1572.     mask2 = mask0 + 4;
  1573.     mask3 = mask0 + 6;
  1574.  
  1575.     const_vec = __msa_ldi_h(128);
  1576.     const_vec <<= 6;
  1577.  
  1578.     weight_vec = __msa_fill_w(weight);
  1579.     offset_vec = __msa_fill_w(offset);
  1580.     rnd_vec = __msa_fill_w(rnd_val);
  1581.  
  1582.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1583.     src += (7 * src_stride);
  1584.     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  1585.  
  1586.     /* row 0 row 1 row 2 row 3 */
  1587.     VSHF_B4_SB(src0, src3, mask0, mask1, mask2, mask3, vec0, vec1, vec2, vec3);
  1588.     VSHF_B4_SB(src1, src4, mask0, mask1, mask2, mask3, vec4, vec5, vec6, vec7);
  1589.     VSHF_B4_SB(src2, src5, mask0, mask1, mask2, mask3,
  1590.                vec8, vec9, vec10, vec11);
  1591.     VSHF_B4_SB(src3, src6, mask0, mask1, mask2, mask3,
  1592.                vec12, vec13, vec14, vec15);
  1593.     dst30 = const_vec;
  1594.     DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1595.                  dst30, dst30, dst30, dst30);
  1596.     dst41 = const_vec;
  1597.     DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
  1598.                  dst41, dst41, dst41, dst41);
  1599.     dst52 = const_vec;
  1600.     DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
  1601.                  dst52, dst52, dst52, dst52);
  1602.     dst63 = const_vec;
  1603.     DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2, filt3,
  1604.                  dst63, dst63, dst63, dst63);
  1605.  
  1606.     ILVR_H3_SH(dst41, dst30, dst52, dst41, dst63, dst52,
  1607.                dst10_r, dst21_r, dst32_r);
  1608.  
  1609.     dst43_r = __msa_ilvl_h(dst41, dst30);
  1610.     dst54_r = __msa_ilvl_h(dst52, dst41);
  1611.     dst65_r = __msa_ilvl_h(dst63, dst52);
  1612.  
  1613.     dst66 = (v8i16) __msa_splati_d((v2i64) dst63, 1);
  1614.  
  1615.     for (loop_cnt = height >> 1; loop_cnt--;) {
  1616.         LD_SB2(src, src_stride, src7, src8);
  1617.         src += (2 * src_stride);
  1618.         XORI_B2_128_SB(src7, src8);
  1619.  
  1620.         VSHF_B4_SB(src7, src8, mask0, mask1, mask2, mask3,
  1621.                    vec0, vec1, vec2, vec3);
  1622.         dst87 = const_vec;
  1623.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1624.                      dst87, dst87, dst87, dst87);
  1625.         dst76_r = __msa_ilvr_h(dst87, dst66);
  1626.         dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
  1627.                                 filt_h0, filt_h1, filt_h2, filt_h3);
  1628.         dst87_r = __msa_vshf_h((v8i16) mask4, dst87, dst87);
  1629.         dst1_r = HEVC_FILT_8TAP(dst21_r, dst43_r, dst65_r, dst87_r,
  1630.                                 filt_h0, filt_h1, filt_h2, filt_h3);
  1631.  
  1632.         dst0_r >>= 6;
  1633.         dst1_r >>= 6;
  1634.         MUL2(dst0_r, weight_vec, dst1_r, weight_vec, dst0_r, dst1_r);
  1635.         SRAR_W2_SW(dst0_r, dst1_r, rnd_vec);
  1636.         ADD2(dst0_r, offset_vec, dst1_r, offset_vec, dst0_r, dst1_r);
  1637.         dst0_r = CLIP_SW_0_255(dst0_r);
  1638.         dst1_r = CLIP_SW_0_255(dst1_r);
  1639.  
  1640.         HEVC_PCK_SW_SB2(dst1_r, dst0_r, dst0_r);
  1641.         ST4x2_UB(dst0_r, dst, dst_stride);
  1642.         dst += (2 * dst_stride);
  1643.  
  1644.         dst10_r = dst32_r;
  1645.         dst32_r = dst54_r;
  1646.         dst54_r = dst76_r;
  1647.         dst21_r = dst43_r;
  1648.         dst43_r = dst65_r;
  1649.         dst65_r = dst87_r;
  1650.         dst66 = (v8i16) __msa_splati_d((v2i64) dst87, 1);
  1651.     }
  1652. }
  1653.  
  1654. static void hevc_hv_uniwgt_8t_8multx2mult_msa(uint8_t *src,
  1655.                                               int32_t src_stride,
  1656.                                               uint8_t *dst,
  1657.                                               int32_t dst_stride,
  1658.                                               const int8_t *filter_x,
  1659.                                               const int8_t *filter_y,
  1660.                                               int32_t height,
  1661.                                               int32_t weight,
  1662.                                               int32_t offset,
  1663.                                               int32_t rnd_val,
  1664.                                               int32_t width)
  1665. {
  1666.     uint32_t loop_cnt, cnt;
  1667.     uint8_t *src_tmp;
  1668.     uint8_t *dst_tmp;
  1669.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1670.     v8i16 filt0, filt1, filt2, filt3;
  1671.     v4i32 filt_h0, filt_h1, filt_h2, filt_h3;
  1672.     v16i8 mask1, mask2, mask3;
  1673.     v8i16 filter_vec, const_vec;
  1674.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
  1675.     v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
  1676.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
  1677.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
  1678.     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
  1679.     v8i16 dst10_l, dst32_l, dst54_l, dst76_l;
  1680.     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
  1681.     v8i16 dst21_l, dst43_l, dst65_l, dst87_l;
  1682.     v4i32 weight_vec, offset_vec, rnd_vec;
  1683.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1684.  
  1685.     src -= ((3 * src_stride) + 3);
  1686.     const_vec = __msa_ldi_h(128);
  1687.     const_vec <<= 6;
  1688.  
  1689.     weight_vec = __msa_fill_w(weight);
  1690.     offset_vec = __msa_fill_w(offset);
  1691.     rnd_vec = __msa_fill_w(rnd_val);
  1692.  
  1693.     filter_vec = LD_SH(filter_x);
  1694.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1695.  
  1696.     filter_vec = LD_SH(filter_y);
  1697.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  1698.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  1699.     SPLATI_W4_SW(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
  1700.  
  1701.     mask1 = mask0 + 2;
  1702.     mask2 = mask0 + 4;
  1703.     mask3 = mask0 + 6;
  1704.  
  1705.     for (cnt = width >> 3; cnt--;) {
  1706.         src_tmp = src;
  1707.         dst_tmp = dst;
  1708.  
  1709.         LD_SB7(src_tmp, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1710.         src_tmp += (7 * src_stride);
  1711.         XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  1712.  
  1713.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  1714.                    vec0, vec1, vec2, vec3);
  1715.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  1716.                    vec4, vec5, vec6, vec7);
  1717.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  1718.                    vec8, vec9, vec10, vec11);
  1719.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  1720.                    vec12, vec13, vec14, vec15);
  1721.         dst0 = const_vec;
  1722.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1723.                      dst0, dst0, dst0, dst0);
  1724.         dst1 = const_vec;
  1725.         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
  1726.                      dst1, dst1, dst1, dst1);
  1727.         dst2 = const_vec;
  1728.         DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
  1729.                      dst2, dst2, dst2, dst2);
  1730.         dst3 = const_vec;
  1731.         DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2, filt3,
  1732.                      dst3, dst3, dst3, dst3);
  1733.  
  1734.         VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
  1735.                    vec0, vec1, vec2, vec3);
  1736.         VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3,
  1737.                    vec4, vec5, vec6, vec7);
  1738.         VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3,
  1739.                    vec8, vec9, vec10, vec11);
  1740.         dst4 = const_vec;
  1741.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1742.                      dst4, dst4, dst4, dst4);
  1743.         dst5 = const_vec;
  1744.         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
  1745.                      dst5, dst5, dst5, dst5);
  1746.         dst6 = const_vec;
  1747.         DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
  1748.                      dst6, dst6, dst6, dst6);
  1749.  
  1750.         ILVR_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst2, dst1,
  1751.                    dst10_r, dst32_r, dst54_r, dst21_r);
  1752.         ILVR_H2_SH(dst4, dst3, dst6, dst5, dst43_r, dst65_r);
  1753.         ILVL_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst2, dst1,
  1754.                    dst10_l, dst32_l, dst54_l, dst21_l);
  1755.         ILVL_H2_SH(dst4, dst3, dst6, dst5, dst43_l, dst65_l);
  1756.  
  1757.         for (loop_cnt = height >> 1; loop_cnt--;) {
  1758.             LD_SB2(src_tmp, src_stride, src7, src8);
  1759.             src_tmp += 2 * src_stride;
  1760.             XORI_B2_128_SB(src7, src8);
  1761.  
  1762.             VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3,
  1763.                        vec0, vec1, vec2, vec3);
  1764.             dst7 = const_vec;
  1765.             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1766.                          dst7, dst7, dst7, dst7);
  1767.  
  1768.             ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
  1769.             dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
  1770.                                     filt_h0, filt_h1, filt_h2, filt_h3);
  1771.             dst0_l = HEVC_FILT_8TAP(dst10_l, dst32_l, dst54_l, dst76_l,
  1772.                                     filt_h0, filt_h1, filt_h2, filt_h3);
  1773.             dst0_r >>= 6;
  1774.             dst0_l >>= 6;
  1775.  
  1776.             /* row 8 */
  1777.             VSHF_B4_SB(src8, src8, mask0, mask1, mask2, mask3,
  1778.                        vec0, vec1, vec2, vec3);
  1779.             dst8 = const_vec;
  1780.             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1781.                          dst8, dst8, dst8, dst8);
  1782.  
  1783.             ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
  1784.             dst1_r = HEVC_FILT_8TAP(dst21_r, dst43_r, dst65_r, dst87_r,
  1785.                                     filt_h0, filt_h1, filt_h2, filt_h3);
  1786.             dst1_l = HEVC_FILT_8TAP(dst21_l, dst43_l, dst65_l, dst87_l,
  1787.                                     filt_h0, filt_h1, filt_h2, filt_h3);
  1788.             dst1_r >>= 6;
  1789.             dst1_l >>= 6;
  1790.  
  1791.             HEVC_HV_UNIW_RND_CLIP4(dst0_r, dst1_r, dst0_l, dst1_l,
  1792.                                    weight_vec, offset_vec, rnd_vec,
  1793.                                    dst0_r, dst1_r, dst0_l, dst1_l);
  1794.  
  1795.             HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  1796.             ST8x2_UB(dst0_r, dst_tmp, dst_stride);
  1797.             dst_tmp += (2 * dst_stride);
  1798.  
  1799.             dst10_r = dst32_r;
  1800.             dst32_r = dst54_r;
  1801.             dst54_r = dst76_r;
  1802.             dst10_l = dst32_l;
  1803.             dst32_l = dst54_l;
  1804.             dst54_l = dst76_l;
  1805.             dst21_r = dst43_r;
  1806.             dst43_r = dst65_r;
  1807.             dst65_r = dst87_r;
  1808.             dst21_l = dst43_l;
  1809.             dst43_l = dst65_l;
  1810.             dst65_l = dst87_l;
  1811.             dst6 = dst8;
  1812.         }
  1813.  
  1814.         src += 8;
  1815.         dst += 8;
  1816.     }
  1817. }
  1818.  
  1819. static void hevc_hv_uniwgt_8t_8w_msa(uint8_t *src,
  1820.                                      int32_t src_stride,
  1821.                                      uint8_t *dst,
  1822.                                      int32_t dst_stride,
  1823.                                      const int8_t *filter_x,
  1824.                                      const int8_t *filter_y,
  1825.                                      int32_t height,
  1826.                                      int32_t weight,
  1827.                                      int32_t offset,
  1828.                                      int32_t rnd_val)
  1829. {
  1830.     hevc_hv_uniwgt_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1831.                                       filter_x, filter_y, height, weight,
  1832.                                       offset, rnd_val, 8);
  1833. }
  1834.  
  1835. static void hevc_hv_uniwgt_8t_12w_msa(uint8_t *src,
  1836.                                       int32_t src_stride,
  1837.                                       uint8_t *dst,
  1838.                                       int32_t dst_stride,
  1839.                                       const int8_t *filter_x,
  1840.                                       const int8_t *filter_y,
  1841.                                       int32_t height,
  1842.                                       int32_t weight,
  1843.                                       int32_t offset,
  1844.                                       int32_t rnd_val)
  1845. {
  1846.     hevc_hv_uniwgt_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1847.                                       filter_x, filter_y, height, weight,
  1848.                                       offset, rnd_val, 8);
  1849.     hevc_hv_uniwgt_8t_4w_msa(src + 8, src_stride, dst + 8, dst_stride,
  1850.                              filter_x, filter_y, height, weight, offset,
  1851.                              rnd_val);
  1852. }
  1853.  
  1854. static void hevc_hv_uniwgt_8t_16w_msa(uint8_t *src,
  1855.                                       int32_t src_stride,
  1856.                                       uint8_t *dst,
  1857.                                       int32_t dst_stride,
  1858.                                       const int8_t *filter_x,
  1859.                                       const int8_t *filter_y,
  1860.                                       int32_t height,
  1861.                                       int32_t weight,
  1862.                                       int32_t offset,
  1863.                                       int32_t rnd_val)
  1864. {
  1865.     hevc_hv_uniwgt_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1866.                                       filter_x, filter_y, height, weight,
  1867.                                       offset, rnd_val, 16);
  1868. }
  1869.  
  1870. static void hevc_hv_uniwgt_8t_24w_msa(uint8_t *src,
  1871.                                       int32_t src_stride,
  1872.                                       uint8_t *dst,
  1873.                                       int32_t dst_stride,
  1874.                                       const int8_t *filter_x,
  1875.                                       const int8_t *filter_y,
  1876.                                       int32_t height,
  1877.                                       int32_t weight,
  1878.                                       int32_t offset,
  1879.                                       int32_t rnd_val)
  1880. {
  1881.     hevc_hv_uniwgt_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1882.                                       filter_x, filter_y, height, weight,
  1883.                                       offset, rnd_val, 24);
  1884. }
  1885.  
  1886. static void hevc_hv_uniwgt_8t_32w_msa(uint8_t *src,
  1887.                                       int32_t src_stride,
  1888.                                       uint8_t *dst,
  1889.                                       int32_t dst_stride,
  1890.                                       const int8_t *filter_x,
  1891.                                       const int8_t *filter_y,
  1892.                                       int32_t height,
  1893.                                       int32_t weight,
  1894.                                       int32_t offset,
  1895.                                       int32_t rnd_val)
  1896. {
  1897.     hevc_hv_uniwgt_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1898.                                       filter_x, filter_y, height, weight,
  1899.                                       offset, rnd_val, 32);
  1900. }
  1901.  
  1902. static void hevc_hv_uniwgt_8t_48w_msa(uint8_t *src,
  1903.                                       int32_t src_stride,
  1904.                                       uint8_t *dst,
  1905.                                       int32_t dst_stride,
  1906.                                       const int8_t *filter_x,
  1907.                                       const int8_t *filter_y,
  1908.                                       int32_t height,
  1909.                                       int32_t weight,
  1910.                                       int32_t offset,
  1911.                                       int32_t rnd_val)
  1912. {
  1913.     hevc_hv_uniwgt_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1914.                                       filter_x, filter_y, height, weight,
  1915.                                       offset, rnd_val, 48);
  1916. }
  1917.  
  1918. static void hevc_hv_uniwgt_8t_64w_msa(uint8_t *src,
  1919.                                       int32_t src_stride,
  1920.                                       uint8_t *dst,
  1921.                                       int32_t dst_stride,
  1922.                                       const int8_t *filter_x,
  1923.                                       const int8_t *filter_y,
  1924.                                       int32_t height,
  1925.                                       int32_t weight,
  1926.                                       int32_t offset,
  1927.                                       int32_t rnd_val)
  1928. {
  1929.     hevc_hv_uniwgt_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1930.                                       filter_x, filter_y, height, weight,
  1931.                                       offset, rnd_val, 64);
  1932. }
  1933.  
  1934. static void hevc_hz_uniwgt_4t_4x2_msa(uint8_t *src,
  1935.                                       int32_t src_stride,
  1936.                                       uint8_t *dst,
  1937.                                       int32_t dst_stride,
  1938.                                       const int8_t *filter,
  1939.                                       int32_t height,
  1940.                                       int32_t weight,
  1941.                                       int32_t offset,
  1942.                                       int32_t rnd_val)
  1943. {
  1944.     v8i16 filt0, filt1;
  1945.     v16i8 src0, src1, vec0, vec1;
  1946.     v16i8 mask1;
  1947.     v8i16 dst0;
  1948.     v4i32 dst0_r, dst0_l;
  1949.     v8i16 filter_vec, const_vec;
  1950.     v4i32 weight_vec, offset_vec, rnd_vec;
  1951.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  1952.  
  1953.     src -= 1;
  1954.  
  1955.     filter_vec = LD_SH(filter);
  1956.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1957.  
  1958.     mask1 = mask0 + 2;
  1959.  
  1960.     weight = weight & 0x0000FFFF;
  1961.  
  1962.     const_vec = __msa_ldi_h(128);
  1963.     const_vec <<= 6;
  1964.  
  1965.     weight_vec = __msa_fill_w(weight);
  1966.     offset_vec = __msa_fill_w(offset);
  1967.     rnd_vec = __msa_fill_w(rnd_val);
  1968.  
  1969.     LD_SB2(src, src_stride, src0, src1);
  1970.     XORI_B2_128_SB(src0, src1);
  1971.  
  1972.     VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
  1973.     dst0 = const_vec;
  1974.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1975.  
  1976.     ILVRL_H2_SW(dst0, dst0, dst0_r, dst0_l);
  1977.     DOTP_SH2_SW(dst0_r, dst0_l, weight_vec, weight_vec, dst0_r, dst0_l);
  1978.     SRAR_W2_SW(dst0_r, dst0_l, rnd_vec);
  1979.     ADD2(dst0_r, offset_vec, dst0_l, offset_vec, dst0_r, dst0_l);
  1980.     dst0_r = CLIP_SW_0_255(dst0_r);
  1981.     dst0_l = CLIP_SW_0_255(dst0_l);
  1982.  
  1983.     HEVC_PCK_SW_SB2(dst0_l, dst0_r, dst0_r);
  1984.     ST4x2_UB(dst0_r, dst, dst_stride);
  1985.     dst += (4 * dst_stride);
  1986. }
  1987.  
  1988. static void hevc_hz_uniwgt_4t_4x4_msa(uint8_t *src,
  1989.                                       int32_t src_stride,
  1990.                                       uint8_t *dst,
  1991.                                       int32_t dst_stride,
  1992.                                       const int8_t *filter,
  1993.                                       int32_t height,
  1994.                                       int32_t weight,
  1995.                                       int32_t offset,
  1996.                                       int32_t rnd_val)
  1997. {
  1998.     v8i16 filt0, filt1;
  1999.     v16i8 src0, src1, src2, src3;
  2000.     v16i8 mask1, vec0, vec1;
  2001.     v8i16 dst0, dst1;
  2002.     v4i32 dst0_r, dst1_r, dst0_l, dst1_l;
  2003.     v8i16 filter_vec, const_vec;
  2004.     v4i32 weight_vec, offset_vec, rnd_vec;
  2005.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  2006.  
  2007.     src -= 1;
  2008.  
  2009.     /* rearranging filter */
  2010.     filter_vec = LD_SH(filter);
  2011.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2012.  
  2013.     mask1 = mask0 + 2;
  2014.  
  2015.     weight = weight & 0x0000FFFF;
  2016.  
  2017.     const_vec = __msa_ldi_h(128);
  2018.     const_vec <<= 6;
  2019.  
  2020.     weight_vec = __msa_fill_w(weight);
  2021.     offset_vec = __msa_fill_w(offset);
  2022.     rnd_vec = __msa_fill_w(rnd_val);
  2023.  
  2024.     LD_SB4(src, src_stride, src0, src1, src2, src3);
  2025.     XORI_B4_128_SB(src0, src1, src2, src3);
  2026.  
  2027.     VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
  2028.     dst0 = const_vec;
  2029.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2030.  
  2031.     VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
  2032.     dst1 = const_vec;
  2033.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2034.  
  2035.     HEVC_UNIW_RND_CLIP2(dst0, dst1, weight_vec, offset_vec, rnd_vec,
  2036.                         dst0_r, dst1_r, dst0_l, dst1_l);
  2037.  
  2038.     HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  2039.     ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
  2040.     dst += (4 * dst_stride);
  2041. }
  2042.  
  2043. static void hevc_hz_uniwgt_4t_4x8multiple_msa(uint8_t *src,
  2044.                                               int32_t src_stride,
  2045.                                               uint8_t *dst,
  2046.                                               int32_t dst_stride,
  2047.                                               const int8_t *filter,
  2048.                                               int32_t height,
  2049.                                               int32_t weight,
  2050.                                               int32_t offset,
  2051.                                               int32_t rnd_val)
  2052. {
  2053.     uint32_t loop_cnt;
  2054.     v8i16 filt0, filt1;
  2055.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  2056.     v16i8 mask1, vec0, vec1;
  2057.     v8i16 dst0, dst1, dst2, dst3;
  2058.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  2059.     v8i16 filter_vec, const_vec;
  2060.     v4i32 weight_vec, offset_vec, rnd_vec;
  2061.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  2062.  
  2063.     src -= 1;
  2064.  
  2065.     filter_vec = LD_SH(filter);
  2066.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2067.  
  2068.     weight = weight & 0x0000FFFF;
  2069.     const_vec = __msa_ldi_h(128);
  2070.     const_vec <<= 6;
  2071.  
  2072.     weight_vec = __msa_fill_w(weight);
  2073.     offset_vec = __msa_fill_w(offset);
  2074.     rnd_vec = __msa_fill_w(rnd_val);
  2075.  
  2076.     mask1 = mask0 + 2;
  2077.  
  2078.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  2079.         LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  2080.         src += (8 * src_stride);
  2081.  
  2082.         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
  2083.  
  2084.         VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
  2085.         dst0 = const_vec;
  2086.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2087.  
  2088.         VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
  2089.         dst1 = const_vec;
  2090.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2091.  
  2092.         VSHF_B2_SB(src4, src5, src4, src5, mask0, mask1, vec0, vec1);
  2093.         dst2 = const_vec;
  2094.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2095.  
  2096.         VSHF_B2_SB(src6, src7, src6, src7, mask0, mask1, vec0, vec1);
  2097.         dst3 = const_vec;
  2098.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2099.  
  2100.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2101.                             weight_vec, offset_vec, rnd_vec,
  2102.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2103.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2104.  
  2105.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2106.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2107.         ST4x8_UB(dst0_r, dst1_r, dst, dst_stride);
  2108.         dst += (8 * dst_stride);
  2109.     }
  2110. }
  2111.  
  2112. static void hevc_hz_uniwgt_4t_4w_msa(uint8_t *src,
  2113.                                      int32_t src_stride,
  2114.                                      uint8_t *dst,
  2115.                                      int32_t dst_stride,
  2116.                                      const int8_t *filter,
  2117.                                      int32_t height,
  2118.                                      int32_t weight,
  2119.                                      int32_t offset,
  2120.                                      int32_t rnd_val)
  2121. {
  2122.     if (2 == height) {
  2123.         hevc_hz_uniwgt_4t_4x2_msa(src, src_stride, dst, dst_stride,
  2124.                                   filter, height, weight, offset, rnd_val);
  2125.     } else if (4 == height) {
  2126.         hevc_hz_uniwgt_4t_4x4_msa(src, src_stride, dst, dst_stride,
  2127.                                   filter, height, weight, offset, rnd_val);
  2128.     } else if (8 == height || 16 == height) {
  2129.         hevc_hz_uniwgt_4t_4x8multiple_msa(src, src_stride, dst, dst_stride,
  2130.                                           filter, height, weight,
  2131.                                           offset, rnd_val);
  2132.     }
  2133. }
  2134.  
  2135. static void hevc_hz_uniwgt_4t_6w_msa(uint8_t *src,
  2136.                                      int32_t src_stride,
  2137.                                      uint8_t *dst,
  2138.                                      int32_t dst_stride,
  2139.                                      const int8_t *filter,
  2140.                                      int32_t height,
  2141.                                      int32_t weight,
  2142.                                      int32_t offset,
  2143.                                      int32_t rnd_val)
  2144. {
  2145.     uint32_t loop_cnt;
  2146.     v8i16 filt0, filt1;
  2147.     v16i8 src0, src1, src2, src3;
  2148.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2149.     v16i8 mask1;
  2150.     v16i8 vec0, vec1;
  2151.     v8i16 dst0, dst1, dst2, dst3;
  2152.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  2153.     v8i16 filter_vec, const_vec;
  2154.     v4i32 weight_vec, offset_vec, rnd_vec;
  2155.  
  2156.     src -= 1;
  2157.  
  2158.     filter_vec = LD_SH(filter);
  2159.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2160.  
  2161.     weight = weight & 0x0000FFFF;
  2162.     const_vec = __msa_ldi_h(128);
  2163.     const_vec <<= 6;
  2164.  
  2165.     weight_vec = __msa_fill_w(weight);
  2166.     offset_vec = __msa_fill_w(offset);
  2167.     rnd_vec = __msa_fill_w(rnd_val);
  2168.  
  2169.     mask1 = mask0 + 2;
  2170.  
  2171.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2172.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  2173.         src += (4 * src_stride);
  2174.  
  2175.         XORI_B4_128_SB(src0, src1, src2, src3);
  2176.  
  2177.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2178.         dst0 = const_vec;
  2179.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2180.  
  2181.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2182.         dst1 = const_vec;
  2183.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2184.  
  2185.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2186.         dst2 = const_vec;
  2187.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2188.  
  2189.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  2190.         dst3 = const_vec;
  2191.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2192.  
  2193.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2194.                             weight_vec, offset_vec, rnd_vec,
  2195.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2196.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2197.  
  2198.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2199.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2200.  
  2201.         ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
  2202.         dst += (4 * dst_stride);
  2203.     }
  2204. }
  2205.  
  2206. static void hevc_hz_uniwgt_4t_8x2_msa(uint8_t *src,
  2207.                                       int32_t src_stride,
  2208.                                       uint8_t *dst,
  2209.                                       int32_t dst_stride,
  2210.                                       const int8_t *filter,
  2211.                                       int32_t height,
  2212.                                       int32_t weight,
  2213.                                       int32_t offset,
  2214.                                       int32_t rnd_val)
  2215. {
  2216.     v8i16 filt0, filt1, dst0, dst1;
  2217.     v16i8 src0, src1;
  2218.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2219.     v16i8 mask1;
  2220.     v16i8 vec0, vec1;
  2221.     v8i16 filter_vec, const_vec;
  2222.     v4i32 dst0_r, dst1_r, dst0_l, dst1_l;
  2223.     v4i32 weight_vec, offset_vec, rnd_vec;
  2224.  
  2225.     src -= 1;
  2226.  
  2227.     filter_vec = LD_SH(filter);
  2228.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2229.  
  2230.     weight = weight & 0x0000FFFF;
  2231.     const_vec = __msa_ldi_h(128);
  2232.     const_vec <<= 6;
  2233.  
  2234.     weight_vec = __msa_fill_w(weight);
  2235.     offset_vec = __msa_fill_w(offset);
  2236.     rnd_vec = __msa_fill_w(rnd_val);
  2237.  
  2238.     mask1 = mask0 + 2;
  2239.  
  2240.     LD_SB2(src, src_stride, src0, src1);
  2241.     XORI_B2_128_SB(src0, src1);
  2242.  
  2243.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2244.     dst0 = const_vec;
  2245.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2246.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2247.     dst1 = const_vec;
  2248.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2249.  
  2250.     HEVC_UNIW_RND_CLIP2(dst0, dst1, weight_vec, offset_vec, rnd_vec,
  2251.                         dst0_r, dst1_r, dst0_l, dst1_l);
  2252.  
  2253.     HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  2254.     ST8x2_UB(dst0_r, dst, dst_stride);
  2255. }
  2256.  
  2257. static void hevc_hz_uniwgt_4t_8x6_msa(uint8_t *src,
  2258.                                       int32_t src_stride,
  2259.                                       uint8_t *dst,
  2260.                                       int32_t dst_stride,
  2261.                                       const int8_t *filter,
  2262.                                       int32_t height,
  2263.                                       int32_t weight,
  2264.                                       int32_t offset,
  2265.                                       int32_t rnd_val)
  2266. {
  2267.     v8i16 filt0, filt1;
  2268.     v16i8 src0, src1, src2, src3, src4, src5;
  2269.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2270.     v16i8 mask1;
  2271.     v16i8 vec0, vec1;
  2272.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  2273.     v8i16 filter_vec, const_vec;
  2274.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  2275.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  2276.     v4i32 weight_vec, offset_vec, rnd_vec;
  2277.  
  2278.     src -= 1;
  2279.  
  2280.     filter_vec = LD_SH(filter);
  2281.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2282.  
  2283.     weight = weight & 0x0000FFFF;
  2284.     const_vec = __msa_ldi_h(128);
  2285.     const_vec <<= 6;
  2286.  
  2287.     weight_vec = __msa_fill_w(weight);
  2288.     offset_vec = __msa_fill_w(offset);
  2289.     rnd_vec = __msa_fill_w(rnd_val);
  2290.  
  2291.     mask1 = mask0 + 2;
  2292.  
  2293.     LD_SB6(src, src_stride, src0, src1, src2, src3, src4, src5);
  2294.     LD_SB6(src, src_stride, src0, src1, src2, src3, src4, src5);
  2295.     XORI_B6_128_SB(src0, src1, src2, src3, src4, src5);
  2296.  
  2297.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2298.     dst0 = const_vec;
  2299.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2300.  
  2301.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2302.     dst1 = const_vec;
  2303.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2304.  
  2305.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2306.     dst2 = const_vec;
  2307.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2308.  
  2309.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  2310.     dst3 = const_vec;
  2311.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2312.  
  2313.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  2314.     dst4 = const_vec;
  2315.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  2316.  
  2317.     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  2318.     dst5 = const_vec;
  2319.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  2320.  
  2321.     HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2322.                         weight_vec, offset_vec, rnd_vec,
  2323.                         dst0_r, dst1_r, dst2_r, dst3_r,
  2324.                         dst0_l, dst1_l, dst2_l, dst3_l);
  2325.  
  2326.     HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
  2327.                         dst4_r, dst5_r, dst4_l, dst5_l);
  2328.  
  2329.     HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  2330.                      dst2_l, dst2_r, dst3_l, dst3_r,
  2331.                      dst4_l, dst4_r, dst5_l, dst5_r, dst0_r, dst1_r, dst2_r);
  2332.  
  2333.     ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  2334.     dst += (4 * dst_stride);
  2335.     ST8x2_UB(dst2_r, dst, dst_stride);
  2336. }
  2337.  
  2338. static void hevc_hz_uniwgt_4t_8x4multiple_msa(uint8_t *src,
  2339.                                               int32_t src_stride,
  2340.                                               uint8_t *dst,
  2341.                                               int32_t dst_stride,
  2342.                                               const int8_t *filter,
  2343.                                               int32_t height,
  2344.                                               int32_t weight,
  2345.                                               int32_t offset,
  2346.                                               int32_t rnd_val)
  2347. {
  2348.     uint32_t loop_cnt;
  2349.     v8i16 filt0, filt1;
  2350.     v16i8 src0, src1, src2, src3;
  2351.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2352.     v16i8 mask1;
  2353.     v16i8 vec0, vec1;
  2354.     v8i16 dst0, dst1, dst2, dst3;
  2355.     v8i16 filter_vec, const_vec;
  2356.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  2357.     v4i32 weight_vec, offset_vec, rnd_vec;
  2358.  
  2359.     src -= 1;
  2360.  
  2361.     filter_vec = LD_SH(filter);
  2362.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2363.  
  2364.     weight = weight & 0x0000FFFF;
  2365.     const_vec = __msa_ldi_h(128);
  2366.     const_vec <<= 6;
  2367.  
  2368.     weight_vec = __msa_fill_w(weight);
  2369.     offset_vec = __msa_fill_w(offset);
  2370.     rnd_vec = __msa_fill_w(rnd_val);
  2371.  
  2372.     mask1 = mask0 + 2;
  2373.  
  2374.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2375.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  2376.         src += (4 * src_stride);
  2377.  
  2378.         XORI_B4_128_SB(src0, src1, src2, src3);
  2379.  
  2380.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2381.         dst0 = const_vec;
  2382.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2383.  
  2384.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2385.         dst1 = const_vec;
  2386.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2387.  
  2388.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2389.         dst2 = const_vec;
  2390.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2391.  
  2392.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  2393.         dst3 = const_vec;
  2394.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2395.  
  2396.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2397.                             weight_vec, offset_vec, rnd_vec,
  2398.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2399.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2400.  
  2401.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2402.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2403.  
  2404.         ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  2405.         dst += (4 * dst_stride);
  2406.     }
  2407. }
  2408.  
  2409. static void hevc_hz_uniwgt_4t_8w_msa(uint8_t *src,
  2410.                                      int32_t src_stride,
  2411.                                      uint8_t *dst,
  2412.                                      int32_t dst_stride,
  2413.                                      const int8_t *filter,
  2414.                                      int32_t height,
  2415.                                      int32_t weight,
  2416.                                      int32_t offset,
  2417.                                      int32_t rnd_val)
  2418. {
  2419.     if (2 == height) {
  2420.         hevc_hz_uniwgt_4t_8x2_msa(src, src_stride, dst, dst_stride,
  2421.                                   filter, height, weight, offset, rnd_val);
  2422.     } else if (6 == height) {
  2423.         hevc_hz_uniwgt_4t_8x6_msa(src, src_stride, dst, dst_stride,
  2424.                                   filter, height, weight, offset, rnd_val);
  2425.     } else {
  2426.         hevc_hz_uniwgt_4t_8x4multiple_msa(src, src_stride, dst, dst_stride,
  2427.                                           filter, height, weight, offset,
  2428.                                           rnd_val);
  2429.     }
  2430. }
  2431.  
  2432. static void hevc_hz_uniwgt_4t_12w_msa(uint8_t *src,
  2433.                                       int32_t src_stride,
  2434.                                       uint8_t *dst,
  2435.                                       int32_t dst_stride,
  2436.                                       const int8_t *filter,
  2437.                                       int32_t height,
  2438.                                       int32_t weight,
  2439.                                       int32_t offset,
  2440.                                       int32_t rnd_val)
  2441. {
  2442.     uint32_t loop_cnt;
  2443.     v8i16 filt0, filt1;
  2444.     v16i8 src0, src1, src2, src3;
  2445.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2446.     v16i8 mask2 = { 8, 9, 9, 10, 10, 11, 11, 12, 24, 25, 25, 26, 26, 27, 27, 28
  2447.     };
  2448.     v16i8 mask1;
  2449.     v16i8 vec0, vec1;
  2450.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  2451.     v8i16 filter_vec, const_vec;
  2452.     v16i8 mask3;
  2453.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  2454.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  2455.     v4i32 weight_vec, offset_vec, rnd_vec;
  2456.  
  2457.     src -= 1;
  2458.  
  2459.     filter_vec = LD_SH(filter);
  2460.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2461.  
  2462.     weight = weight & 0x0000FFFF;
  2463.     const_vec = __msa_ldi_h(128);
  2464.     const_vec <<= 6;
  2465.  
  2466.     weight_vec = __msa_fill_w(weight);
  2467.     offset_vec = __msa_fill_w(offset);
  2468.     rnd_vec = __msa_fill_w(rnd_val);
  2469.  
  2470.     mask1 = mask0 + 2;
  2471.     mask3 = mask2 + 2;
  2472.  
  2473.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2474.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  2475.         src += (4 * src_stride);
  2476.  
  2477.         XORI_B4_128_SB(src0, src1, src2, src3);
  2478.  
  2479.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2480.         dst0 = const_vec;
  2481.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2482.  
  2483.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2484.         dst1 = const_vec;
  2485.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2486.  
  2487.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2488.         dst2 = const_vec;
  2489.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2490.  
  2491.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  2492.         dst3 = const_vec;
  2493.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2494.  
  2495.         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
  2496.         dst4 = const_vec;
  2497.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  2498.  
  2499.         VSHF_B2_SB(src2, src3, src2, src3, mask2, mask3, vec0, vec1);
  2500.         dst5 = const_vec;
  2501.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  2502.  
  2503.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2504.                             weight_vec, offset_vec, rnd_vec,
  2505.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2506.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2507.  
  2508.         HEVC_UNIW_RND_CLIP2(dst4, dst5, weight_vec, offset_vec, rnd_vec,
  2509.                             dst4_r, dst5_r, dst4_l, dst5_l);
  2510.  
  2511.         HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  2512.                          dst2_l, dst2_r, dst3_l, dst3_r,
  2513.                          dst4_l, dst4_r, dst5_l, dst5_r,
  2514.                          dst0_r, dst1_r, dst2_r);
  2515.  
  2516.         ST12x4_UB(dst0_r, dst1_r, dst2_r, dst, dst_stride);
  2517.         dst += (4 * dst_stride);
  2518.     }
  2519. }
  2520.  
  2521. static void hevc_hz_uniwgt_4t_16w_msa(uint8_t *src,
  2522.                                       int32_t src_stride,
  2523.                                       uint8_t *dst,
  2524.                                       int32_t dst_stride,
  2525.                                       const int8_t *filter,
  2526.                                       int32_t height,
  2527.                                       int32_t weight,
  2528.                                       int32_t offset,
  2529.                                       int32_t rnd_val)
  2530. {
  2531.     uint32_t loop_cnt;
  2532.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  2533.     v8i16 filt0, filt1;
  2534.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2535.     v16i8 mask1;
  2536.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
  2537.     v16i8 vec0, vec1;
  2538.     v8i16 filter_vec, const_vec;
  2539.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  2540.     v4i32 weight_vec, offset_vec, rnd_vec;
  2541.  
  2542.     src -= 1;
  2543.  
  2544.     filter_vec = LD_SH(filter);
  2545.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2546.  
  2547.     weight = weight & 0x0000FFFF;
  2548.     const_vec = __msa_ldi_h(128);
  2549.     const_vec <<= 6;
  2550.  
  2551.     weight_vec = __msa_fill_w(weight);
  2552.     offset_vec = __msa_fill_w(offset);
  2553.     rnd_vec = __msa_fill_w(rnd_val);
  2554.  
  2555.     mask1 = mask0 + 2;
  2556.  
  2557.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2558.         LD_SB4(src, src_stride, src0, src2, src4, src6);
  2559.         LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
  2560.         src += (4 * src_stride);
  2561.  
  2562.         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
  2563.  
  2564.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2565.         dst0 = const_vec;
  2566.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2567.  
  2568.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2569.         dst1 = const_vec;
  2570.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2571.  
  2572.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2573.         dst2 = const_vec;
  2574.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2575.  
  2576.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  2577.         dst3 = const_vec;
  2578.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2579.  
  2580.         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  2581.         dst4 = const_vec;
  2582.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  2583.  
  2584.         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  2585.         dst5 = const_vec;
  2586.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  2587.  
  2588.         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  2589.         dst6 = const_vec;
  2590.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
  2591.  
  2592.         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
  2593.         dst7 = const_vec;
  2594.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
  2595.  
  2596.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2597.                             weight_vec, offset_vec, rnd_vec,
  2598.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2599.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2600.  
  2601.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2602.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2603.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  2604.         dst += (2 * dst_stride);
  2605.  
  2606.         HEVC_UNIW_RND_CLIP4(dst4, dst5, dst6, dst7,
  2607.                             weight_vec, offset_vec, rnd_vec,
  2608.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2609.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2610.  
  2611.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2612.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2613.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  2614.         dst += (2 * dst_stride);
  2615.     }
  2616. }
  2617.  
  2618. static void hevc_hz_uniwgt_4t_24w_msa(uint8_t *src,
  2619.                                       int32_t src_stride,
  2620.                                       uint8_t *dst,
  2621.                                       int32_t dst_stride,
  2622.                                       const int8_t *filter,
  2623.                                       int32_t height,
  2624.                                       int32_t weight,
  2625.                                       int32_t offset,
  2626.                                       int32_t rnd_val)
  2627. {
  2628.     uint32_t loop_cnt;
  2629.     uint8_t *dst_tmp = dst + 16;
  2630.     v16i8 src0, src1, src2, src3;
  2631.     v8i16 filt0, filt1;
  2632.     v8i16 dst0, dst1, dst2, dst3;
  2633.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2634.     v16i8 mask1, mask2, mask3;
  2635.     v16i8 vec0, vec1;
  2636.     v8i16 filter_vec, const_vec;
  2637.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  2638.     v4i32 weight_vec, offset_vec, rnd_vec;
  2639.  
  2640.     src -= 1;
  2641.  
  2642.     filter_vec = LD_SH(filter);
  2643.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2644.  
  2645.     weight = weight & 0x0000FFFF;
  2646.     const_vec = __msa_ldi_h(128);
  2647.     const_vec <<= 6;
  2648.  
  2649.     weight_vec = __msa_fill_w(weight);
  2650.     offset_vec = __msa_fill_w(offset);
  2651.     rnd_vec = __msa_fill_w(rnd_val);
  2652.  
  2653.     mask1 = mask0 + 2;
  2654.     mask2 = mask0 + 8;
  2655.     mask3 = mask0 + 10;
  2656.  
  2657.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  2658.         /* 16 width */
  2659.         LD_SB2(src, src_stride, src0, src2);
  2660.         LD_SB2(src + 16, src_stride, src1, src3);
  2661.         src += (2 * src_stride);
  2662.  
  2663.         XORI_B4_128_SB(src0, src1, src2, src3);
  2664.  
  2665.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2666.         dst0 = const_vec;
  2667.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2668.  
  2669.         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
  2670.         dst1 = const_vec;
  2671.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2672.  
  2673.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2674.         dst2 = const_vec;
  2675.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2676.  
  2677.         VSHF_B2_SB(src2, src3, src2, src3, mask2, mask3, vec0, vec1);
  2678.         dst3 = const_vec;
  2679.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2680.  
  2681.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2682.                             weight_vec, offset_vec, rnd_vec,
  2683.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2684.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2685.  
  2686.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2687.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2688.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  2689.         dst += (2 * dst_stride);
  2690.  
  2691.         /* 8 width */
  2692.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2693.         dst0 = const_vec;
  2694.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2695.  
  2696.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  2697.         dst1 = const_vec;
  2698.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2699.  
  2700.         HEVC_UNIW_RND_CLIP2(dst0, dst1, weight_vec, offset_vec, rnd_vec,
  2701.                             dst0_r, dst1_r, dst0_l, dst1_l);
  2702.  
  2703.         HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  2704.         ST8x2_UB(dst0_r, dst_tmp, dst_stride);
  2705.         dst_tmp += (2 * dst_stride);
  2706.     }
  2707. }
  2708.  
  2709. static void hevc_hz_uniwgt_4t_32w_msa(uint8_t *src,
  2710.                                       int32_t src_stride,
  2711.                                       uint8_t *dst,
  2712.                                       int32_t dst_stride,
  2713.                                       const int8_t *filter,
  2714.                                       int32_t height,
  2715.                                       int32_t weight,
  2716.                                       int32_t offset,
  2717.                                       int32_t rnd_val)
  2718. {
  2719.     uint32_t loop_cnt;
  2720.     v16i8 src0, src1, src2;
  2721.     v8i16 filt0, filt1;
  2722.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2723.     v16i8 mask1, mask2, mask3;
  2724.     v8i16 dst0, dst1, dst2, dst3;
  2725.     v16i8 vec0, vec1;
  2726.     v8i16 filter_vec, const_vec;
  2727.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  2728.     v4i32 weight_vec, offset_vec, rnd_vec;
  2729.  
  2730.     src -= 1;
  2731.  
  2732.     filter_vec = LD_SH(filter);
  2733.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2734.  
  2735.     weight = weight & 0x0000FFFF;
  2736.     const_vec = __msa_ldi_h(128);
  2737.     const_vec <<= 6;
  2738.  
  2739.     weight_vec = __msa_fill_w(weight);
  2740.     offset_vec = __msa_fill_w(offset);
  2741.     rnd_vec = __msa_fill_w(rnd_val);
  2742.  
  2743.     mask1 = mask0 + 2;
  2744.     mask2 = mask0 + 8;
  2745.     mask3 = mask0 + 10;
  2746.  
  2747.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  2748.         LD_SB2(src, 16, src0, src1);
  2749.         src2 = LD_SB(src + 24);
  2750.         src += src_stride;
  2751.  
  2752.         XORI_B3_128_SB(src0, src1, src2);
  2753.  
  2754.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2755.         dst0 = const_vec;
  2756.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2757.  
  2758.         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
  2759.         dst1 = const_vec;
  2760.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2761.  
  2762.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2763.         dst2 = const_vec;
  2764.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2765.  
  2766.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2767.         dst3 = const_vec;
  2768.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2769.  
  2770.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2771.                             weight_vec, offset_vec, rnd_vec,
  2772.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2773.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2774.  
  2775.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2776.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2777.         ST_SW2(dst0_r, dst1_r, dst, 16);
  2778.         dst += dst_stride;
  2779.  
  2780.         LD_SB2(src, 16, src0, src1);
  2781.         src2 = LD_SB(src + 24);
  2782.         src += src_stride;
  2783.  
  2784.         XORI_B3_128_SB(src0, src1, src2);
  2785.  
  2786.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2787.         dst0 = const_vec;
  2788.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2789.  
  2790.         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
  2791.         dst1 = const_vec;
  2792.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2793.  
  2794.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2795.         dst2 = const_vec;
  2796.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2797.  
  2798.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2799.         dst3 = const_vec;
  2800.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2801.  
  2802.         HEVC_UNIW_RND_CLIP4(dst0, dst1, dst2, dst3,
  2803.                             weight_vec, offset_vec, rnd_vec,
  2804.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2805.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2806.  
  2807.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2808.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2809.         ST_SW2(dst0_r, dst1_r, dst, 16);
  2810.         dst += dst_stride;
  2811.     }
  2812. }
  2813.  
  2814. static void hevc_vt_uniwgt_4t_4x2_msa(uint8_t *src,
  2815.                                       int32_t src_stride,
  2816.                                       uint8_t *dst,
  2817.                                       int32_t dst_stride,
  2818.                                       const int8_t *filter,
  2819.                                       int32_t height,
  2820.                                       int32_t weight,
  2821.                                       int32_t offset,
  2822.                                       int32_t rnd_val)
  2823. {
  2824.     v16i8 src0, src1, src2, src3, src4;
  2825.     v16i8 src10_r, src32_r, src21_r, src43_r;
  2826.     v16i8 src2110, src4332;
  2827.     v8i16 dst10;
  2828.     v4i32 dst0_r, dst0_l;
  2829.     v8i16 filt0, filt1;
  2830.     v8i16 filter_vec, const_vec;
  2831.     v4i32 weight_vec, offset_vec, rnd_vec;
  2832.  
  2833.     src -= src_stride;
  2834.  
  2835.     const_vec = __msa_ldi_h(128);
  2836.     const_vec <<= 6;
  2837.     weight = weight & 0x0000FFFF;
  2838.  
  2839.     weight_vec = __msa_fill_w(weight);
  2840.     offset_vec = __msa_fill_w(offset);
  2841.     rnd_vec = __msa_fill_w(rnd_val);
  2842.  
  2843.     filter_vec = LD_SH(filter);
  2844.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2845.  
  2846.     LD_SB3(src, src_stride, src0, src1, src2);
  2847.     src += (3 * src_stride);
  2848.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2849.     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
  2850.     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
  2851.     LD_SB2(src, src_stride, src3, src4);
  2852.     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2853.     src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_r, (v2i64) src32_r);
  2854.     src4332 = (v16i8) __msa_xori_b((v16u8) src4332, 128);
  2855.  
  2856.     dst10 = const_vec;
  2857.     DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
  2858.  
  2859.     ILVRL_H2_SW(dst10, dst10, dst0_r, dst0_l);
  2860.     DOTP_SH2_SW(dst0_r, dst0_l, weight_vec, weight_vec, dst0_r, dst0_l);
  2861.     SRAR_W2_SW(dst0_r, dst0_l, rnd_vec);
  2862.     ADD2(dst0_r, offset_vec, dst0_l, offset_vec, dst0_r, dst0_l);
  2863.     dst0_r = CLIP_SW_0_255(dst0_r);
  2864.     dst0_l = CLIP_SW_0_255(dst0_l);
  2865.  
  2866.     HEVC_PCK_SW_SB2(dst0_l, dst0_r, dst0_r);
  2867.     ST4x2_UB(dst0_r, dst, dst_stride);
  2868. }
  2869.  
  2870. static void hevc_vt_uniwgt_4t_4x4_msa(uint8_t *src,
  2871.                                       int32_t src_stride,
  2872.                                       uint8_t *dst,
  2873.                                       int32_t dst_stride,
  2874.                                       const int8_t *filter,
  2875.                                       int32_t height,
  2876.                                       int32_t weight,
  2877.                                       int32_t offset,
  2878.                                       int32_t rnd_val)
  2879. {
  2880.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  2881.     v16i8 src10_r, src32_r, src54_r, src21_r, src43_r, src65_r;
  2882.     v16i8 src2110, src4332, src6554;
  2883.     v8i16 dst10, dst32;
  2884.     v4i32 dst0_r, dst1_r, dst0_l, dst1_l;
  2885.     v8i16 filt0, filt1;
  2886.     v8i16 filter_vec, const_vec;
  2887.     v4i32 weight_vec, offset_vec, rnd_vec;
  2888.  
  2889.     src -= src_stride;
  2890.  
  2891.     const_vec = __msa_ldi_h(128);
  2892.     const_vec <<= 6;
  2893.     weight = weight & 0x0000FFFF;
  2894.  
  2895.     weight_vec = __msa_fill_w(weight);
  2896.     offset_vec = __msa_fill_w(offset);
  2897.     rnd_vec = __msa_fill_w(rnd_val);
  2898.  
  2899.     filter_vec = LD_SH(filter);
  2900.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2901.  
  2902.     LD_SB3(src, src_stride, src0, src1, src2);
  2903.     src += (3 * src_stride);
  2904.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2905.     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
  2906.     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
  2907.  
  2908.     LD_SB4(src, src_stride, src3, src4, src5, src6);
  2909.     ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
  2910.                src32_r, src43_r, src54_r, src65_r);
  2911.     ILVR_D2_SB(src43_r, src32_r, src65_r, src54_r, src4332, src6554);
  2912.     XORI_B2_128_SB(src4332, src6554);
  2913.  
  2914.     dst10 = const_vec;
  2915.     DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
  2916.     dst32 = const_vec;
  2917.     DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
  2918.     HEVC_UNIW_RND_CLIP2(dst10, dst32, weight_vec, offset_vec, rnd_vec,
  2919.                         dst0_r, dst1_r, dst0_l, dst1_l);
  2920.  
  2921.     HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  2922.     ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
  2923.     dst += (4 * dst_stride);
  2924. }
  2925.  
  2926. static void hevc_vt_uniwgt_4t_4x8multiple_msa(uint8_t *src,
  2927.                                               int32_t src_stride,
  2928.                                               uint8_t *dst,
  2929.                                               int32_t dst_stride,
  2930.                                               const int8_t *filter,
  2931.                                               int32_t height,
  2932.                                               int32_t weight,
  2933.                                               int32_t offset,
  2934.                                               int32_t rnd_val)
  2935. {
  2936.     int32_t loop_cnt;
  2937.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
  2938.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  2939.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  2940.     v16i8 src2110, src4332, src6554, src8776;
  2941.     v8i16 dst10, dst32, dst54, dst76;
  2942.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  2943.     v8i16 filt0, filt1;
  2944.     v8i16 filter_vec, const_vec;
  2945.     v4i32 weight_vec, offset_vec, rnd_vec;
  2946.  
  2947.     src -= src_stride;
  2948.  
  2949.     const_vec = __msa_ldi_h(128);
  2950.     const_vec <<= 6;
  2951.     weight = weight & 0x0000FFFF;
  2952.  
  2953.     weight_vec = __msa_fill_w(weight);
  2954.     offset_vec = __msa_fill_w(offset);
  2955.     rnd_vec = __msa_fill_w(rnd_val);
  2956.  
  2957.     filter_vec = LD_SH(filter);
  2958.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2959.  
  2960.     LD_SB3(src, src_stride, src0, src1, src2);
  2961.     src += (3 * src_stride);
  2962.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2963.     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
  2964.     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
  2965.  
  2966.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  2967.         LD_SB6(src, src_stride, src3, src4, src5, src6, src7, src8);
  2968.         src += (6 * src_stride);
  2969.         ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
  2970.                    src32_r, src43_r, src54_r, src65_r);
  2971.         ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
  2972.         ILVR_D3_SB(src43_r, src32_r, src65_r, src54_r, src87_r, src76_r,
  2973.                    src4332, src6554, src8776);
  2974.         XORI_B3_128_SB(src4332, src6554, src8776);
  2975.  
  2976.         dst10 = const_vec;
  2977.         DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
  2978.         dst32 = const_vec;
  2979.         DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
  2980.         dst54 = const_vec;
  2981.         DPADD_SB2_SH(src6554, src8776, filt0, filt1, dst54, dst54);
  2982.  
  2983.         LD_SB2(src, src_stride, src9, src2);
  2984.         src += (2 * src_stride);
  2985.         ILVR_B2_SB(src9, src8, src2, src9, src98_r, src109_r);
  2986.         src2110 = (v16i8) __msa_ilvr_d((v2i64) src109_r, (v2i64) src98_r);
  2987.         src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
  2988.  
  2989.         dst76 = const_vec;
  2990.         DPADD_SB2_SH(src8776, src2110, filt0, filt1, dst76, dst76);
  2991.         HEVC_UNIW_RND_CLIP4(dst10, dst32, dst54, dst76,
  2992.                             weight_vec, offset_vec, rnd_vec,
  2993.                             dst0_r, dst1_r, dst2_r, dst3_r,
  2994.                             dst0_l, dst1_l, dst2_l, dst3_l);
  2995.  
  2996.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  2997.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  2998.         ST4x8_UB(dst0_r, dst1_r, dst, dst_stride);
  2999.         dst += (8 * dst_stride);
  3000.     }
  3001. }
  3002.  
  3003. static void hevc_vt_uniwgt_4t_4w_msa(uint8_t *src,
  3004.                                      int32_t src_stride,
  3005.                                      uint8_t *dst,
  3006.                                      int32_t dst_stride,
  3007.                                      const int8_t *filter,
  3008.                                      int32_t height,
  3009.                                      int32_t weight,
  3010.                                      int32_t offset,
  3011.                                      int32_t rnd_val)
  3012. {
  3013.     if (2 == height) {
  3014.         hevc_vt_uniwgt_4t_4x2_msa(src, src_stride, dst, dst_stride,
  3015.                                   filter, height, weight, offset, rnd_val);
  3016.     } else if (4 == height) {
  3017.         hevc_vt_uniwgt_4t_4x4_msa(src, src_stride, dst, dst_stride,
  3018.                                   filter, height, weight, offset, rnd_val);
  3019.     } else if (0 == (height % 8)) {
  3020.         hevc_vt_uniwgt_4t_4x8multiple_msa(src, src_stride, dst, dst_stride,
  3021.                                           filter, height, weight, offset,
  3022.                                           rnd_val);
  3023.     }
  3024. }
  3025.  
  3026. static void hevc_vt_uniwgt_4t_6w_msa(uint8_t *src,
  3027.                                      int32_t src_stride,
  3028.                                      uint8_t *dst,
  3029.                                      int32_t dst_stride,
  3030.                                      const int8_t *filter,
  3031.                                      int32_t height,
  3032.                                      int32_t weight,
  3033.                                      int32_t offset,
  3034.                                      int32_t rnd_val)
  3035. {
  3036.     int32_t loop_cnt;
  3037.     v16i8 src0, src1, src2, src3, src4;
  3038.     v16i8 src10_r, src32_r, src21_r, src43_r;
  3039.     v8i16 tmp0, tmp1, tmp2, tmp3;
  3040.     v8i16 filt0, filt1;
  3041.     v8i16 filter_vec, const_vec;
  3042.     v4i32 weight_vec, offset_vec, rnd_vec;
  3043.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  3044.  
  3045.     src -= src_stride;
  3046.  
  3047.     const_vec = __msa_ldi_h(128);
  3048.     const_vec <<= 6;
  3049.     weight = weight & 0x0000FFFF;
  3050.  
  3051.     weight_vec = __msa_fill_w(weight);
  3052.     offset_vec = __msa_fill_w(offset);
  3053.     rnd_vec = __msa_fill_w(rnd_val);
  3054.  
  3055.     filter_vec = LD_SH(filter);
  3056.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3057.  
  3058.     LD_SB3(src, src_stride, src0, src1, src2);
  3059.     src += (3 * src_stride);
  3060.     XORI_B3_128_SB(src0, src1, src2);
  3061.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  3062.  
  3063.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  3064.         LD_SB2(src, src_stride, src3, src4);
  3065.         src += (2 * src_stride);
  3066.         XORI_B2_128_SB(src3, src4);
  3067.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  3068.  
  3069.         tmp0 = const_vec;
  3070.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, tmp0, tmp0);
  3071.         tmp1 = const_vec;
  3072.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, tmp1, tmp1);
  3073.  
  3074.         LD_SB2(src, src_stride, src1, src2);
  3075.         src += (2 * src_stride);
  3076.         XORI_B2_128_SB(src1, src2);
  3077.         ILVR_B2_SB(src1, src4, src2, src1, src10_r, src21_r);
  3078.  
  3079.         tmp2 = const_vec;
  3080.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, tmp2, tmp2);
  3081.         tmp3 = const_vec;
  3082.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, tmp3, tmp3);
  3083.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  3084.                             weight_vec, offset_vec, rnd_vec,
  3085.                             dst0_r, dst1_r, dst2_r, dst3_r,
  3086.                             dst0_l, dst1_l, dst2_l, dst3_l);
  3087.  
  3088.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  3089.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  3090.  
  3091.         ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
  3092.         dst += (4 * dst_stride);
  3093.     }
  3094. }
  3095.  
  3096. static void hevc_vt_uniwgt_4t_8x2_msa(uint8_t *src,
  3097.                                       int32_t src_stride,
  3098.                                       uint8_t *dst,
  3099.                                       int32_t dst_stride,
  3100.                                       const int8_t *filter,
  3101.                                       int32_t height,
  3102.                                       int32_t weight,
  3103.                                       int32_t offset,
  3104.                                       int32_t rnd_val)
  3105. {
  3106.     v16i8 src0, src1, src2, src3, src4;
  3107.     v16i8 src10_r, src32_r, src21_r, src43_r;
  3108.     v8i16 tmp0, tmp1;
  3109.     v8i16 filt0, filt1;
  3110.     v8i16 filter_vec, const_vec;
  3111.     v4i32 weight_vec, offset_vec, rnd_vec;
  3112.     v4i32 dst0_r, dst1_r, dst0_l, dst1_l;
  3113.  
  3114.     src -= src_stride;
  3115.  
  3116.     const_vec = __msa_ldi_h(128);
  3117.     const_vec <<= 6;
  3118.     weight = weight & 0x0000FFFF;
  3119.  
  3120.     weight_vec = __msa_fill_w(weight);
  3121.     offset_vec = __msa_fill_w(offset);
  3122.     rnd_vec = __msa_fill_w(rnd_val);
  3123.  
  3124.     filter_vec = LD_SH(filter);
  3125.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3126.  
  3127.     LD_SB3(src, src_stride, src0, src1, src2);
  3128.     src += (3 * src_stride);
  3129.     XORI_B3_128_SB(src0, src1, src2);
  3130.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  3131.     LD_SB2(src, src_stride, src3, src4);
  3132.     XORI_B2_128_SB(src3, src4);
  3133.     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  3134.  
  3135.     tmp0 = const_vec;
  3136.     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, tmp0, tmp0);
  3137.     tmp1 = const_vec;
  3138.     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, tmp1, tmp1);
  3139.     HEVC_UNIW_RND_CLIP2(tmp0, tmp1, weight_vec, offset_vec, rnd_vec,
  3140.                         dst0_r, dst1_r, dst0_l, dst1_l);
  3141.  
  3142.     HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  3143.     ST8x2_UB(dst0_r, dst, dst_stride);
  3144. }
  3145.  
  3146. static void hevc_vt_uniwgt_4t_8x6_msa(uint8_t *src,
  3147.                                       int32_t src_stride,
  3148.                                       uint8_t *dst,
  3149.                                       int32_t dst_stride,
  3150.                                       const int8_t *filter,
  3151.                                       int32_t height,
  3152.                                       int32_t weight,
  3153.                                       int32_t offset,
  3154.                                       int32_t rnd_val)
  3155. {
  3156.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  3157.     v16i8 src10_r, src32_r, src54_r, src76_r;
  3158.     v16i8 src21_r, src43_r, src65_r, src87_r;
  3159.     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
  3160.     v8i16 filt0, filt1;
  3161.     v8i16 filter_vec, const_vec;
  3162.     v4i32 weight_vec, offset_vec, rnd_vec;
  3163.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  3164.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  3165.  
  3166.     src -= src_stride;
  3167.  
  3168.     const_vec = __msa_ldi_h(128);
  3169.     const_vec <<= 6;
  3170.     weight = weight & 0x0000FFFF;
  3171.  
  3172.     weight_vec = __msa_fill_w(weight);
  3173.     offset_vec = __msa_fill_w(offset);
  3174.     rnd_vec = __msa_fill_w(rnd_val);
  3175.  
  3176.     filter_vec = LD_SH(filter);
  3177.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3178.  
  3179.     LD_SB3(src, src_stride, src0, src1, src2);
  3180.     src += (3 * src_stride);
  3181.     XORI_B3_128_SB(src0, src1, src2);
  3182.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  3183.  
  3184.     LD_SB6(src, src_stride, src3, src4, src5, src6, src7, src8);
  3185.     XORI_B6_128_SB(src3, src4, src5, src6, src7, src8);
  3186.     ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
  3187.                src32_r, src43_r, src54_r, src65_r);
  3188.     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
  3189.  
  3190.     tmp0 = const_vec;
  3191.     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, tmp0, tmp0);
  3192.     tmp1 = const_vec;
  3193.     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, tmp1, tmp1);
  3194.     tmp2 = const_vec;
  3195.     DPADD_SB2_SH(src32_r, src54_r, filt0, filt1, tmp2, tmp2);
  3196.     tmp3 = const_vec;
  3197.     DPADD_SB2_SH(src43_r, src65_r, filt0, filt1, tmp3, tmp3);
  3198.     tmp4 = const_vec;
  3199.     DPADD_SB2_SH(src54_r, src76_r, filt0, filt1, tmp4, tmp4);
  3200.     tmp5 = const_vec;
  3201.     DPADD_SB2_SH(src65_r, src87_r, filt0, filt1, tmp5, tmp5);
  3202.     HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  3203.                         weight_vec, offset_vec, rnd_vec,
  3204.                         dst0_r, dst1_r, dst2_r, dst3_r,
  3205.                         dst0_l, dst1_l, dst2_l, dst3_l);
  3206.     HEVC_UNIW_RND_CLIP2(tmp4, tmp5, weight_vec, offset_vec, rnd_vec,
  3207.                         dst4_r, dst5_r, dst4_l, dst5_l);
  3208.  
  3209.     HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  3210.                      dst2_l, dst2_r, dst3_l, dst3_r,
  3211.                      dst4_l, dst4_r, dst5_l, dst5_r, dst0_r, dst1_r, dst2_r);
  3212.     ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  3213.     dst += (4 * dst_stride);
  3214.     ST8x2_UB(dst2_r, dst, dst_stride);
  3215. }
  3216.  
  3217. static void hevc_vt_uniwgt_4t_8x4multiple_msa(uint8_t *src,
  3218.                                               int32_t src_stride,
  3219.                                               uint8_t *dst,
  3220.                                               int32_t dst_stride,
  3221.                                               const int8_t *filter,
  3222.                                               int32_t height,
  3223.                                               int32_t weight,
  3224.                                               int32_t offset,
  3225.                                               int32_t rnd_val)
  3226. {
  3227.     int32_t loop_cnt;
  3228.     v16i8 src0, src1, src2, src3, src4;
  3229.     v16i8 src10_r, src32_r, src21_r, src43_r;
  3230.     v8i16 tmp0, tmp1, tmp2, tmp3;
  3231.     v8i16 filt0, filt1;
  3232.     v8i16 filter_vec, const_vec;
  3233.     v4i32 weight_vec, offset_vec, rnd_vec;
  3234.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  3235.  
  3236.     src -= src_stride;
  3237.  
  3238.     const_vec = __msa_ldi_h(128);
  3239.     const_vec <<= 6;
  3240.     weight = weight & 0x0000FFFF;
  3241.  
  3242.     weight_vec = __msa_fill_w(weight);
  3243.     offset_vec = __msa_fill_w(offset);
  3244.     rnd_vec = __msa_fill_w(rnd_val);
  3245.  
  3246.     filter_vec = LD_SH(filter);
  3247.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3248.  
  3249.     LD_SB3(src, src_stride, src0, src1, src2);
  3250.     src += (3 * src_stride);
  3251.     XORI_B3_128_SB(src0, src1, src2);
  3252.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  3253.  
  3254.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  3255.         LD_SB2(src, src_stride, src3, src4);
  3256.         src += (2 * src_stride);
  3257.         XORI_B2_128_SB(src3, src4);
  3258.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  3259.  
  3260.         tmp0 = const_vec;
  3261.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, tmp0, tmp0);
  3262.         tmp1 = const_vec;
  3263.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, tmp1, tmp1);
  3264.  
  3265.         LD_SB2(src, src_stride, src1, src2);
  3266.         src += (2 * src_stride);
  3267.         XORI_B2_128_SB(src1, src2);
  3268.         ILVR_B2_SB(src1, src4, src2, src1, src10_r, src21_r);
  3269.  
  3270.         tmp2 = const_vec;
  3271.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, tmp2, tmp2);
  3272.         tmp3 = const_vec;
  3273.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, tmp3, tmp3);
  3274.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  3275.                             weight_vec, offset_vec, rnd_vec,
  3276.                             dst0_r, dst1_r, dst2_r, dst3_r,
  3277.                             dst0_l, dst1_l, dst2_l, dst3_l);
  3278.  
  3279.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  3280.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  3281.         ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  3282.         dst += (4 * dst_stride);
  3283.     }
  3284. }
  3285.  
  3286. static void hevc_vt_uniwgt_4t_8w_msa(uint8_t *src,
  3287.                                      int32_t src_stride,
  3288.                                      uint8_t *dst,
  3289.                                      int32_t dst_stride,
  3290.                                      const int8_t *filter,
  3291.                                      int32_t height,
  3292.                                      int32_t weight,
  3293.                                      int32_t offset,
  3294.                                      int32_t rnd_val)
  3295. {
  3296.     if (2 == height) {
  3297.         hevc_vt_uniwgt_4t_8x2_msa(src, src_stride, dst, dst_stride,
  3298.                                   filter, height, weight, offset, rnd_val);
  3299.     } else if (6 == height) {
  3300.         hevc_vt_uniwgt_4t_8x6_msa(src, src_stride, dst, dst_stride,
  3301.                                   filter, height, weight, offset, rnd_val);
  3302.     } else {
  3303.         hevc_vt_uniwgt_4t_8x4multiple_msa(src, src_stride, dst, dst_stride,
  3304.                                           filter, height, weight, offset,
  3305.                                           rnd_val);
  3306.     }
  3307. }
  3308.  
  3309. static void hevc_vt_uniwgt_4t_12w_msa(uint8_t *src,
  3310.                                       int32_t src_stride,
  3311.                                       uint8_t *dst,
  3312.                                       int32_t dst_stride,
  3313.                                       const int8_t *filter,
  3314.                                       int32_t height,
  3315.                                       int32_t weight,
  3316.                                       int32_t offset,
  3317.                                       int32_t rnd_val)
  3318. {
  3319.     int32_t loop_cnt;
  3320.     v16i8 src0, src1, src2, src3, src4, src5;
  3321.     v16i8 src10_r, src32_r, src21_r, src43_r;
  3322.     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
  3323.     v16i8 src10_l, src32_l, src54_l, src21_l, src43_l, src65_l;
  3324.     v16i8 src2110, src4332;
  3325.     v8i16 filt0, filt1;
  3326.     v8i16 filter_vec, const_vec;
  3327.     v4i32 weight_vec, offset_vec, rnd_vec;
  3328.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  3329.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  3330.  
  3331.     src -= (1 * src_stride);
  3332.  
  3333.     const_vec = __msa_ldi_h(128);
  3334.     const_vec <<= 6;
  3335.     weight = weight & 0x0000FFFF;
  3336.  
  3337.     weight_vec = __msa_fill_w(weight);
  3338.     offset_vec = __msa_fill_w(offset);
  3339.     rnd_vec = __msa_fill_w(rnd_val);
  3340.  
  3341.     filter_vec = LD_SH(filter);
  3342.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3343.  
  3344.     LD_SB3(src, src_stride, src0, src1, src2);
  3345.     src += (3 * src_stride);
  3346.     XORI_B3_128_SB(src0, src1, src2);
  3347.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  3348.     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
  3349.     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_l, (v2i64) src10_l);
  3350.  
  3351.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  3352.         LD_SB2(src, src_stride, src3, src4);
  3353.         src += (2 * src_stride);
  3354.         XORI_B2_128_SB(src3, src4);
  3355.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  3356.         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
  3357.         src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_l, (v2i64) src32_l);
  3358.  
  3359.         tmp0 = const_vec;
  3360.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, tmp0, tmp0);
  3361.         tmp1 = const_vec;
  3362.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, tmp1, tmp1);
  3363.         tmp4 = const_vec;
  3364.         DPADD_SB2_SH(src2110, src4332, filt0, filt1, tmp4, tmp4);
  3365.  
  3366.         LD_SB2(src, src_stride, src5, src2);
  3367.         src += (2 * src_stride);
  3368.         XORI_B2_128_SB(src5, src2);
  3369.         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
  3370.         ILVL_B2_SB(src5, src4, src2, src5, src54_l, src65_l);
  3371.         src2110 = (v16i8) __msa_ilvr_d((v2i64) src65_l, (v2i64) src54_l);
  3372.  
  3373.         tmp2 = const_vec;
  3374.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, tmp2, tmp2);
  3375.         tmp3 = const_vec;
  3376.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, tmp3, tmp3);
  3377.         tmp5 = const_vec;
  3378.         DPADD_SB2_SH(src4332, src2110, filt0, filt1, tmp5, tmp5);
  3379.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  3380.                             weight_vec, offset_vec, rnd_vec,
  3381.                             dst0_r, dst1_r, dst2_r, dst3_r,
  3382.                             dst0_l, dst1_l, dst2_l, dst3_l);
  3383.         HEVC_UNIW_RND_CLIP2(tmp4, tmp5, weight_vec, offset_vec, rnd_vec,
  3384.                             dst4_r, dst5_r, dst4_l, dst5_l);
  3385.  
  3386.         HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  3387.                          dst2_l, dst2_r, dst3_l, dst3_r,
  3388.                          dst4_l, dst4_r, dst5_l, dst5_r,
  3389.                          dst0_r, dst1_r, dst2_r);
  3390.         ST12x4_UB(dst0_r, dst1_r, dst2_r, dst, dst_stride);
  3391.         dst += (4 * dst_stride);
  3392.     }
  3393. }
  3394.  
  3395. static void hevc_vt_uniwgt_4t_16w_msa(uint8_t *src,
  3396.                                       int32_t src_stride,
  3397.                                       uint8_t *dst,
  3398.                                       int32_t dst_stride,
  3399.                                       const int8_t *filter,
  3400.                                       int32_t height,
  3401.                                       int32_t weight,
  3402.                                       int32_t offset,
  3403.                                       int32_t rnd_val)
  3404. {
  3405.     int32_t loop_cnt;
  3406.     v16i8 src0, src1, src2, src3, src4, src5;
  3407.     v16i8 src10_r, src32_r, src21_r, src43_r;
  3408.     v16i8 src10_l, src32_l, src21_l, src43_l;
  3409.     v8i16 tmp0, tmp1, tmp2, tmp3;
  3410.     v8i16 filt0, filt1;
  3411.     v8i16 filter_vec, const_vec;
  3412.     v4i32 weight_vec, offset_vec, rnd_vec;
  3413.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst0_l, dst1_l, dst2_l, dst3_l;
  3414.  
  3415.     src -= src_stride;
  3416.  
  3417.     const_vec = __msa_ldi_h(128);
  3418.     const_vec <<= 6;
  3419.     weight = weight & 0x0000FFFF;
  3420.  
  3421.     weight_vec = __msa_fill_w(weight);
  3422.     offset_vec = __msa_fill_w(offset);
  3423.     rnd_vec = __msa_fill_w(rnd_val);
  3424.  
  3425.     filter_vec = LD_SH(filter);
  3426.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3427.  
  3428.     LD_SB3(src, src_stride, src0, src1, src2);
  3429.     src += (3 * src_stride);
  3430.     XORI_B3_128_SB(src0, src1, src2);
  3431.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  3432.     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
  3433.  
  3434.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  3435.         LD_SB2(src, src_stride, src3, src4);
  3436.         src += (2 * src_stride);
  3437.         XORI_B2_128_SB(src3, src4);
  3438.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  3439.         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
  3440.  
  3441.         tmp0 = const_vec;
  3442.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, tmp0, tmp0);
  3443.         tmp1 = const_vec;
  3444.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, tmp1, tmp1);
  3445.         tmp2 = const_vec;
  3446.         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, tmp2, tmp2);
  3447.         tmp3 = const_vec;
  3448.         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, tmp3, tmp3);
  3449.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  3450.                             weight_vec, offset_vec, rnd_vec,
  3451.                             dst0_r, dst1_r, dst2_r, dst3_r,
  3452.                             dst0_l, dst1_l, dst2_l, dst3_l);
  3453.  
  3454.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
  3455.                         dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
  3456.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  3457.         dst += (2 * dst_stride);
  3458.  
  3459.         LD_SB2(src, src_stride, src5, src2);
  3460.         src += (2 * src_stride);
  3461.         XORI_B2_128_SB(src5, src2);
  3462.         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
  3463.         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
  3464.  
  3465.         tmp0 = const_vec;
  3466.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, tmp0, tmp0);
  3467.         tmp1 = const_vec;
  3468.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, tmp1, tmp1);
  3469.         tmp2 = const_vec;
  3470.         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, tmp2, tmp2);
  3471.         tmp3 = const_vec;
  3472.         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, tmp3, tmp3);
  3473.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp2, tmp3,
  3474.                             weight_vec, offset_vec, rnd_vec,
  3475.                             dst0_r, dst1_r, dst2_r, dst3_r,
  3476.                             dst0_l, dst1_l, dst2_l, dst3_l);
  3477.  
  3478.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
  3479.                         dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
  3480.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  3481.         dst += (2 * dst_stride);
  3482.     }
  3483. }
  3484.  
  3485. static void hevc_vt_uniwgt_4t_24w_msa(uint8_t *src,
  3486.                                       int32_t src_stride,
  3487.                                       uint8_t *dst,
  3488.                                       int32_t dst_stride,
  3489.                                       const int8_t *filter,
  3490.                                       int32_t height,
  3491.                                       int32_t weight,
  3492.                                       int32_t offset,
  3493.                                       int32_t rnd_val)
  3494. {
  3495.     uint32_t loop_cnt;
  3496.     v16i8 src0, src1, src2, src3, src4, src5;
  3497.     v16i8 src6, src7, src8, src9, src10, src11;
  3498.     v16i8 src10_r, src32_r, src76_r, src98_r;
  3499.     v16i8 src21_r, src43_r, src87_r, src109_r;
  3500.     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
  3501.     v16i8 src10_l, src32_l, src21_l, src43_l;
  3502.     v8i16 filt0, filt1;
  3503.     v8i16 filter_vec, const_vec;
  3504.     v4i32 weight_vec, offset_vec, rnd_vec;
  3505.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
  3506.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l;
  3507.  
  3508.     src -= src_stride;
  3509.  
  3510.     const_vec = __msa_ldi_h(128);
  3511.     const_vec <<= 6;
  3512.     weight = weight & 0x0000FFFF;
  3513.  
  3514.     weight_vec = __msa_fill_w(weight);
  3515.     offset_vec = __msa_fill_w(offset);
  3516.     rnd_vec = __msa_fill_w(rnd_val);
  3517.  
  3518.     filter_vec = LD_SH(filter);
  3519.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3520.  
  3521.     LD_SB3(src, src_stride, src0, src1, src2);
  3522.     XORI_B3_128_SB(src0, src1, src2);
  3523.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  3524.     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
  3525.  
  3526.     LD_SB3(src + 16, src_stride, src6, src7, src8);
  3527.     src += (3 * src_stride);
  3528.     XORI_B3_128_SB(src6, src7, src8);
  3529.     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
  3530.  
  3531.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  3532.         LD_SB2(src, src_stride, src3, src4);
  3533.         XORI_B2_128_SB(src3, src4);
  3534.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  3535.         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
  3536.         LD_SB2(src + 16, src_stride, src9, src10);
  3537.         src += (2 * src_stride);
  3538.         XORI_B2_128_SB(src9, src10);
  3539.         ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
  3540.  
  3541.         tmp0 = const_vec;
  3542.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, tmp0, tmp0);
  3543.         tmp4 = const_vec;
  3544.         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, tmp4, tmp4);
  3545.         tmp1 = const_vec;
  3546.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, tmp1, tmp1);
  3547.         tmp5 = const_vec;
  3548.         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, tmp5, tmp5);
  3549.         tmp2 = const_vec;
  3550.         DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, tmp2, tmp2);
  3551.         tmp3 = const_vec;
  3552.         DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, tmp3, tmp3);
  3553.  
  3554.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp4, tmp5,
  3555.                             weight_vec, offset_vec, rnd_vec,
  3556.                             dst0_r, dst1_r, dst2_r, dst3_r,
  3557.                             dst0_l, dst1_l, dst2_l, dst3_l);
  3558.         HEVC_UNIW_RND_CLIP2(tmp2, tmp3, weight_vec, offset_vec, rnd_vec,
  3559.                             dst4_r, dst5_r, dst4_l, dst5_l);
  3560.  
  3561.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
  3562.                         dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
  3563.         HEVC_PCK_SW_SB4(dst4_l, dst4_r, dst5_l, dst5_r, dst4_r);
  3564.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  3565.         ST8x2_UB(dst4_r, dst + 16, dst_stride);
  3566.         dst += (2 * dst_stride);
  3567.  
  3568.         LD_SB2(src, src_stride, src5, src2);
  3569.         XORI_B2_128_SB(src5, src2);
  3570.         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
  3571.         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
  3572.         LD_SB2(src + 16, src_stride, src11, src8);
  3573.         src += (2 * src_stride);
  3574.         XORI_B2_128_SB(src11, src8);
  3575.         ILVR_B2_SB(src11, src10, src8, src11, src76_r, src87_r);
  3576.  
  3577.         tmp0 = const_vec;
  3578.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, tmp0, tmp0);
  3579.         tmp4 = const_vec;
  3580.         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, tmp4, tmp4);
  3581.         tmp1 = const_vec;
  3582.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, tmp1, tmp1);
  3583.         tmp5 = const_vec;
  3584.         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, tmp5, tmp5);
  3585.         tmp2 = const_vec;
  3586.         DPADD_SB2_SH(src98_r, src76_r, filt0, filt1, tmp2, tmp2);
  3587.         tmp3 = const_vec;
  3588.         DPADD_SB2_SH(src109_r, src87_r, filt0, filt1, tmp3, tmp3);
  3589.  
  3590.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp4, tmp5,
  3591.                             weight_vec, offset_vec, rnd_vec,
  3592.                             dst0_r, dst1_r, dst2_r, dst3_r,
  3593.                             dst0_l, dst1_l, dst2_l, dst3_l);
  3594.         HEVC_UNIW_RND_CLIP2(tmp2, tmp3, weight_vec, offset_vec, rnd_vec,
  3595.                             dst4_r, dst5_r, dst4_l, dst5_l);
  3596.  
  3597.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
  3598.                         dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
  3599.         HEVC_PCK_SW_SB4(dst4_l, dst4_r, dst5_l, dst5_r, dst4_r);
  3600.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  3601.         ST8x2_UB(dst4_r, dst + 16, dst_stride);
  3602.         dst += (2 * dst_stride);
  3603.     }
  3604. }
  3605.  
  3606. static void hevc_vt_uniwgt_4t_32w_msa(uint8_t *src,
  3607.                                       int32_t src_stride,
  3608.                                       uint8_t *dst,
  3609.                                       int32_t dst_stride,
  3610.                                       const int8_t *filter,
  3611.                                       int32_t height,
  3612.                                       int32_t weight,
  3613.                                       int32_t offset,
  3614.                                       int32_t rnd_val)
  3615. {
  3616.     int32_t loop_cnt;
  3617.     uint8_t *dst_tmp = dst + 16;
  3618.     v16i8 src0, src1, src2, src3, src4, src6, src7, src8, src9, src10;
  3619.     v16i8 src10_r, src32_r, src76_r, src98_r;
  3620.     v16i8 src21_r, src43_r, src87_r, src109_r;
  3621.     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
  3622.     v16i8 src10_l, src32_l, src76_l, src98_l;
  3623.     v16i8 src21_l, src43_l, src87_l, src109_l;
  3624.     v8i16 filt0, filt1;
  3625.     v8i16 filter_vec, const_vec;
  3626.     v4i32 weight_vec, offset_vec, rnd_vec;
  3627.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r, dst6_r, dst7_r;
  3628.     v4i32 dst0_l, dst1_l, dst2_l, dst3_l, dst4_l, dst5_l, dst6_l, dst7_l;
  3629.  
  3630.     src -= src_stride;
  3631.  
  3632.     const_vec = __msa_ldi_h(128);
  3633.     const_vec <<= 6;
  3634.     weight = weight & 0x0000FFFF;
  3635.  
  3636.     weight_vec = __msa_fill_w(weight);
  3637.     offset_vec = __msa_fill_w(offset);
  3638.     rnd_vec = __msa_fill_w(rnd_val);
  3639.  
  3640.     filter_vec = LD_SH(filter);
  3641.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3642.  
  3643.     LD_SB3(src, src_stride, src0, src1, src2);
  3644.     XORI_B3_128_SB(src0, src1, src2);
  3645.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  3646.     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
  3647.  
  3648.     LD_SB3(src + 16, src_stride, src6, src7, src8);
  3649.     src += (3 * src_stride);
  3650.     XORI_B3_128_SB(src6, src7, src8);
  3651.     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
  3652.     ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
  3653.  
  3654.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  3655.         LD_SB2(src, src_stride, src3, src4);
  3656.         XORI_B2_128_SB(src3, src4);
  3657.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  3658.         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
  3659.  
  3660.         tmp0 = const_vec;
  3661.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, tmp0, tmp0);
  3662.         tmp4 = const_vec;
  3663.         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, tmp4, tmp4);
  3664.         tmp1 = const_vec;
  3665.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, tmp1, tmp1);
  3666.         tmp5 = const_vec;
  3667.         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, tmp5, tmp5);
  3668.  
  3669.         HEVC_UNIW_RND_CLIP4(tmp0, tmp1, tmp4, tmp5,
  3670.                             weight_vec, offset_vec, rnd_vec,
  3671.                             dst0_r, dst1_r, dst2_r, dst3_r,
  3672.                             dst0_l, dst1_l, dst2_l, dst3_l);
  3673.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst2_l, dst2_r,
  3674.                         dst1_l, dst1_r, dst3_l, dst3_r, dst0_r, dst1_r);
  3675.         ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  3676.         dst += (2 * dst_stride);
  3677.  
  3678.         src10_r = src32_r;
  3679.         src21_r = src43_r;
  3680.         src10_l = src32_l;
  3681.         src21_l = src43_l;
  3682.         src2 = src4;
  3683.  
  3684.         LD_SB2(src + 16, src_stride, src9, src10);
  3685.         src += (2 * src_stride);
  3686.         XORI_B2_128_SB(src9, src10);
  3687.         ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
  3688.         ILVL_B2_SB(src9, src8, src10, src9, src98_l, src109_l);
  3689.  
  3690.         tmp2 = const_vec;
  3691.         DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, tmp2, tmp2);
  3692.         tmp6 = const_vec;
  3693.         DPADD_SB2_SH(src76_l, src98_l, filt0, filt1, tmp6, tmp6);
  3694.         tmp3 = const_vec;
  3695.         DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, tmp3, tmp3);
  3696.         tmp7 = const_vec;
  3697.         DPADD_SB2_SH(src87_l, src109_l, filt0, filt1, tmp7, tmp7);
  3698.  
  3699.         HEVC_UNIW_RND_CLIP4(tmp2, tmp3, tmp6, tmp7,
  3700.                             weight_vec, offset_vec, rnd_vec,
  3701.                             dst4_r, dst5_r, dst6_r, dst7_r,
  3702.                             dst4_l, dst5_l, dst6_l, dst7_l);
  3703.  
  3704.         HEVC_PCK_SW_SB8(dst4_l, dst4_r, dst6_l, dst6_r,
  3705.                         dst5_l, dst5_r, dst7_l, dst7_r, dst4_r, dst5_r);
  3706.         ST_SW2(dst4_r, dst5_r, dst_tmp, dst_stride);
  3707.         dst_tmp += (2 * dst_stride);
  3708.  
  3709.         src76_r = src98_r;
  3710.         src87_r = src109_r;
  3711.         src76_l = src98_l;
  3712.         src87_l = src109_l;
  3713.         src8 = src10;
  3714.     }
  3715. }
  3716.  
  3717. static void hevc_hv_uniwgt_4t_4x2_msa(uint8_t *src,
  3718.                                       int32_t src_stride,
  3719.                                       uint8_t *dst,
  3720.                                       int32_t dst_stride,
  3721.                                       const int8_t *filter_x,
  3722.                                       const int8_t *filter_y,
  3723.                                       int32_t height,
  3724.                                       int32_t weight,
  3725.                                       int32_t offset,
  3726.                                       int32_t rnd_val)
  3727. {
  3728.     v16i8 src0, src1, src2, src3, src4;
  3729.     v8i16 filt0, filt1;
  3730.     v4i32 filt_h0, filt_h1;
  3731.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  3732.     v16i8 mask1;
  3733.     v8i16 filter_vec, const_vec;
  3734.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  3735.     v8i16 dst0, dst1, dst2, dst3, dst4;
  3736.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  3737.     v4i32 dst0_r, dst1_r;
  3738.     v4i32 weight_vec, offset_vec, rnd_vec;
  3739.  
  3740.     src -= (src_stride + 1);
  3741.  
  3742.     filter_vec = LD_SH(filter_x);
  3743.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3744.  
  3745.     filter_vec = LD_SH(filter_y);
  3746.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  3747.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  3748.  
  3749.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  3750.  
  3751.     mask1 = mask0 + 2;
  3752.  
  3753.     const_vec = __msa_ldi_h(128);
  3754.     const_vec <<= 6;
  3755.  
  3756.     weight_vec = __msa_fill_w(weight);
  3757.     offset_vec = __msa_fill_w(offset);
  3758.     rnd_vec = __msa_fill_w(rnd_val);
  3759.  
  3760.     LD_SB3(src, src_stride, src0, src1, src2);
  3761.     src += (3 * src_stride);
  3762.     XORI_B3_128_SB(src0, src1, src2);
  3763.  
  3764.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3765.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3766.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3767.     dst0 = const_vec;
  3768.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3769.     dst1 = const_vec;
  3770.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3771.     dst2 = const_vec;
  3772.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3773.  
  3774.     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
  3775.     LD_SB2(src, src_stride, src3, src4);
  3776.     XORI_B2_128_SB(src3, src4);
  3777.  
  3778.     /* row 3 */
  3779.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3780.     dst3 = const_vec;
  3781.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3782.  
  3783.     dst32_r = __msa_ilvr_h(dst3, dst2);
  3784.     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3785.     dst0_r >>= 6;
  3786.  
  3787.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3788.     dst4 = const_vec;
  3789.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3790.  
  3791.     dst43_r = __msa_ilvr_h(dst4, dst3);
  3792.     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3793.     dst1_r >>= 6;
  3794.  
  3795.     MUL2(dst0_r, weight_vec, dst1_r, weight_vec, dst0_r, dst1_r);
  3796.     SRAR_W2_SW(dst0_r, dst1_r, rnd_vec);
  3797.     ADD2(dst0_r, offset_vec, dst1_r, offset_vec, dst0_r, dst1_r);
  3798.     dst0_r = CLIP_SW_0_255(dst0_r);
  3799.     dst1_r = CLIP_SW_0_255(dst1_r);
  3800.  
  3801.     HEVC_PCK_SW_SB2(dst1_r, dst0_r, dst0_r);
  3802.     ST4x2_UB(dst0_r, dst, dst_stride);
  3803. }
  3804.  
  3805. static void hevc_hv_uniwgt_4t_4x4_msa(uint8_t *src,
  3806.                                       int32_t src_stride,
  3807.                                       uint8_t *dst,
  3808.                                       int32_t dst_stride,
  3809.                                       const int8_t *filter_x,
  3810.                                       const int8_t *filter_y,
  3811.                                       int32_t height,
  3812.                                       int32_t weight,
  3813.                                       int32_t offset,
  3814.                                       int32_t rnd_val)
  3815. {
  3816.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  3817.     v8i16 filt0, filt1;
  3818.     v4i32 filt_h0, filt_h1;
  3819.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  3820.     v16i8 mask1;
  3821.     v8i16 filter_vec, const_vec;
  3822.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  3823.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  3824.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r;
  3825.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  3826.     v4i32 weight_vec, offset_vec, rnd_vec;
  3827.  
  3828.     src -= (src_stride + 1);
  3829.  
  3830.     filter_vec = LD_SH(filter_x);
  3831.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3832.  
  3833.     filter_vec = LD_SH(filter_y);
  3834.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  3835.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  3836.  
  3837.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  3838.  
  3839.     mask1 = mask0 + 2;
  3840.  
  3841.     const_vec = __msa_ldi_h(128);
  3842.     const_vec <<= 6;
  3843.  
  3844.     weight_vec = __msa_fill_w(weight);
  3845.     offset_vec = __msa_fill_w(offset);
  3846.     rnd_vec = __msa_fill_w(rnd_val);
  3847.  
  3848.     LD_SB3(src, src_stride, src0, src1, src2);
  3849.     src += (3 * src_stride);
  3850.     XORI_B3_128_SB(src0, src1, src2);
  3851.  
  3852.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3853.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3854.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3855.     dst0 = const_vec;
  3856.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3857.     dst1 = const_vec;
  3858.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3859.     dst2 = const_vec;
  3860.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3861.  
  3862.     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
  3863.  
  3864.     LD_SB4(src, src_stride, src3, src4, src5, src6);
  3865.     XORI_B4_128_SB(src3, src4, src5, src6);
  3866.  
  3867.     /* row 3 */
  3868.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3869.     dst3 = const_vec;
  3870.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3871.     dst32_r = __msa_ilvr_h(dst3, dst2);
  3872.     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3873.     dst0_r >>= 6;
  3874.  
  3875.     /* row 4 */
  3876.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3877.     dst4 = const_vec;
  3878.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3879.     dst43_r = __msa_ilvr_h(dst4, dst3);
  3880.     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3881.     dst1_r >>= 6;
  3882.  
  3883.     /* row 5 */
  3884.     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  3885.     dst5 = const_vec;
  3886.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  3887.     dst10_r = __msa_ilvr_h(dst5, dst4);
  3888.     dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
  3889.     dst2_r >>= 6;
  3890.  
  3891.     /* row 6 */
  3892.     VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  3893.     dst2 = const_vec;
  3894.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  3895.     dst21_r = __msa_ilvr_h(dst2, dst5);
  3896.     dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
  3897.     dst3_r >>= 6;
  3898.  
  3899.     HEVC_HV_UNIW_RND_CLIP4(dst0_r, dst1_r, dst2_r, dst3_r,
  3900.                            weight_vec, offset_vec, rnd_vec,
  3901.                            dst0_r, dst1_r, dst2_r, dst3_r);
  3902.     HEVC_PCK_SW_SB4(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r);
  3903.     ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
  3904. }
  3905.  
  3906. static void hevc_hv_uniwgt_4t_4multx8mult_msa(uint8_t *src,
  3907.                                               int32_t src_stride,
  3908.                                               uint8_t *dst,
  3909.                                               int32_t dst_stride,
  3910.                                               const int8_t *filter_x,
  3911.                                               const int8_t *filter_y,
  3912.                                               int32_t height,
  3913.                                               int32_t weight,
  3914.                                               int32_t offset,
  3915.                                               int32_t rnd_val)
  3916. {
  3917.     uint32_t loop_cnt;
  3918.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
  3919.     v8i16 filt0, filt1;
  3920.     v4i32 filt_h0, filt_h1;
  3921.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  3922.     v16i8 mask1;
  3923.     v8i16 filter_vec, const_vec;
  3924.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  3925.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8, dst9;
  3926.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r, dst6_r, dst7_r;
  3927.     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
  3928.     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
  3929.     v4i32 weight_vec, offset_vec, rnd_vec;
  3930.  
  3931.     src -= (src_stride + 1);
  3932.  
  3933.     filter_vec = LD_SH(filter_x);
  3934.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3935.  
  3936.     filter_vec = LD_SH(filter_y);
  3937.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  3938.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  3939.  
  3940.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  3941.  
  3942.     mask1 = mask0 + 2;
  3943.  
  3944.     const_vec = __msa_ldi_h(128);
  3945.     const_vec <<= 6;
  3946.  
  3947.     weight_vec = __msa_fill_w(weight);
  3948.     offset_vec = __msa_fill_w(offset);
  3949.     rnd_vec = __msa_fill_w(rnd_val);
  3950.  
  3951.     LD_SB3(src, src_stride, src0, src1, src2);
  3952.     src += (3 * src_stride);
  3953.     XORI_B3_128_SB(src0, src1, src2);
  3954.  
  3955.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3956.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3957.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3958.     dst0 = const_vec;
  3959.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3960.     dst1 = const_vec;
  3961.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3962.     dst2 = const_vec;
  3963.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3964.     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
  3965.  
  3966.     for (loop_cnt = height >> 3; loop_cnt--;) {
  3967.         LD_SB8(src, src_stride,
  3968.                src3, src4, src5, src6, src7, src8, src9, src10);
  3969.         src += (8 * src_stride);
  3970.         XORI_B8_128_SB(src3, src4, src5, src6, src7, src8, src9, src10);
  3971.  
  3972.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3973.         dst3 = const_vec;
  3974.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3975.         dst32_r = __msa_ilvr_h(dst3, dst2);
  3976.         dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3977.         dst0_r >>= 6;
  3978.  
  3979.         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3980.         dst4 = const_vec;
  3981.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3982.         dst43_r = __msa_ilvr_h(dst4, dst3);
  3983.         dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3984.         dst1_r >>= 6;
  3985.  
  3986.         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  3987.         dst5 = const_vec;
  3988.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  3989.         dst54_r = __msa_ilvr_h(dst5, dst4);
  3990.         dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
  3991.         dst2_r >>= 6;
  3992.  
  3993.         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  3994.         dst6 = const_vec;
  3995.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
  3996.         dst65_r = __msa_ilvr_h(dst6, dst5);
  3997.         dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
  3998.         dst3_r >>= 6;
  3999.  
  4000.         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
  4001.         dst7 = const_vec;
  4002.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
  4003.         dst76_r = __msa_ilvr_h(dst7, dst6);
  4004.         dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
  4005.         dst4_r >>= 6;
  4006.  
  4007.         VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
  4008.         dst8 = const_vec;
  4009.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
  4010.         dst87_r = __msa_ilvr_h(dst8, dst7);
  4011.         dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
  4012.         dst5_r >>= 6;
  4013.  
  4014.         VSHF_B2_SB(src9, src9, src9, src9, mask0, mask1, vec0, vec1);
  4015.         dst9 = const_vec;
  4016.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst9, dst9);
  4017.         dst10_r = __msa_ilvr_h(dst9, dst8);
  4018.         dst6_r = HEVC_FILT_4TAP(dst76_r, dst10_r, filt_h0, filt_h1);
  4019.         dst6_r >>= 6;
  4020.  
  4021.         VSHF_B2_SB(src10, src10, src10, src10, mask0, mask1, vec0, vec1);
  4022.         dst2 = const_vec;
  4023.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  4024.         dst21_r = __msa_ilvr_h(dst2, dst9);
  4025.         dst7_r = HEVC_FILT_4TAP(dst87_r, dst21_r, filt_h0, filt_h1);
  4026.         dst7_r >>= 6;
  4027.  
  4028.         HEVC_HV_UNIW_RND_CLIP4(dst0_r, dst1_r, dst2_r, dst3_r,
  4029.                                weight_vec, offset_vec, rnd_vec,
  4030.                                dst0_r, dst1_r, dst2_r, dst3_r);
  4031.         HEVC_PCK_SW_SB4(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r);
  4032.         ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
  4033.         dst += (4 * dst_stride);
  4034.  
  4035.         HEVC_HV_UNIW_RND_CLIP4(dst4_r, dst5_r, dst6_r, dst7_r,
  4036.                                weight_vec, offset_vec, rnd_vec,
  4037.                                dst4_r, dst5_r, dst6_r, dst7_r);
  4038.         HEVC_PCK_SW_SB4(dst5_r, dst4_r, dst7_r, dst6_r, dst0_r);
  4039.         ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
  4040.         dst += (4 * dst_stride);
  4041.     }
  4042. }
  4043.  
  4044. static void hevc_hv_uniwgt_4t_4w_msa(uint8_t *src,
  4045.                                      int32_t src_stride,
  4046.                                      uint8_t *dst,
  4047.                                      int32_t dst_stride,
  4048.                                      const int8_t *filter_x,
  4049.                                      const int8_t *filter_y,
  4050.                                      int32_t height,
  4051.                                      int32_t weight,
  4052.                                      int32_t offset,
  4053.                                      int32_t rnd_val)
  4054. {
  4055.     if (2 == height) {
  4056.         hevc_hv_uniwgt_4t_4x2_msa(src, src_stride, dst, dst_stride,
  4057.                                   filter_x, filter_y, height, weight,
  4058.                                   offset, rnd_val);
  4059.     } else if (4 == height) {
  4060.         hevc_hv_uniwgt_4t_4x4_msa(src, src_stride, dst, dst_stride,
  4061.                                   filter_x, filter_y, height, weight,
  4062.                                   offset, rnd_val);
  4063.     } else if (0 == (height % 8)) {
  4064.         hevc_hv_uniwgt_4t_4multx8mult_msa(src, src_stride, dst, dst_stride,
  4065.                                           filter_x, filter_y, height, weight,
  4066.                                           offset, rnd_val);
  4067.     }
  4068. }
  4069.  
  4070. static void hevc_hv_uniwgt_4t_6w_msa(uint8_t *src,
  4071.                                      int32_t src_stride,
  4072.                                      uint8_t *dst,
  4073.                                      int32_t dst_stride,
  4074.                                      const int8_t *filter_x,
  4075.                                      const int8_t *filter_y,
  4076.                                      int32_t height,
  4077.                                      int32_t weight,
  4078.                                      int32_t offset,
  4079.                                      int32_t rnd_val)
  4080. {
  4081.     uint32_t loop_cnt;
  4082.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  4083.     v8i16 filt0, filt1;
  4084.     v4i32 filt_h0, filt_h1;
  4085.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  4086.     v16i8 mask1;
  4087.     v8i16 filter_vec, const_vec;
  4088.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  4089.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  4090.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
  4091.     v4i32 weight_vec, offset_vec, rnd_vec;
  4092.     v4i32 dst2_r, dst2_l, dst3_r, dst3_l;
  4093.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  4094.     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
  4095.  
  4096.     src -= (src_stride + 1);
  4097.  
  4098.     filter_vec = LD_SH(filter_x);
  4099.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  4100.  
  4101.     filter_vec = LD_SH(filter_y);
  4102.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  4103.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  4104.  
  4105.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  4106.  
  4107.     mask1 = mask0 + 2;
  4108.  
  4109.     const_vec = __msa_ldi_h(128);
  4110.     const_vec <<= 6;
  4111.  
  4112.     weight_vec = __msa_fill_w(weight);
  4113.     offset_vec = __msa_fill_w(offset);
  4114.     rnd_vec = __msa_fill_w(rnd_val);
  4115.  
  4116.     LD_SB3(src, src_stride, src0, src1, src2);
  4117.     src += (3 * src_stride);
  4118.     XORI_B3_128_SB(src0, src1, src2);
  4119.  
  4120.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  4121.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  4122.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  4123.     dst0 = const_vec;
  4124.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  4125.     dst1 = const_vec;
  4126.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  4127.     dst2 = const_vec;
  4128.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  4129.  
  4130.     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
  4131.     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
  4132.  
  4133.     for (loop_cnt = height >> 2; loop_cnt--;) {
  4134.         LD_SB4(src, src_stride, src3, src4, src5, src6);
  4135.         src += (4 * src_stride);
  4136.         XORI_B4_128_SB(src3, src4, src5, src6);
  4137.  
  4138.         /* row 3 */
  4139.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  4140.         dst3 = const_vec;
  4141.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  4142.         ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
  4143.         dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  4144.         dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
  4145.         dst0_r >>= 6;
  4146.         dst0_l >>= 6;
  4147.  
  4148.         /* row 4 */
  4149.         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  4150.         dst4 = const_vec;
  4151.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  4152.         ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
  4153.         dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  4154.         dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
  4155.         dst1_r >>= 6;
  4156.         dst1_l >>= 6;
  4157.  
  4158.         /* row 5 */
  4159.         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  4160.         dst5 = const_vec;
  4161.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  4162.         ILVRL_H2_SH(dst5, dst4, dst10_r, dst10_l);
  4163.         dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
  4164.         dst2_l = HEVC_FILT_4TAP(dst32_l, dst10_l, filt_h0, filt_h1);
  4165.         dst2_r >>= 6;
  4166.         dst2_l >>= 6;
  4167.  
  4168.         /* row 6 */
  4169.         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  4170.         dst2 = const_vec;
  4171.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  4172.         ILVRL_H2_SH(dst2, dst5, dst21_r, dst21_l);
  4173.         dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
  4174.         dst3_l = HEVC_FILT_4TAP(dst43_l, dst21_l, filt_h0, filt_h1);
  4175.         dst3_r >>= 6;
  4176.         dst3_l >>= 6;
  4177.  
  4178.         HEVC_HV_UNIW_RND_CLIP4(dst0_r, dst1_r, dst0_l, dst1_l,
  4179.                                weight_vec, offset_vec, rnd_vec,
  4180.                                dst0_r, dst1_r, dst0_l, dst1_l);
  4181.         HEVC_HV_UNIW_RND_CLIP4(dst2_r, dst3_r, dst2_l, dst3_l,
  4182.                                weight_vec, offset_vec, rnd_vec,
  4183.                                dst2_r, dst3_r, dst2_l, dst3_l);
  4184.         HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  4185.                         dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  4186.         ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
  4187.         dst += (4 * dst_stride);
  4188.     }
  4189. }
  4190.  
  4191. static void hevc_hv_uniwgt_4t_8x2_msa(uint8_t *src,
  4192.                                       int32_t src_stride,
  4193.                                       uint8_t *dst,
  4194.                                       int32_t dst_stride,
  4195.                                       const int8_t *filter_x,
  4196.                                       const int8_t *filter_y,
  4197.                                       int32_t height,
  4198.                                       int32_t weight,
  4199.                                       int32_t offset,
  4200.                                       int32_t rnd_val)
  4201. {
  4202.     v16i8 src0, src1, src2, src3, src4;
  4203.     v8i16 filt0, filt1;
  4204.     v4i32 filt_h0, filt_h1;
  4205.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  4206.     v16i8 mask1;
  4207.     v8i16 filter_vec, const_vec;
  4208.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  4209.     v8i16 dst0, dst1, dst2, dst3, dst4;
  4210.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
  4211.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  4212.     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
  4213.     v4i32 weight_vec, offset_vec, rnd_vec;
  4214.  
  4215.     src -= (src_stride + 1);
  4216.  
  4217.     filter_vec = LD_SH(filter_x);
  4218.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  4219.  
  4220.     filter_vec = LD_SH(filter_y);
  4221.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  4222.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  4223.  
  4224.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  4225.  
  4226.     mask1 = mask0 + 2;
  4227.  
  4228.     const_vec = __msa_ldi_h(128);
  4229.     const_vec <<= 6;
  4230.  
  4231.     weight_vec = __msa_fill_w(weight);
  4232.     offset_vec = __msa_fill_w(offset);
  4233.     rnd_vec = __msa_fill_w(rnd_val);
  4234.  
  4235.     LD_SB3(src, src_stride, src0, src1, src2);
  4236.     src += (3 * src_stride);
  4237.     XORI_B3_128_SB(src0, src1, src2);
  4238.  
  4239.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  4240.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  4241.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  4242.     dst0 = const_vec;
  4243.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  4244.     dst1 = const_vec;
  4245.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  4246.     dst2 = const_vec;
  4247.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  4248.  
  4249.     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
  4250.     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
  4251.  
  4252.     LD_SB2(src, src_stride, src3, src4);
  4253.     src += (2 * src_stride);
  4254.     XORI_B2_128_SB(src3, src4);
  4255.  
  4256.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  4257.     dst3 = const_vec;
  4258.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  4259.     ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
  4260.     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  4261.     dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
  4262.     dst0_r >>= 6;
  4263.     dst0_l >>= 6;
  4264.  
  4265.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  4266.     dst4 = const_vec;
  4267.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  4268.     ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
  4269.     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  4270.     dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
  4271.     dst1_r >>= 6;
  4272.     dst1_l >>= 6;
  4273.  
  4274.     HEVC_HV_UNIW_RND_CLIP4(dst0_r, dst1_r, dst0_l, dst1_l,
  4275.                            weight_vec, offset_vec, rnd_vec,
  4276.                            dst0_r, dst1_r, dst0_l, dst1_l);
  4277.     HEVC_PCK_SW_SB4(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r);
  4278.     ST8x2_UB(dst0_r, dst, dst_stride);
  4279.     dst += (2 * dst_stride);
  4280. }
  4281.  
  4282. static void hevc_hv_uniwgt_4t_8x6_msa(uint8_t *src,
  4283.                                       int32_t src_stride,
  4284.                                       uint8_t *dst,
  4285.                                       int32_t dst_stride,
  4286.                                       const int8_t *filter_x,
  4287.                                       const int8_t *filter_y,
  4288.                                       int32_t height,
  4289.                                       int32_t weight,
  4290.                                       int32_t offset,
  4291.                                       int32_t rnd_val)
  4292. {
  4293.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  4294.     v8i16 filt0, filt1;
  4295.     v4i32 filt_h0, filt_h1;
  4296.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  4297.     v16i8 mask1;
  4298.     v8i16 filter_vec, const_vec;
  4299.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  4300.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
  4301.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
  4302.     v4i32 dst4_r, dst4_l, dst5_r, dst5_l;
  4303.     v8i16 dst10_r, dst32_r, dst10_l, dst32_l;
  4304.     v8i16 dst21_r, dst43_r, dst21_l, dst43_l;
  4305.     v8i16 dst54_r, dst54_l, dst65_r, dst65_l;
  4306.     v8i16 dst76_r, dst76_l, dst87_r, dst87_l;
  4307.     v4i32 weight_vec, offset_vec, rnd_vec;
  4308.  
  4309.     src -= (src_stride + 1);
  4310.  
  4311.     filter_vec = LD_SH(filter_x);
  4312.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  4313.  
  4314.     filter_vec = LD_SH(filter_y);
  4315.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  4316.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  4317.  
  4318.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  4319.  
  4320.     mask1 = mask0 + 2;
  4321.  
  4322.     const_vec = __msa_ldi_h(128);
  4323.     const_vec <<= 6;
  4324.  
  4325.     weight_vec = __msa_fill_w(weight);
  4326.     offset_vec = __msa_fill_w(offset);
  4327.     rnd_vec = __msa_fill_w(rnd_val);
  4328.  
  4329.     LD_SB3(src, src_stride, src0, src1, src2);
  4330.     src += (3 * src_stride);
  4331.  
  4332.     XORI_B3_128_SB(src0, src1, src2);
  4333.  
  4334.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  4335.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  4336.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  4337.     dst0 = const_vec;
  4338.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  4339.     dst1 = const_vec;
  4340.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  4341.     dst2 = const_vec;
  4342.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  4343.  
  4344.     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
  4345.     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
  4346.  
  4347.     LD_SB2(src, src_stride, src3, src4);
  4348.     src += (2 * src_stride);
  4349.     XORI_B2_128_SB(src3, src4);
  4350.  
  4351.     /* row 3 */
  4352.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  4353.     dst3 = const_vec;
  4354.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  4355.     ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
  4356.     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  4357.     dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
  4358.     dst0_r >>= 6;
  4359.     dst0_l >>= 6;
  4360.  
  4361.     /* row 4 */
  4362.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  4363.     dst4 = const_vec;
  4364.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  4365.     ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
  4366.     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  4367.     dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
  4368.     dst1_r >>= 6;
  4369.     dst1_l >>= 6;
  4370.  
  4371.     LD_SB2(src, src_stride, src5, src6);
  4372.     src += (2 * src_stride);
  4373.     XORI_B2_128_SB(src5, src6);
  4374.  
  4375.     /* row 5 */
  4376.     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  4377.     dst5 = const_vec;
  4378.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  4379.     ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
  4380.     dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
  4381.     dst2_l = HEVC_FILT_4TAP(dst32_l, dst54_l, filt_h0, filt_h1);
  4382.     dst2_r >>= 6;
  4383.     dst2_l >>= 6;
  4384.  
  4385.     /* row 6 */
  4386.     VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  4387.     dst6 = const_vec;
  4388.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
  4389.     ILVRL_H2_SH(dst6, dst5, dst65_r, dst65_l);
  4390.     dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
  4391.     dst3_l = HEVC_FILT_4TAP(dst43_l, dst65_l, filt_h0, filt_h1);
  4392.     dst3_r >>= 6;
  4393.     dst3_l >>= 6;
  4394.  
  4395.     LD_SB2(src, src_stride, src7, src8);
  4396.     src += (2 * src_stride);
  4397.     XORI_B2_128_SB(src7, src8);
  4398.  
  4399.     /* row 7 */
  4400.     VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
  4401.     dst7 = const_vec;
  4402.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
  4403.     ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
  4404.     dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
  4405.     dst4_l = HEVC_FILT_4TAP(dst54_l, dst76_l, filt_h0, filt_h1);
  4406.  
  4407.     dst4_r >>= 6;
  4408.     dst4_l >>= 6;
  4409.  
  4410.     /* row 8 */
  4411.     VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
  4412.     dst8 = const_vec;
  4413.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
  4414.     ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
  4415.     dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
  4416.     dst5_l = HEVC_FILT_4TAP(dst65_l, dst87_l, filt_h0, filt_h1);
  4417.     dst5_r >>= 6;
  4418.     dst5_l >>= 6;
  4419.  
  4420.     HEVC_HV_UNIW_RND_CLIP4(dst0_r, dst1_r, dst0_l, dst1_l,
  4421.                            weight_vec, offset_vec, rnd_vec,
  4422.                            dst0_r, dst1_r, dst0_l, dst1_l);
  4423.     HEVC_HV_UNIW_RND_CLIP4(dst2_r, dst3_r, dst2_l, dst3_l,
  4424.                            weight_vec, offset_vec, rnd_vec,
  4425.                            dst2_r, dst3_r, dst2_l, dst3_l);
  4426.     HEVC_HV_UNIW_RND_CLIP4(dst4_r, dst5_r, dst4_l, dst5_l,
  4427.                            weight_vec, offset_vec, rnd_vec,
  4428.                            dst4_r, dst5_r, dst4_l, dst5_l);
  4429.     HEVC_PCK_SW_SB12(dst0_l, dst0_r, dst1_l, dst1_r,
  4430.                      dst2_l, dst2_r, dst3_l, dst3_r,
  4431.                      dst4_l, dst4_r, dst5_l, dst5_r, dst0_r, dst1_r, dst2_r);
  4432.     ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
  4433.     dst += (4 * dst_stride);
  4434.     ST8x2_UB(dst2_r, dst, dst_stride);
  4435. }
  4436.  
  4437. static void hevc_hv_uniwgt_4t_8multx4mult_msa(uint8_t *src,
  4438.                                               int32_t src_stride,
  4439.                                               uint8_t *dst,
  4440.                                               int32_t dst_stride,
  4441.                                               const int8_t *filter_x,
  4442.                                               const int8_t *filter_y,
  4443.                                               int32_t height,
  4444.                                               int32_t weight,
  4445.                                               int32_t offset,
  4446.                                               int32_t rnd_val,
  4447.                                               int32_t width)
  4448. {
  4449.     uint32_t loop_cnt, cnt;
  4450.     uint8_t *src_tmp;
  4451.     uint8_t *dst_tmp;
  4452.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  4453.     v8i16 filt0, filt1;
  4454.     v4i32 filt_h0, filt_h1;
  4455.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  4456.     v16i8 mask1;
  4457.     v8i16 filter_vec, const_vec;
  4458.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  4459.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  4460.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
  4461.     v4i32 weight_vec, offset_vec, rnd_vec;
  4462.     v4i32 dst2_r, dst2_l, dst3_r, dst3_l;
  4463.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  4464.     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
  4465.  
  4466.     src -= (src_stride + 1);
  4467.  
  4468.     filter_vec = LD_SH(filter_x);
  4469.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  4470.  
  4471.     filter_vec = LD_SH(filter_y);
  4472.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  4473.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  4474.  
  4475.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  4476.  
  4477.     mask1 = mask0 + 2;
  4478.  
  4479.     const_vec = __msa_ldi_h(128);
  4480.     const_vec <<= 6;
  4481.  
  4482.     weight_vec = __msa_fill_w(weight);
  4483.     offset_vec = __msa_fill_w(offset);
  4484.     rnd_vec = __msa_fill_w(rnd_val);
  4485.  
  4486.     for (cnt = width >> 3; cnt--;) {
  4487.         src_tmp = src;
  4488.         dst_tmp = dst;
  4489.  
  4490.         LD_SB3(src_tmp, src_stride, src0, src1, src2);
  4491.         src_tmp += (3 * src_stride);
  4492.         XORI_B3_128_SB(src0, src1, src2);
  4493.  
  4494.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  4495.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  4496.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  4497.         dst0 = const_vec;
  4498.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  4499.         dst1 = const_vec;
  4500.         DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  4501.         dst2 = const_vec;
  4502.         DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  4503.  
  4504.         ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
  4505.         ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
  4506.  
  4507.         for (loop_cnt = height >> 2; loop_cnt--;) {
  4508.             LD_SB4(src_tmp, src_stride, src3, src4, src5, src6);
  4509.             src_tmp += (4 * src_stride);
  4510.             XORI_B4_128_SB(src3, src4, src5, src6);
  4511.  
  4512.             VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  4513.             dst3 = const_vec;
  4514.             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  4515.             ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
  4516.             dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  4517.             dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
  4518.             dst0_r >>= 6;
  4519.             dst0_l >>= 6;
  4520.  
  4521.             VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  4522.             dst4 = const_vec;
  4523.             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  4524.             ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
  4525.             dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  4526.             dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
  4527.             dst1_r >>= 6;
  4528.             dst1_l >>= 6;
  4529.  
  4530.             VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  4531.             dst5 = const_vec;
  4532.             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  4533.             ILVRL_H2_SH(dst5, dst4, dst10_r, dst10_l);
  4534.             dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
  4535.             dst2_l = HEVC_FILT_4TAP(dst32_l, dst10_l, filt_h0, filt_h1);
  4536.             dst2_r >>= 6;
  4537.             dst2_l >>= 6;
  4538.  
  4539.             VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  4540.             dst2 = const_vec;
  4541.             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  4542.             ILVRL_H2_SH(dst2, dst5, dst21_r, dst21_l);
  4543.             dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
  4544.             dst3_l = HEVC_FILT_4TAP(dst43_l, dst21_l, filt_h0, filt_h1);
  4545.             dst3_r >>= 6;
  4546.             dst3_l >>= 6;
  4547.  
  4548.             HEVC_HV_UNIW_RND_CLIP4(dst0_r, dst1_r, dst0_l, dst1_l,
  4549.                                    weight_vec, offset_vec, rnd_vec,
  4550.                                    dst0_r, dst1_r, dst0_l, dst1_l);
  4551.             HEVC_HV_UNIW_RND_CLIP4(dst2_r, dst3_r, dst2_l, dst3_l,
  4552.                                    weight_vec, offset_vec, rnd_vec,
  4553.                                    dst2_r, dst3_r, dst2_l, dst3_l);
  4554.             HEVC_PCK_SW_SB8(dst0_l, dst0_r, dst1_l, dst1_r,
  4555.                             dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r);
  4556.             ST8x4_UB(dst0_r, dst1_r, dst_tmp, dst_stride);
  4557.             dst_tmp += (4 * dst_stride);
  4558.         }
  4559.  
  4560.         src += 8;
  4561.         dst += 8;
  4562.     }
  4563. }
  4564.  
  4565. static void hevc_hv_uniwgt_4t_8w_msa(uint8_t *src,
  4566.                                      int32_t src_stride,
  4567.                                      uint8_t *dst,
  4568.                                      int32_t dst_stride,
  4569.                                      const int8_t *filter_x,
  4570.                                      const int8_t *filter_y,
  4571.                                      int32_t height,
  4572.                                      int32_t weight,
  4573.                                      int32_t offset,
  4574.                                      int32_t rnd_val)
  4575. {
  4576.  
  4577.     if (2 == height) {
  4578.         hevc_hv_uniwgt_4t_8x2_msa(src, src_stride, dst, dst_stride,
  4579.                                   filter_x, filter_y, height, weight,
  4580.                                   offset, rnd_val);
  4581.     } else if (6 == height) {
  4582.         hevc_hv_uniwgt_4t_8x6_msa(src, src_stride, dst, dst_stride,
  4583.                                   filter_x, filter_y, height, weight,
  4584.                                   offset, rnd_val);
  4585.     } else if (0 == (height % 4)) {
  4586.         hevc_hv_uniwgt_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  4587.                                           filter_x, filter_y, height, weight,
  4588.                                           offset, rnd_val, 8);
  4589.     }
  4590. }
  4591.  
  4592. static void hevc_hv_uniwgt_4t_12w_msa(uint8_t *src,
  4593.                                       int32_t src_stride,
  4594.                                       uint8_t *dst,
  4595.                                       int32_t dst_stride,
  4596.                                       const int8_t *filter_x,
  4597.                                       const int8_t *filter_y,
  4598.                                       int32_t height,
  4599.                                       int32_t weight,
  4600.                                       int32_t offset,
  4601.                                       int32_t rnd_val)
  4602. {
  4603.     hevc_hv_uniwgt_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  4604.                                       filter_x, filter_y, height, weight,
  4605.                                       offset, rnd_val, 8);
  4606.     hevc_hv_uniwgt_4t_4w_msa(src + 8, src_stride, dst + 8, dst_stride,
  4607.                              filter_x, filter_y, height, weight,
  4608.                              offset, rnd_val);
  4609. }
  4610.  
  4611. static void hevc_hv_uniwgt_4t_16w_msa(uint8_t *src,
  4612.                                       int32_t src_stride,
  4613.                                       uint8_t *dst,
  4614.                                       int32_t dst_stride,
  4615.                                       const int8_t *filter_x,
  4616.                                       const int8_t *filter_y,
  4617.                                       int32_t height,
  4618.                                       int32_t weight,
  4619.                                       int32_t offset,
  4620.                                       int32_t rnd_val)
  4621. {
  4622.     hevc_hv_uniwgt_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  4623.                                       filter_x, filter_y, height, weight,
  4624.                                       offset, rnd_val, 16);
  4625. }
  4626.  
  4627. static void hevc_hv_uniwgt_4t_24w_msa(uint8_t *src,
  4628.                                       int32_t src_stride,
  4629.                                       uint8_t *dst,
  4630.                                       int32_t dst_stride,
  4631.                                       const int8_t *filter_x,
  4632.                                       const int8_t *filter_y,
  4633.                                       int32_t height,
  4634.                                       int32_t weight,
  4635.                                       int32_t offset,
  4636.                                       int32_t rnd_val)
  4637. {
  4638.     hevc_hv_uniwgt_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  4639.                                       filter_x, filter_y, height, weight,
  4640.                                       offset, rnd_val, 24);
  4641. }
  4642.  
  4643. static void hevc_hv_uniwgt_4t_32w_msa(uint8_t *src,
  4644.                                       int32_t src_stride,
  4645.                                       uint8_t *dst,
  4646.                                       int32_t dst_stride,
  4647.                                       const int8_t *filter_x,
  4648.                                       const int8_t *filter_y,
  4649.                                       int32_t height,
  4650.                                       int32_t weight,
  4651.                                       int32_t offset,
  4652.                                       int32_t rnd_val)
  4653. {
  4654.     hevc_hv_uniwgt_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  4655.                                       filter_x, filter_y, height, weight,
  4656.                                       offset, rnd_val, 32);
  4657. }
  4658.  
  4659. #define UNIWGT_MC_COPY(WIDTH)                                                \
  4660. void ff_hevc_put_hevc_uni_w_pel_pixels##WIDTH##_8_msa(uint8_t *dst,          \
  4661.                                                       ptrdiff_t dst_stride,  \
  4662.                                                       uint8_t *src,          \
  4663.                                                       ptrdiff_t src_stride,  \
  4664.                                                       int height,            \
  4665.                                                       int denom,             \
  4666.                                                       int weight,            \
  4667.                                                       int offset,            \
  4668.                                                       intptr_t mx,           \
  4669.                                                       intptr_t my,           \
  4670.                                                       int width)             \
  4671. {                                                                            \
  4672.     int shift = denom + 14 - 8;                                              \
  4673.     hevc_uniwgt_copy_##WIDTH##w_msa(src, src_stride, dst, dst_stride,        \
  4674.                                     height, weight, offset, shift);          \
  4675. }
  4676.  
  4677. UNIWGT_MC_COPY(4);
  4678. UNIWGT_MC_COPY(6);
  4679. UNIWGT_MC_COPY(8);
  4680. UNIWGT_MC_COPY(12);
  4681. UNIWGT_MC_COPY(16);
  4682. UNIWGT_MC_COPY(24);
  4683. UNIWGT_MC_COPY(32);
  4684. UNIWGT_MC_COPY(48);
  4685. UNIWGT_MC_COPY(64);
  4686.  
  4687. #undef UNIWGT_MC_COPY
  4688.  
  4689. #define UNI_W_MC(PEL, DIR, WIDTH, TAP, DIR1, FILT_DIR)                        \
  4690. void ff_hevc_put_hevc_uni_w_##PEL##_##DIR##WIDTH##_8_msa(uint8_t *dst,        \
  4691.                                                            ptrdiff_t          \
  4692.                                                            dst_stride,        \
  4693.                                                            uint8_t *src,      \
  4694.                                                            ptrdiff_t          \
  4695.                                                            src_stride,        \
  4696.                                                            int height,        \
  4697.                                                            int denom,         \
  4698.                                                            int weight,        \
  4699.                                                            int offset,        \
  4700.                                                            intptr_t mx,       \
  4701.                                                            intptr_t my,       \
  4702.                                                            int width)         \
  4703. {                                                                             \
  4704.     const int8_t *filter = ff_hevc_##PEL##_filters[FILT_DIR - 1];             \
  4705.     int shift = denom + 14 - 8;                                               \
  4706.                                                                               \
  4707.     hevc_##DIR1##_uniwgt_##TAP##t_##WIDTH##w_msa(src, src_stride, dst,        \
  4708.                                                  dst_stride, filter, height,  \
  4709.                                                  weight, offset, shift);      \
  4710. }
  4711.  
  4712. UNI_W_MC(qpel, h, 4, 8, hz, mx);
  4713. UNI_W_MC(qpel, h, 8, 8, hz, mx);
  4714. UNI_W_MC(qpel, h, 12, 8, hz, mx);
  4715. UNI_W_MC(qpel, h, 16, 8, hz, mx);
  4716. UNI_W_MC(qpel, h, 24, 8, hz, mx);
  4717. UNI_W_MC(qpel, h, 32, 8, hz, mx);
  4718. UNI_W_MC(qpel, h, 48, 8, hz, mx);
  4719. UNI_W_MC(qpel, h, 64, 8, hz, mx);
  4720.  
  4721. UNI_W_MC(qpel, v, 4, 8, vt, my);
  4722. UNI_W_MC(qpel, v, 8, 8, vt, my);
  4723. UNI_W_MC(qpel, v, 12, 8, vt, my);
  4724. UNI_W_MC(qpel, v, 16, 8, vt, my);
  4725. UNI_W_MC(qpel, v, 24, 8, vt, my);
  4726. UNI_W_MC(qpel, v, 32, 8, vt, my);
  4727. UNI_W_MC(qpel, v, 48, 8, vt, my);
  4728. UNI_W_MC(qpel, v, 64, 8, vt, my);
  4729.  
  4730. UNI_W_MC(epel, h, 4, 4, hz, mx);
  4731. UNI_W_MC(epel, h, 6, 4, hz, mx);
  4732. UNI_W_MC(epel, h, 8, 4, hz, mx);
  4733. UNI_W_MC(epel, h, 12, 4, hz, mx);
  4734. UNI_W_MC(epel, h, 16, 4, hz, mx);
  4735. UNI_W_MC(epel, h, 24, 4, hz, mx);
  4736. UNI_W_MC(epel, h, 32, 4, hz, mx);
  4737.  
  4738. UNI_W_MC(epel, v, 4, 4, vt, my);
  4739. UNI_W_MC(epel, v, 6, 4, vt, my);
  4740. UNI_W_MC(epel, v, 8, 4, vt, my);
  4741. UNI_W_MC(epel, v, 12, 4, vt, my);
  4742. UNI_W_MC(epel, v, 16, 4, vt, my);
  4743. UNI_W_MC(epel, v, 24, 4, vt, my);
  4744. UNI_W_MC(epel, v, 32, 4, vt, my);
  4745.  
  4746. #undef UNI_W_MC
  4747.  
  4748. #define UNI_W_MC_HV(PEL, DIR, WIDTH, TAP, DIR1)                              \
  4749. void ff_hevc_put_hevc_uni_w_##PEL##_##DIR##WIDTH##_8_msa(uint8_t *dst,       \
  4750.                                                            ptrdiff_t         \
  4751.                                                            dst_stride,       \
  4752.                                                            uint8_t *src,     \
  4753.                                                            ptrdiff_t         \
  4754.                                                            src_stride,       \
  4755.                                                            int height,       \
  4756.                                                            int denom,        \
  4757.                                                            int weight,       \
  4758.                                                            int offset,       \
  4759.                                                            intptr_t mx,      \
  4760.                                                            intptr_t my,      \
  4761.                                                            int width)        \
  4762. {                                                                            \
  4763.     const int8_t *filter_x = ff_hevc_##PEL##_filters[mx - 1];                \
  4764.     const int8_t *filter_y = ff_hevc_##PEL##_filters[my - 1];                \
  4765.     int shift = denom + 14 - 8;                                              \
  4766.                                                                              \
  4767.     hevc_##DIR1##_uniwgt_##TAP##t_##WIDTH##w_msa(src, src_stride, dst,       \
  4768.                                                  dst_stride, filter_x,       \
  4769.                                                  filter_y,  height, weight,  \
  4770.                                                  offset, shift);             \
  4771. }
  4772.  
  4773. UNI_W_MC_HV(qpel, hv, 4, 8, hv);
  4774. UNI_W_MC_HV(qpel, hv, 8, 8, hv);
  4775. UNI_W_MC_HV(qpel, hv, 12, 8, hv);
  4776. UNI_W_MC_HV(qpel, hv, 16, 8, hv);
  4777. UNI_W_MC_HV(qpel, hv, 24, 8, hv);
  4778. UNI_W_MC_HV(qpel, hv, 32, 8, hv);
  4779. UNI_W_MC_HV(qpel, hv, 48, 8, hv);
  4780. UNI_W_MC_HV(qpel, hv, 64, 8, hv);
  4781.  
  4782. UNI_W_MC_HV(epel, hv, 4, 4, hv);
  4783. UNI_W_MC_HV(epel, hv, 6, 4, hv);
  4784. UNI_W_MC_HV(epel, hv, 8, 4, hv);
  4785. UNI_W_MC_HV(epel, hv, 12, 4, hv);
  4786. UNI_W_MC_HV(epel, hv, 16, 4, hv);
  4787. UNI_W_MC_HV(epel, hv, 24, 4, hv);
  4788. UNI_W_MC_HV(epel, hv, 32, 4, hv);
  4789.  
  4790. #undef UNI_W_MC_HV
  4791.