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. static void hevc_copy_4w_msa(uint8_t *src, int32_t src_stride,
  26.                              int16_t *dst, int32_t dst_stride,
  27.                              int32_t height)
  28. {
  29.     v16i8 zero = { 0 };
  30.  
  31.     if (2 == height) {
  32.         v16i8 src0, src1;
  33.         v8i16 in0;
  34.  
  35.         LD_SB2(src, src_stride, src0, src1);
  36.  
  37.         src0 = (v16i8) __msa_ilvr_w((v4i32) src1, (v4i32) src0);
  38.         in0 = (v8i16) __msa_ilvr_b(zero, src0);
  39.         in0 <<= 6;
  40.         ST8x2_UB(in0, dst, 2 * dst_stride);
  41.     } else if (4 == height) {
  42.         v16i8 src0, src1, src2, src3;
  43.         v8i16 in0, in1;
  44.  
  45.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  46.  
  47.         ILVR_W2_SB(src1, src0, src3, src2, src0, src1);
  48.         ILVR_B2_SH(zero, src0, zero, src1, in0, in1);
  49.         in0 <<= 6;
  50.         in1 <<= 6;
  51.         ST8x4_UB(in0, in1, dst, 2 * dst_stride);
  52.     } else if (0 == height % 8) {
  53.         v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  54.         v8i16 in0, in1, in2, in3;
  55.         uint32_t loop_cnt;
  56.  
  57.         for (loop_cnt = (height >> 3); loop_cnt--;) {
  58.             LD_SB8(src, src_stride,
  59.                    src0, src1, src2, src3, src4, src5, src6, src7);
  60.             src += (8 * src_stride);
  61.  
  62.             ILVR_W4_SB(src1, src0, src3, src2, src5, src4, src7, src6,
  63.                        src0, src1, src2, src3);
  64.             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  65.                        in0, in1, in2, in3);
  66.             SLLI_4V(in0, in1, in2, in3, 6);
  67.             ST8x8_UB(in0, in1, in2, in3, dst, 2 * dst_stride);
  68.             dst += (8 * dst_stride);
  69.         }
  70.     }
  71. }
  72.  
  73. static void hevc_copy_6w_msa(uint8_t *src, int32_t src_stride,
  74.                              int16_t *dst, int32_t dst_stride,
  75.                              int32_t height)
  76. {
  77.     uint32_t loop_cnt;
  78.     v16i8 zero = { 0 };
  79.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  80.     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
  81.  
  82.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  83.         LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  84.         src += (8 * src_stride);
  85.  
  86.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  87.                    in0, in1, in2, in3);
  88.         ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
  89.                    in4, in5, in6, in7);
  90.         SLLI_4V(in0, in1, in2, in3, 6);
  91.         SLLI_4V(in4, in5, in6, in7, 6);
  92.         ST12x8_UB(in0, in1, in2, in3, in4, in5, in6, in7, dst, 2 * dst_stride);
  93.         dst += (8 * dst_stride);
  94.     }
  95. }
  96.  
  97. static void hevc_copy_8w_msa(uint8_t *src, int32_t src_stride,
  98.                              int16_t *dst, int32_t dst_stride,
  99.                              int32_t height)
  100. {
  101.     v16i8 zero = { 0 };
  102.  
  103.     if (2 == height) {
  104.         v16i8 src0, src1;
  105.         v8i16 in0, in1;
  106.  
  107.         LD_SB2(src, src_stride, src0, src1);
  108.  
  109.         ILVR_B2_SH(zero, src0, zero, src1, in0, in1);
  110.         in0 <<= 6;
  111.         in1 <<= 6;
  112.         ST_SH2(in0, in1, dst, dst_stride);
  113.     } else if (4 == height) {
  114.         v16i8 src0, src1, src2, src3;
  115.         v8i16 in0, in1, in2, in3;
  116.  
  117.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  118.  
  119.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  120.                    in0, in1, in2, in3);
  121.         SLLI_4V(in0, in1, in2, in3, 6);
  122.         ST_SH4(in0, in1, in2, in3, dst, dst_stride);
  123.     } else if (6 == height) {
  124.         v16i8 src0, src1, src2, src3, src4, src5;
  125.         v8i16 in0, in1, in2, in3, in4, in5;
  126.  
  127.         LD_SB6(src, src_stride, src0, src1, src2, src3, src4, src5);
  128.  
  129.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  130.                    in0, in1, in2, in3);
  131.         ILVR_B2_SH(zero, src4, zero, src5, in4, in5);
  132.         SLLI_4V(in0, in1, in2, in3, 6);
  133.         in4 <<= 6;
  134.         in5 <<= 6;
  135.         ST_SH6(in0, in1, in2, in3, in4, in5, dst, dst_stride);
  136.     } else if (0 == height % 8) {
  137.         uint32_t loop_cnt;
  138.         v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  139.         v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
  140.  
  141.         for (loop_cnt = (height >> 3); loop_cnt--;) {
  142.             LD_SB8(src, src_stride,
  143.                    src0, src1, src2, src3, src4, src5, src6, src7);
  144.             src += (8 * src_stride);
  145.  
  146.             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  147.                        in0, in1, in2, in3);
  148.             ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
  149.                        in4, in5, in6, in7);
  150.             SLLI_4V(in0, in1, in2, in3, 6);
  151.             SLLI_4V(in4, in5, in6, in7, 6);
  152.             ST_SH8(in0, in1, in2, in3, in4, in5, in6, in7, dst, dst_stride);
  153.             dst += (8 * dst_stride);
  154.         }
  155.     }
  156. }
  157.  
  158. static void hevc_copy_12w_msa(uint8_t *src, int32_t src_stride,
  159.                               int16_t *dst, int32_t dst_stride,
  160.                               int32_t height)
  161. {
  162.     uint32_t loop_cnt;
  163.     v16i8 zero = { 0 };
  164.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  165.     v8i16 in0, in1, in0_r, in1_r, in2_r, in3_r;
  166.  
  167.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  168.         LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  169.         src += (8 * src_stride);
  170.  
  171.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  172.                    in0_r, in1_r, in2_r, in3_r);
  173.         SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
  174.         ILVL_W2_SB(src1, src0, src3, src2, src0, src1);
  175.         ILVR_B2_SH(zero, src0, zero, src1, in0, in1);
  176.         in0 <<= 6;
  177.         in1 <<= 6;
  178.         ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
  179.         ST8x4_UB(in0, in1, dst + 8, 2 * dst_stride);
  180.         dst += (4 * dst_stride);
  181.  
  182.         ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
  183.                    in0_r, in1_r, in2_r, in3_r);
  184.         SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
  185.         ILVL_W2_SB(src5, src4, src7, src6, src0, src1);
  186.         ILVR_B2_SH(zero, src0, zero, src1, in0, in1);
  187.         in0 <<= 6;
  188.         in1 <<= 6;
  189.         ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
  190.         ST8x4_UB(in0, in1, dst + 8, 2 * dst_stride);
  191.         dst += (4 * dst_stride);
  192.     }
  193. }
  194.  
  195. static void hevc_copy_16multx8mult_msa(uint8_t *src,
  196.                                        int32_t src_stride,
  197.                                        int16_t *dst,
  198.                                        int32_t dst_stride,
  199.                                        int32_t height,
  200.                                        int32_t width)
  201. {
  202.     uint8_t *src_tmp;
  203.     int16_t *dst_tmp;
  204.     uint32_t loop_cnt, cnt;
  205.     v16i8 zero = { 0 };
  206.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  207.     v8i16 in0_r, in1_r, in2_r, in3_r;
  208.     v8i16 in0_l, in1_l, in2_l, in3_l;
  209.  
  210.     for (cnt = (width >> 4); cnt--;) {
  211.         src_tmp = src;
  212.         dst_tmp = dst;
  213.  
  214.         for (loop_cnt = (height >> 3); loop_cnt--;) {
  215.             LD_SB8(src_tmp, src_stride,
  216.                    src0, src1, src2, src3, src4, src5, src6, src7);
  217.             src_tmp += (8 * src_stride);
  218.  
  219.             ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  220.                        in0_r, in1_r, in2_r, in3_r);
  221.             ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  222.                        in0_l, in1_l, in2_l, in3_l);
  223.             SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
  224.             SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
  225.             ST_SH4(in0_r, in1_r, in2_r, in3_r, dst_tmp, dst_stride);
  226.             ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst_tmp + 8), dst_stride);
  227.             dst_tmp += (4 * dst_stride);
  228.  
  229.             ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
  230.                        in0_r, in1_r, in2_r, in3_r);
  231.             ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
  232.                        in0_l, in1_l, in2_l, in3_l);
  233.             SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
  234.             SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
  235.             ST_SH4(in0_r, in1_r, in2_r, in3_r, dst_tmp, dst_stride);
  236.             ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst_tmp + 8), dst_stride);
  237.             dst_tmp += (4 * dst_stride);
  238.         }
  239.  
  240.         src += 16;
  241.         dst += 16;
  242.     }
  243. }
  244.  
  245. static void hevc_copy_16w_msa(uint8_t *src, int32_t src_stride,
  246.                               int16_t *dst, int32_t dst_stride,
  247.                               int32_t height)
  248. {
  249.     v16i8 zero = { 0 };
  250.  
  251.     if (4 == height) {
  252.         v16i8 src0, src1, src2, src3;
  253.         v8i16 in0_r, in1_r, in2_r, in3_r;
  254.         v8i16 in0_l, in1_l, in2_l, in3_l;
  255.  
  256.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  257.  
  258.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  259.                    in0_r, in1_r, in2_r, in3_r);
  260.         ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  261.                    in0_l, in1_l, in2_l, in3_l);
  262.         SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
  263.         SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
  264.         ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
  265.         ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
  266.     } else if (12 == height) {
  267.         v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  268.         v16i8 src8, src9, src10, src11;
  269.         v8i16 in0_r, in1_r, in2_r, in3_r;
  270.         v8i16 in0_l, in1_l, in2_l, in3_l;
  271.  
  272.         LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  273.         src += (8 * src_stride);
  274.         LD_SB4(src, src_stride, src8, src9, src10, src11);
  275.  
  276.         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  277.                    in0_r, in1_r, in2_r, in3_r);
  278.         ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3,
  279.                    in0_l, in1_l, in2_l, in3_l);
  280.         SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
  281.         SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
  282.         ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
  283.         ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
  284.         dst += (4 * dst_stride);
  285.  
  286.         ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
  287.                    in0_r, in1_r, in2_r, in3_r);
  288.         ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7,
  289.                    in0_l, in1_l, in2_l, in3_l);
  290.         SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
  291.         SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
  292.         ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
  293.         ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
  294.         dst += (4 * dst_stride);
  295.  
  296.         ILVR_B4_SH(zero, src8, zero, src9, zero, src10, zero, src11,
  297.                    in0_r, in1_r, in2_r, in3_r);
  298.         ILVL_B4_SH(zero, src8, zero, src9, zero, src10, zero, src11,
  299.                    in0_l, in1_l, in2_l, in3_l);
  300.         SLLI_4V(in0_r, in1_r, in2_r, in3_r, 6);
  301.         SLLI_4V(in0_l, in1_l, in2_l, in3_l, 6);
  302.         ST_SH4(in0_r, in1_r, in2_r, in3_r, dst, dst_stride);
  303.         ST_SH4(in0_l, in1_l, in2_l, in3_l, (dst + 8), dst_stride);
  304.     } else if (0 == (height % 8)) {
  305.         hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride,
  306.                                    height, 16);
  307.     }
  308. }
  309.  
  310. static void hevc_copy_24w_msa(uint8_t *src, int32_t src_stride,
  311.                               int16_t *dst, int32_t dst_stride,
  312.                               int32_t height)
  313. {
  314.     hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
  315.     hevc_copy_8w_msa(src + 16, src_stride, dst + 16, dst_stride, height);
  316. }
  317.  
  318. static void hevc_copy_32w_msa(uint8_t *src, int32_t src_stride,
  319.                               int16_t *dst, int32_t dst_stride,
  320.                               int32_t height)
  321. {
  322.     hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 32);
  323. }
  324.  
  325. static void hevc_copy_48w_msa(uint8_t *src, int32_t src_stride,
  326.                               int16_t *dst, int32_t dst_stride,
  327.                               int32_t height)
  328. {
  329.     hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 48);
  330. }
  331.  
  332. static void hevc_copy_64w_msa(uint8_t *src, int32_t src_stride,
  333.                               int16_t *dst, int32_t dst_stride,
  334.                               int32_t height)
  335. {
  336.     hevc_copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 64);
  337. }
  338.  
  339. static void hevc_hz_8t_4w_msa(uint8_t *src, int32_t src_stride,
  340.                               int16_t *dst, int32_t dst_stride,
  341.                               const int8_t *filter, int32_t height)
  342. {
  343.     uint32_t loop_cnt;
  344.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  345.     v8i16 filt0, filt1, filt2, filt3;
  346.     v16i8 mask1, mask2, mask3;
  347.     v16i8 vec0, vec1, vec2, vec3;
  348.     v8i16 dst0, dst1, dst2, dst3;
  349.     v8i16 filter_vec, const_vec;
  350.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  351.  
  352.     src -= 3;
  353.     const_vec = __msa_ldi_h(128);
  354.     const_vec <<= 6;
  355.  
  356.     filter_vec = LD_SH(filter);
  357.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  358.  
  359.     mask1 = mask0 + 2;
  360.     mask2 = mask0 + 4;
  361.     mask3 = mask0 + 6;
  362.  
  363.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  364.         LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  365.         src += (8 * src_stride);
  366.         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
  367.  
  368.         VSHF_B4_SB(src0, src1, mask0, mask1, mask2, mask3,
  369.                    vec0, vec1, vec2, vec3);
  370.         dst0 = const_vec;
  371.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  372.                      dst0, dst0, dst0, dst0);
  373.         VSHF_B4_SB(src2, src3, mask0, mask1, mask2, mask3,
  374.                    vec0, vec1, vec2, vec3);
  375.         dst1 = const_vec;
  376.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  377.                      dst1, dst1, dst1, dst1);
  378.         VSHF_B4_SB(src4, src5, mask0, mask1, mask2, mask3,
  379.                    vec0, vec1, vec2, vec3);
  380.         dst2 = const_vec;
  381.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  382.                      dst2, dst2, dst2, dst2);
  383.         VSHF_B4_SB(src6, src7, mask0, mask1, mask2, mask3,
  384.                    vec0, vec1, vec2, vec3);
  385.         dst3 = const_vec;
  386.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  387.                      dst3, dst3, dst3, dst3);
  388.  
  389.         ST8x8_UB(dst0, dst1, dst2, dst3, dst, 2 * dst_stride);
  390.         dst += (8 * dst_stride);
  391.     }
  392. }
  393.  
  394. static void hevc_hz_8t_8w_msa(uint8_t *src, int32_t src_stride,
  395.                               int16_t *dst, int32_t dst_stride,
  396.                               const int8_t *filter, int32_t height)
  397. {
  398.     uint32_t loop_cnt;
  399.     v16i8 src0, src1, src2, src3;
  400.     v8i16 filt0, filt1, filt2, filt3;
  401.     v16i8 mask1, mask2, mask3;
  402.     v16i8 vec0, vec1, vec2, vec3;
  403.     v8i16 dst0, dst1, dst2, dst3;
  404.     v8i16 filter_vec, const_vec;
  405.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  406.  
  407.     src -= 3;
  408.     const_vec = __msa_ldi_h(128);
  409.     const_vec <<= 6;
  410.  
  411.     filter_vec = LD_SH(filter);
  412.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  413.  
  414.     mask1 = mask0 + 2;
  415.     mask2 = mask0 + 4;
  416.     mask3 = mask0 + 6;
  417.  
  418.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  419.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  420.         src += (4 * src_stride);
  421.         XORI_B4_128_SB(src0, src1, src2, src3);
  422.  
  423.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  424.                    vec0, vec1, vec2, vec3);
  425.         dst0 = const_vec;
  426.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  427.                      dst0, dst0, dst0, dst0);
  428.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  429.                    vec0, vec1, vec2, vec3);
  430.         dst1 = const_vec;
  431.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  432.                      dst1, dst1, dst1, dst1);
  433.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  434.                    vec0, vec1, vec2, vec3);
  435.         dst2 = const_vec;
  436.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  437.                      dst2, dst2, dst2, dst2);
  438.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  439.                    vec0, vec1, vec2, vec3);
  440.         dst3 = const_vec;
  441.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  442.                      dst3, dst3, dst3, dst3);
  443.  
  444.         ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
  445.         dst += (4 * dst_stride);
  446.     }
  447. }
  448.  
  449. static void hevc_hz_8t_12w_msa(uint8_t *src, int32_t src_stride,
  450.                                int16_t *dst, int32_t dst_stride,
  451.                                const int8_t *filter, int32_t height)
  452. {
  453.     hevc_hz_8t_8w_msa(src, src_stride, dst, dst_stride, filter, height);
  454.     hevc_hz_8t_4w_msa(src + 8, src_stride, dst + 8, dst_stride, filter, height);
  455. }
  456.  
  457. static void hevc_hz_8t_16w_msa(uint8_t *src, int32_t src_stride,
  458.                                int16_t *dst, int32_t dst_stride,
  459.                                const int8_t *filter, int32_t height)
  460. {
  461.     uint32_t loop_cnt;
  462.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  463.     v8i16 filt0, filt1, filt2, filt3;
  464.     v16i8 mask1, mask2, mask3;
  465.     v16i8 vec0, vec1, vec2, vec3;
  466.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
  467.     v8i16 filter_vec, const_vec;
  468.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  469.  
  470.     src -= 3;
  471.     const_vec = __msa_ldi_h(128);
  472.     const_vec <<= 6;
  473.  
  474.     filter_vec = LD_SH(filter);
  475.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  476.  
  477.     mask1 = mask0 + 2;
  478.     mask2 = mask0 + 4;
  479.     mask3 = mask0 + 6;
  480.  
  481.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  482.         LD_SB4(src, src_stride, src0, src2, src4, src6);
  483.         LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
  484.         src += (4 * src_stride);
  485.         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
  486.  
  487.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  488.                    vec0, vec1, vec2, vec3);
  489.         dst0 = const_vec;
  490.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  491.                      dst0, dst0, dst0, dst0);
  492.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  493.                    vec0, vec1, vec2, vec3);
  494.         dst1 = const_vec;
  495.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  496.                      dst1, dst1, dst1, dst1);
  497.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  498.                    vec0, vec1, vec2, vec3);
  499.         dst2 = const_vec;
  500.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  501.                      dst2, dst2, dst2, dst2);
  502.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  503.                    vec0, vec1, vec2, vec3);
  504.         dst3 = const_vec;
  505.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  506.                      dst3, dst3, dst3, dst3);
  507.         VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
  508.                    vec0, vec1, vec2, vec3);
  509.         dst4 = const_vec;
  510.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  511.                      dst4, dst4, dst4, dst4);
  512.         VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3,
  513.                    vec0, vec1, vec2, vec3);
  514.         dst5 = const_vec;
  515.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  516.                      dst5, dst5, dst5, dst5);
  517.         VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3,
  518.                    vec0, vec1, vec2, vec3);
  519.         dst6 = const_vec;
  520.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  521.                      dst6, dst6, dst6, dst6);
  522.         VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3,
  523.                    vec0, vec1, vec2, vec3);
  524.         dst7 = const_vec;
  525.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  526.                      dst7, dst7, dst7, dst7);
  527.  
  528.         ST_SH4(dst0, dst2, dst4, dst6, dst, dst_stride);
  529.         ST_SH4(dst1, dst3, dst5, dst7, dst + 8, dst_stride);
  530.         dst += (4 * dst_stride);
  531.     }
  532. }
  533.  
  534. static void hevc_hz_8t_24w_msa(uint8_t *src, int32_t src_stride,
  535.                                int16_t *dst, int32_t dst_stride,
  536.                                const int8_t *filter, int32_t height)
  537. {
  538.     uint32_t loop_cnt;
  539.     v16i8 src0, src1, src2, src3;
  540.     v8i16 filt0, filt1, filt2, filt3;
  541.     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
  542.     v16i8 vec0, vec1, vec2, vec3;
  543.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  544.     v8i16 filter_vec, const_vec;
  545.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  546.  
  547.     src -= 3;
  548.     filter_vec = LD_SH(filter);
  549.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  550.  
  551.     mask1 = mask0 + 2;
  552.     mask2 = mask0 + 4;
  553.     mask3 = mask0 + 6;
  554.     mask4 = mask0 + 8;
  555.     mask5 = mask0 + 10;
  556.     mask6 = mask0 + 12;
  557.     mask7 = mask0 + 14;
  558.  
  559.     const_vec = __msa_ldi_h(128);
  560.     const_vec <<= 6;
  561.  
  562.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  563.         LD_SB2(src, 16, src0, src1);
  564.         src += src_stride;
  565.         LD_SB2(src, 16, src2, src3);
  566.         src += src_stride;
  567.         XORI_B4_128_SB(src0, src1, src2, src3);
  568.  
  569.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  570.                    vec0, vec1, vec2, vec3);
  571.         dst0 = const_vec;
  572.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  573.                      dst0, dst0, dst0, dst0);
  574.         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
  575.                    vec0, vec1, vec2, vec3);
  576.         dst1 = const_vec;
  577.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  578.                      dst1, dst1, dst1, dst1);
  579.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  580.                    vec0, vec1, vec2, vec3);
  581.         dst2 = const_vec;
  582.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  583.                      dst2, dst2, dst2, dst2);
  584.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  585.                    vec0, vec1, vec2, vec3);
  586.         dst3 = const_vec;
  587.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  588.                      dst3, dst3, dst3, dst3);
  589.         VSHF_B4_SB(src2, src3, mask4, mask5, mask6, mask7,
  590.                    vec0, vec1, vec2, vec3);
  591.         dst4 = const_vec;
  592.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  593.                      dst4, dst4, dst4, dst4);
  594.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  595.                    vec0, vec1, vec2, vec3);
  596.         dst5 = const_vec;
  597.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  598.                      dst5, dst5, dst5, dst5);
  599.  
  600.         ST_SH2(dst0, dst1, dst, 8);
  601.         ST_SH(dst2, dst + 16);
  602.         dst += dst_stride;
  603.         ST_SH2(dst3, dst4, dst, 8);
  604.         ST_SH(dst5, dst + 16);
  605.         dst += dst_stride;
  606.     }
  607. }
  608.  
  609. static void hevc_hz_8t_32w_msa(uint8_t *src, int32_t src_stride,
  610.                                int16_t *dst, int32_t dst_stride,
  611.                                const int8_t *filter, int32_t height)
  612. {
  613.     uint32_t loop_cnt;
  614.     v16i8 src0, src1, src2;
  615.     v8i16 filt0, filt1, filt2, filt3;
  616.     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
  617.     v16i8 vec0, vec1, vec2, vec3;
  618.     v8i16 dst0, dst1, dst2, dst3;
  619.     v8i16 filter_vec, const_vec;
  620.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  621.  
  622.     src -= 3;
  623.     filter_vec = LD_SH(filter);
  624.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  625.  
  626.     mask1 = mask0 + 2;
  627.     mask2 = mask0 + 4;
  628.     mask3 = mask0 + 6;
  629.     mask4 = mask0 + 8;
  630.     mask5 = mask0 + 10;
  631.     mask6 = mask0 + 12;
  632.     mask7 = mask0 + 14;
  633.  
  634.     const_vec = __msa_ldi_h(128);
  635.     const_vec <<= 6;
  636.  
  637.     for (loop_cnt = height; loop_cnt--;) {
  638.         LD_SB2(src, 16, src0, src1);
  639.         src2 = LD_SB(src + 24);
  640.         src += src_stride;
  641.         XORI_B3_128_SB(src0, src1, src2);
  642.  
  643.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  644.                    vec0, vec1, vec2, vec3);
  645.         dst0 = const_vec;
  646.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  647.                      dst0, dst0, dst0, dst0);
  648.         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
  649.                    vec0, vec1, vec2, vec3);
  650.         dst1 = const_vec;
  651.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  652.                      dst1, dst1, dst1, dst1);
  653.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  654.                    vec0, vec1, vec2, vec3);
  655.         dst2 = const_vec;
  656.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  657.                      dst2, dst2, dst2, dst2);
  658.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  659.                    vec0, vec1, vec2, vec3);
  660.         dst3 = const_vec;
  661.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  662.                      dst3, dst3, dst3, dst3);
  663.  
  664.         ST_SH4(dst0, dst1, dst2, dst3, dst, 8);
  665.         dst += dst_stride;
  666.     }
  667. }
  668.  
  669. static void hevc_hz_8t_48w_msa(uint8_t *src, int32_t src_stride,
  670.                                int16_t *dst, int32_t dst_stride,
  671.                                const int8_t *filter, int32_t height)
  672. {
  673.     uint32_t loop_cnt;
  674.     v16i8 src0, src1, src2, src3;
  675.     v8i16 filt0, filt1, filt2, filt3;
  676.     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
  677.     v16i8 vec0, vec1, vec2, vec3;
  678.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  679.     v8i16 filter_vec, const_vec;
  680.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  681.  
  682.     src -= 3;
  683.     filter_vec = LD_SH(filter);
  684.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  685.  
  686.     mask1 = mask0 + 2;
  687.     mask2 = mask0 + 4;
  688.     mask3 = mask0 + 6;
  689.     mask4 = mask0 + 8;
  690.     mask5 = mask0 + 10;
  691.     mask6 = mask0 + 12;
  692.     mask7 = mask0 + 14;
  693.  
  694.     const_vec = __msa_ldi_h(128);
  695.     const_vec <<= 6;
  696.  
  697.     for (loop_cnt = height; loop_cnt--;) {
  698.         LD_SB3(src, 16, src0, src1, src2);
  699.         src3 = LD_SB(src + 40);
  700.         src += src_stride;
  701.         XORI_B4_128_SB(src0, src1, src2, src3);
  702.  
  703.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  704.                    vec0, vec1, vec2, vec3);
  705.         dst0 = const_vec;
  706.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  707.                      dst0, dst0, dst0, dst0);
  708.         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
  709.                    vec0, vec1, vec2, vec3);
  710.         dst1 = const_vec;
  711.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  712.                      dst1, dst1, dst1, dst1);
  713.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  714.                    vec0, vec1, vec2, vec3);
  715.         dst2 = const_vec;
  716.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  717.                      dst2, dst2, dst2, dst2);
  718.         VSHF_B4_SB(src1, src2, mask4, mask5, mask6, mask7,
  719.                    vec0, vec1, vec2, vec3);
  720.         dst3 = const_vec;
  721.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  722.                      dst3, dst3, dst3, dst3);
  723.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  724.                    vec0, vec1, vec2, vec3);
  725.         dst4 = const_vec;
  726.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  727.                      dst4, dst4, dst4, dst4);
  728.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  729.                    vec0, vec1, vec2, vec3);
  730.         dst5 = const_vec;
  731.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  732.                      dst5, dst5, dst5, dst5);
  733.  
  734.         ST_SH6(dst0, dst1, dst2, dst3, dst4, dst5, dst, 8);
  735.         dst += dst_stride;
  736.     }
  737. }
  738.  
  739. static void hevc_hz_8t_64w_msa(uint8_t *src, int32_t src_stride,
  740.                                int16_t *dst, int32_t dst_stride,
  741.                                const int8_t *filter, int32_t height)
  742. {
  743.     uint32_t loop_cnt;
  744.     v16i8 src0, src1, src2, src3, src4;
  745.     v8i16 filt0, filt1, filt2, filt3;
  746.     v16i8 mask1, mask2, mask3, mask4, mask5, mask6, mask7;
  747.     v16i8 vec0, vec1, vec2, vec3;
  748.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
  749.     v8i16 filter_vec, const_vec;
  750.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  751.  
  752.     src -= 3;
  753.  
  754.     filter_vec = LD_SH(filter);
  755.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  756.  
  757.     mask1 = mask0 + 2;
  758.     mask2 = mask0 + 4;
  759.     mask3 = mask0 + 6;
  760.     mask4 = mask0 + 8;
  761.     mask5 = mask0 + 10;
  762.     mask6 = mask0 + 12;
  763.     mask7 = mask0 + 14;
  764.  
  765.     const_vec = __msa_ldi_h(128);
  766.     const_vec <<= 6;
  767.  
  768.     for (loop_cnt = height; loop_cnt--;) {
  769.         LD_SB4(src, 16, src0, src1, src2, src3);
  770.         src4 = LD_SB(src + 56);
  771.         src += src_stride;
  772.         XORI_B5_128_SB(src0, src1, src2, src3, src4);
  773.  
  774.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  775.                    vec0, vec1, vec2, vec3);
  776.         dst0 = const_vec;
  777.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  778.                      dst0, dst0, dst0, dst0);
  779.         ST_SH(dst0, dst);
  780.  
  781.         VSHF_B4_SB(src0, src1, mask4, mask5, mask6, mask7,
  782.                    vec0, vec1, vec2, vec3);
  783.         dst1 = const_vec;
  784.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  785.                      dst1, dst1, dst1, dst1);
  786.         ST_SH(dst1, dst + 8);
  787.  
  788.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  789.                    vec0, vec1, vec2, vec3);
  790.         dst2 = const_vec;
  791.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  792.                      dst2, dst2, dst2, dst2);
  793.         ST_SH(dst2, dst + 16);
  794.  
  795.         VSHF_B4_SB(src1, src2, mask4, mask5, mask6, mask7,
  796.                    vec0, vec1, vec2, vec3);
  797.         dst3 = const_vec;
  798.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  799.                      dst3, dst3, dst3, dst3);
  800.         ST_SH(dst3, dst + 24);
  801.  
  802.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  803.                    vec0, vec1, vec2, vec3);
  804.         dst4 = const_vec;
  805.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  806.                      dst4, dst4, dst4, dst4);
  807.         ST_SH(dst4, dst + 32);
  808.  
  809.         VSHF_B4_SB(src2, src3, mask4, mask5, mask6, mask7,
  810.                    vec0, vec1, vec2, vec3);
  811.         dst5 = const_vec;
  812.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  813.                      dst5, dst5, dst5, dst5);
  814.         ST_SH(dst5, dst + 40);
  815.  
  816.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  817.                    vec0, vec1, vec2, vec3);
  818.         dst6 = const_vec;
  819.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  820.                      dst6, dst6, dst6, dst6);
  821.         ST_SH(dst6, dst + 48);
  822.  
  823.         VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
  824.                    vec0, vec1, vec2, vec3);
  825.         dst7 = const_vec;
  826.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  827.                      dst7, dst7, dst7, dst7);
  828.         ST_SH(dst7, dst + 56);
  829.         dst += dst_stride;
  830.     }
  831. }
  832.  
  833. static void hevc_vt_8t_4w_msa(uint8_t *src, int32_t src_stride,
  834.                               int16_t *dst, int32_t dst_stride,
  835.                               const int8_t *filter, int32_t height)
  836. {
  837.     int32_t loop_cnt;
  838.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  839.     v16i8 src9, src10, src11, src12, src13, src14;
  840.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  841.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  842.     v16i8 src1110_r, src1211_r, src1312_r, src1413_r;
  843.     v16i8 src2110, src4332, src6554, src8776, src10998;
  844.     v16i8 src12111110, src14131312;
  845.     v8i16 dst10, dst32, dst54, dst76;
  846.     v8i16 filt0, filt1, filt2, filt3;
  847.     v8i16 filter_vec, const_vec;
  848.  
  849.     src -= (3 * src_stride);
  850.  
  851.     const_vec = __msa_ldi_h(128);
  852.     const_vec <<= 6;
  853.  
  854.     filter_vec = LD_SH(filter);
  855.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  856.  
  857.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  858.     src += (7 * src_stride);
  859.     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  860.                src10_r, src32_r, src54_r, src21_r);
  861.     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
  862.     ILVR_D3_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r,
  863.                src2110, src4332, src6554);
  864.     XORI_B3_128_SB(src2110, src4332, src6554);
  865.  
  866.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  867.         LD_SB8(src, src_stride,
  868.                src7, src8, src9, src10, src11, src12, src13, src14);
  869.         src += (8 * src_stride);
  870.  
  871.         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  872.                    src76_r, src87_r, src98_r, src109_r);
  873.         ILVR_B4_SB(src11, src10, src12, src11, src13, src12, src14, src13,
  874.                    src1110_r, src1211_r, src1312_r, src1413_r);
  875.         ILVR_D4_SB(src87_r, src76_r, src109_r, src98_r,
  876.                    src1211_r, src1110_r, src1413_r, src1312_r,
  877.                    src8776, src10998, src12111110, src14131312);
  878.         XORI_B4_128_SB(src8776, src10998, src12111110, src14131312);
  879.  
  880.         dst10 = const_vec;
  881.         DPADD_SB4_SH(src2110, src4332, src6554, src8776,
  882.                      filt0, filt1, filt2, filt3, dst10, dst10, dst10, dst10);
  883.         dst32 = const_vec;
  884.         DPADD_SB4_SH(src4332, src6554, src8776, src10998,
  885.                      filt0, filt1, filt2, filt3, dst32, dst32, dst32, dst32);
  886.         dst54 = const_vec;
  887.         DPADD_SB4_SH(src6554, src8776, src10998, src12111110,
  888.                      filt0, filt1, filt2, filt3, dst54, dst54, dst54, dst54);
  889.         dst76 = const_vec;
  890.         DPADD_SB4_SH(src8776, src10998, src12111110, src14131312,
  891.                      filt0, filt1, filt2, filt3, dst76, dst76, dst76, dst76);
  892.  
  893.         ST8x8_UB(dst10, dst32, dst54, dst76, dst, 2 * dst_stride);
  894.         dst += (8 * dst_stride);
  895.  
  896.         src2110 = src10998;
  897.         src4332 = src12111110;
  898.         src6554 = src14131312;
  899.         src6 = src14;
  900.     }
  901. }
  902.  
  903. static void hevc_vt_8t_8w_msa(uint8_t *src, int32_t src_stride,
  904.                               int16_t *dst, int32_t dst_stride,
  905.                               const int8_t *filter, int32_t height)
  906. {
  907.     int32_t loop_cnt;
  908.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
  909.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  910.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  911.     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
  912.     v8i16 filter_vec, const_vec;
  913.     v8i16 filt0, filt1, filt2, filt3;
  914.  
  915.     src -= (3 * src_stride);
  916.     const_vec = __msa_ldi_h(128);
  917.     const_vec <<= 6;
  918.  
  919.     filter_vec = LD_SH(filter);
  920.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  921.  
  922.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  923.     src += (7 * src_stride);
  924.     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  925.     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  926.                src10_r, src32_r, src54_r, src21_r);
  927.     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
  928.  
  929.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  930.         LD_SB4(src, src_stride, src7, src8, src9, src10);
  931.         src += (4 * src_stride);
  932.         XORI_B4_128_SB(src7, src8, src9, src10);
  933.         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  934.                    src76_r, src87_r, src98_r, src109_r);
  935.  
  936.         dst0_r = const_vec;
  937.         DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
  938.                      filt0, filt1, filt2, filt3,
  939.                      dst0_r, dst0_r, dst0_r, dst0_r);
  940.         dst1_r = const_vec;
  941.         DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
  942.                      filt0, filt1, filt2, filt3,
  943.                      dst1_r, dst1_r, dst1_r, dst1_r);
  944.         dst2_r = const_vec;
  945.         DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
  946.                      filt0, filt1, filt2, filt3,
  947.                      dst2_r, dst2_r, dst2_r, dst2_r);
  948.         dst3_r = const_vec;
  949.         DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
  950.                      filt0, filt1, filt2, filt3,
  951.                      dst3_r, dst3_r, dst3_r, dst3_r);
  952.  
  953.         ST_SH4(dst0_r, dst1_r, dst2_r, dst3_r, dst, dst_stride);
  954.         dst += (4 * dst_stride);
  955.  
  956.         src10_r = src54_r;
  957.         src32_r = src76_r;
  958.         src54_r = src98_r;
  959.         src21_r = src65_r;
  960.         src43_r = src87_r;
  961.         src65_r = src109_r;
  962.         src6 = src10;
  963.     }
  964. }
  965.  
  966. static void hevc_vt_8t_12w_msa(uint8_t *src, int32_t src_stride,
  967.                                int16_t *dst, int32_t dst_stride,
  968.                                const int8_t *filter, int32_t height)
  969. {
  970.     int32_t loop_cnt;
  971.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
  972.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  973.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  974.     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
  975.     v16i8 src10_l, src32_l, src54_l, src76_l, src98_l;
  976.     v16i8 src21_l, src43_l, src65_l, src87_l, src109_l;
  977.     v16i8 src2110, src4332, src6554, src8776, src10998;
  978.     v8i16 dst0_l, dst1_l;
  979.     v8i16 filter_vec, const_vec;
  980.     v8i16 filt0, filt1, filt2, filt3;
  981.  
  982.     src -= (3 * src_stride);
  983.     const_vec = __msa_ldi_h(128);
  984.     const_vec <<= 6;
  985.  
  986.     filter_vec = LD_SH(filter);
  987.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  988.  
  989.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  990.     src += (7 * src_stride);
  991.     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  992.     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  993.                src10_r, src32_r, src54_r, src21_r);
  994.     ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
  995.     ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  996.                src10_l, src32_l, src54_l, src21_l);
  997.     ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
  998.     ILVR_D3_SB(src21_l, src10_l, src43_l, src32_l, src65_l, src54_l,
  999.                src2110, src4332, src6554);
  1000.  
  1001.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1002.         LD_SB4(src, src_stride, src7, src8, src9, src10);
  1003.         src += (4 * src_stride);
  1004.         XORI_B4_128_SB(src7, src8, src9, src10);
  1005.         ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  1006.                    src76_r, src87_r, src98_r, src109_r);
  1007.         ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  1008.                    src76_l, src87_l, src98_l, src109_l);
  1009.         ILVR_D2_SB(src87_l, src76_l, src109_l, src98_l, src8776, src10998);
  1010.  
  1011.         dst0_r = const_vec;
  1012.         DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
  1013.                      filt0, filt1, filt2, filt3,
  1014.                      dst0_r, dst0_r, dst0_r, dst0_r);
  1015.         dst1_r = const_vec;
  1016.         DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
  1017.                      filt0, filt1, filt2, filt3,
  1018.                      dst1_r, dst1_r, dst1_r, dst1_r);
  1019.         dst2_r = const_vec;
  1020.         DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
  1021.                      filt0, filt1, filt2, filt3,
  1022.                      dst2_r, dst2_r, dst2_r, dst2_r);
  1023.         dst3_r = const_vec;
  1024.         DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
  1025.                      filt0, filt1, filt2, filt3,
  1026.                      dst3_r, dst3_r, dst3_r, dst3_r);
  1027.         dst0_l = const_vec;
  1028.         DPADD_SB4_SH(src2110, src4332, src6554, src8776,
  1029.                      filt0, filt1, filt2, filt3,
  1030.                      dst0_l, dst0_l, dst0_l, dst0_l);
  1031.         dst1_l = const_vec;
  1032.         DPADD_SB4_SH(src4332, src6554, src8776, src10998,
  1033.                      filt0, filt1, filt2, filt3,
  1034.                      dst1_l, dst1_l, dst1_l, dst1_l);
  1035.  
  1036.         ST_SH4(dst0_r, dst1_r, dst2_r, dst3_r, dst, dst_stride);
  1037.         ST8x4_UB(dst0_l, dst1_l, dst + 8, 2 * dst_stride);
  1038.         dst += (4 * dst_stride);
  1039.  
  1040.         src10_r = src54_r;
  1041.         src32_r = src76_r;
  1042.         src54_r = src98_r;
  1043.         src21_r = src65_r;
  1044.         src43_r = src87_r;
  1045.         src65_r = src109_r;
  1046.         src2110 = src6554;
  1047.         src4332 = src8776;
  1048.         src6554 = src10998;
  1049.         src6 = src10;
  1050.     }
  1051. }
  1052.  
  1053. static void hevc_vt_8t_16multx4mult_msa(uint8_t *src,
  1054.                                         int32_t src_stride,
  1055.                                         int16_t *dst,
  1056.                                         int32_t dst_stride,
  1057.                                         const int8_t *filter,
  1058.                                         int32_t height,
  1059.                                         int32_t width)
  1060. {
  1061.     uint8_t *src_tmp;
  1062.     int16_t *dst_tmp;
  1063.     int32_t loop_cnt, cnt;
  1064.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
  1065.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  1066.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  1067.     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
  1068.     v16i8 src10_l, src32_l, src54_l, src76_l, src98_l;
  1069.     v16i8 src21_l, src43_l, src65_l, src87_l, src109_l;
  1070.     v8i16 dst0_l, dst1_l, dst2_l, dst3_l;
  1071.     v8i16 filter_vec, const_vec;
  1072.     v8i16 filt0, filt1, filt2, filt3;
  1073.  
  1074.     src -= (3 * src_stride);
  1075.     const_vec = __msa_ldi_h(128);
  1076.     const_vec <<= 6;
  1077.  
  1078.     filter_vec = LD_SH(filter);
  1079.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1080.  
  1081.     for (cnt = width >> 4; cnt--;) {
  1082.         src_tmp = src;
  1083.         dst_tmp = dst;
  1084.  
  1085.         LD_SB7(src_tmp, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1086.         src_tmp += (7 * src_stride);
  1087.         XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  1088.         ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  1089.                    src10_r, src32_r, src54_r, src21_r);
  1090.         ILVR_B2_SB(src4, src3, src6, src5, src43_r, src65_r);
  1091.         ILVL_B4_SB(src1, src0, src3, src2, src5, src4, src2, src1,
  1092.                    src10_l, src32_l, src54_l, src21_l);
  1093.         ILVL_B2_SB(src4, src3, src6, src5, src43_l, src65_l);
  1094.  
  1095.         for (loop_cnt = (height >> 2); loop_cnt--;) {
  1096.             LD_SB4(src_tmp, src_stride, src7, src8, src9, src10);
  1097.             src_tmp += (4 * src_stride);
  1098.             XORI_B4_128_SB(src7, src8, src9, src10);
  1099.             ILVR_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  1100.                        src76_r, src87_r, src98_r, src109_r);
  1101.             ILVL_B4_SB(src7, src6, src8, src7, src9, src8, src10, src9,
  1102.                        src76_l, src87_l, src98_l, src109_l);
  1103.  
  1104.             dst0_r = const_vec;
  1105.             DPADD_SB4_SH(src10_r, src32_r, src54_r, src76_r,
  1106.                          filt0, filt1, filt2, filt3,
  1107.                          dst0_r, dst0_r, dst0_r, dst0_r);
  1108.             dst1_r = const_vec;
  1109.             DPADD_SB4_SH(src21_r, src43_r, src65_r, src87_r,
  1110.                          filt0, filt1, filt2, filt3,
  1111.                          dst1_r, dst1_r, dst1_r, dst1_r);
  1112.             dst2_r = const_vec;
  1113.             DPADD_SB4_SH(src32_r, src54_r, src76_r, src98_r,
  1114.                          filt0, filt1, filt2, filt3,
  1115.                          dst2_r, dst2_r, dst2_r, dst2_r);
  1116.             dst3_r = const_vec;
  1117.             DPADD_SB4_SH(src43_r, src65_r, src87_r, src109_r,
  1118.                          filt0, filt1, filt2, filt3,
  1119.                          dst3_r, dst3_r, dst3_r, dst3_r);
  1120.             dst0_l = const_vec;
  1121.             DPADD_SB4_SH(src10_l, src32_l, src54_l, src76_l,
  1122.                          filt0, filt1, filt2, filt3,
  1123.                          dst0_l, dst0_l, dst0_l, dst0_l);
  1124.             dst1_l = const_vec;
  1125.             DPADD_SB4_SH(src21_l, src43_l, src65_l, src87_l,
  1126.                          filt0, filt1, filt2, filt3,
  1127.                          dst1_l, dst1_l, dst1_l, dst1_l);
  1128.             dst2_l = const_vec;
  1129.             DPADD_SB4_SH(src32_l, src54_l, src76_l, src98_l,
  1130.                          filt0, filt1, filt2, filt3,
  1131.                          dst2_l, dst2_l, dst2_l, dst2_l);
  1132.             dst3_l = const_vec;
  1133.             DPADD_SB4_SH(src43_l, src65_l, src87_l, src109_l,
  1134.                          filt0, filt1, filt2, filt3,
  1135.                          dst3_l, dst3_l, dst3_l, dst3_l);
  1136.  
  1137.             ST_SH4(dst0_r, dst1_r, dst2_r, dst3_r, dst_tmp, dst_stride);
  1138.             ST_SH4(dst0_l, dst1_l, dst2_l, dst3_l, dst_tmp + 8, dst_stride);
  1139.             dst_tmp += (4 * dst_stride);
  1140.  
  1141.             src10_r = src54_r;
  1142.             src32_r = src76_r;
  1143.             src54_r = src98_r;
  1144.             src21_r = src65_r;
  1145.             src43_r = src87_r;
  1146.             src65_r = src109_r;
  1147.             src10_l = src54_l;
  1148.             src32_l = src76_l;
  1149.             src54_l = src98_l;
  1150.             src21_l = src65_l;
  1151.             src43_l = src87_l;
  1152.             src65_l = src109_l;
  1153.             src6 = src10;
  1154.         }
  1155.  
  1156.         src += 16;
  1157.         dst += 16;
  1158.     }
  1159. }
  1160.  
  1161. static void hevc_vt_8t_16w_msa(uint8_t *src, int32_t src_stride,
  1162.                                int16_t *dst, int32_t dst_stride,
  1163.                                const int8_t *filter, int32_t height)
  1164. {
  1165.     hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
  1166.                                 filter, height, 16);
  1167. }
  1168.  
  1169. static void hevc_vt_8t_24w_msa(uint8_t *src, int32_t src_stride,
  1170.                                int16_t *dst, int32_t dst_stride,
  1171.                                const int8_t *filter, int32_t height)
  1172. {
  1173.     hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
  1174.                                 filter, height, 16);
  1175.     hevc_vt_8t_8w_msa(src + 16, src_stride, dst + 16, dst_stride,
  1176.                       filter, height);
  1177. }
  1178.  
  1179. static void hevc_vt_8t_32w_msa(uint8_t *src, int32_t src_stride,
  1180.                                int16_t *dst, int32_t dst_stride,
  1181.                                const int8_t *filter, int32_t height)
  1182. {
  1183.     hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
  1184.                                 filter, height, 32);
  1185. }
  1186.  
  1187. static void hevc_vt_8t_48w_msa(uint8_t *src, int32_t src_stride,
  1188.                                int16_t *dst, int32_t dst_stride,
  1189.                                const int8_t *filter, int32_t height)
  1190. {
  1191.     hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
  1192.                                 filter, height, 48);
  1193. }
  1194.  
  1195. static void hevc_vt_8t_64w_msa(uint8_t *src, int32_t src_stride,
  1196.                                int16_t *dst, int32_t dst_stride,
  1197.                                const int8_t *filter, int32_t height)
  1198. {
  1199.     hevc_vt_8t_16multx4mult_msa(src, src_stride, dst, dst_stride,
  1200.                                 filter, height, 64);
  1201. }
  1202.  
  1203. static void hevc_hv_8t_4w_msa(uint8_t *src, int32_t src_stride,
  1204.                               int16_t *dst, int32_t dst_stride,
  1205.                               const int8_t *filter_x, const int8_t *filter_y,
  1206.                               int32_t height)
  1207. {
  1208.     uint32_t loop_cnt;
  1209.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1210.     v8i16 filt0, filt1, filt2, filt3;
  1211.     v4i32 filt_h0, filt_h1, filt_h2, filt_h3;
  1212.     v16i8 mask1, mask2, mask3;
  1213.     v8i16 filter_vec, const_vec;
  1214.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
  1215.     v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
  1216.     v8i16 dst30, dst41, dst52, dst63, dst66, dst87;
  1217.     v4i32 dst0_r, dst1_r;
  1218.     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
  1219.     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
  1220.     v16i8 mask0 = {
  1221.         0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20
  1222.     };
  1223.     v8u16 mask4 = { 0, 4, 1, 5, 2, 6, 3, 7 };
  1224.  
  1225.     src -= ((3 * src_stride) + 3);
  1226.     filter_vec = LD_SH(filter_x);
  1227.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1228.  
  1229.     filter_vec = LD_SH(filter_y);
  1230.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  1231.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  1232.  
  1233.     SPLATI_W4_SW(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
  1234.  
  1235.     mask1 = mask0 + 2;
  1236.     mask2 = mask0 + 4;
  1237.     mask3 = mask0 + 6;
  1238.  
  1239.     const_vec = __msa_ldi_h(128);
  1240.     const_vec <<= 6;
  1241.  
  1242.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1243.     src += (7 * src_stride);
  1244.     XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  1245.  
  1246.     VSHF_B4_SB(src0, src3, mask0, mask1, mask2, mask3, vec0, vec1, vec2, vec3);
  1247.     VSHF_B4_SB(src1, src4, mask0, mask1, mask2, mask3, vec4, vec5, vec6, vec7);
  1248.     VSHF_B4_SB(src2, src5, mask0, mask1, mask2, mask3,
  1249.                vec8, vec9, vec10, vec11);
  1250.     VSHF_B4_SB(src3, src6, mask0, mask1, mask2, mask3,
  1251.                vec12, vec13, vec14, vec15);
  1252.     dst30 = const_vec;
  1253.     DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1254.                  dst30, dst30, dst30, dst30);
  1255.     dst41 = const_vec;
  1256.     DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
  1257.                  dst41, dst41, dst41, dst41);
  1258.     dst52 = const_vec;
  1259.     DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
  1260.                  dst52, dst52, dst52, dst52);
  1261.     dst63 = const_vec;
  1262.     DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2, filt3,
  1263.                  dst63, dst63, dst63, dst63);
  1264.  
  1265.     ILVR_H3_SH(dst41, dst30, dst52, dst41, dst63, dst52,
  1266.                dst10_r, dst21_r, dst32_r);
  1267.     dst43_r = __msa_ilvl_h(dst41, dst30);
  1268.     dst54_r = __msa_ilvl_h(dst52, dst41);
  1269.     dst65_r = __msa_ilvl_h(dst63, dst52);
  1270.     dst66 = (v8i16) __msa_splati_d((v2i64) dst63, 1);
  1271.  
  1272.     for (loop_cnt = height >> 1; loop_cnt--;) {
  1273.         LD_SB2(src, src_stride, src7, src8);
  1274.         src += (2 * src_stride);
  1275.         XORI_B2_128_SB(src7, src8);
  1276.  
  1277.         VSHF_B4_SB(src7, src8, mask0, mask1, mask2, mask3,
  1278.                    vec0, vec1, vec2, vec3);
  1279.         dst87 = const_vec;
  1280.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1281.                      dst87, dst87, dst87, dst87);
  1282.         dst76_r = __msa_ilvr_h(dst87, dst66);
  1283.         dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
  1284.                                 filt_h0, filt_h1, filt_h2, filt_h3);
  1285.         dst87_r = __msa_vshf_h((v8i16) mask4, dst87, dst87);
  1286.         dst1_r = HEVC_FILT_8TAP(dst21_r, dst43_r, dst65_r, dst87_r,
  1287.                                 filt_h0, filt_h1, filt_h2, filt_h3);
  1288.         dst0_r >>= 6;
  1289.         dst1_r >>= 6;
  1290.  
  1291.         dst0_r = (v4i32) __msa_pckev_h((v8i16) dst1_r, (v8i16) dst0_r);
  1292.         ST8x2_UB(dst0_r, dst, (2 * dst_stride));
  1293.         dst += (2 * dst_stride);
  1294.  
  1295.         dst10_r = dst32_r;
  1296.         dst32_r = dst54_r;
  1297.         dst54_r = dst76_r;
  1298.         dst21_r = dst43_r;
  1299.         dst43_r = dst65_r;
  1300.         dst65_r = dst87_r;
  1301.         dst66 = (v8i16) __msa_splati_d((v2i64) dst87, 1);
  1302.     }
  1303. }
  1304.  
  1305. static void hevc_hv_8t_8multx2mult_msa(uint8_t *src,
  1306.                                        int32_t src_stride,
  1307.                                        int16_t *dst,
  1308.                                        int32_t dst_stride,
  1309.                                        const int8_t *filter_x,
  1310.                                        const int8_t *filter_y,
  1311.                                        int32_t height, int32_t width)
  1312. {
  1313.     uint32_t loop_cnt, cnt;
  1314.     uint8_t *src_tmp;
  1315.     int16_t *dst_tmp;
  1316.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1317.     v8i16 filt0, filt1, filt2, filt3;
  1318.     v4i32 filt_h0, filt_h1, filt_h2, filt_h3;
  1319.     v16i8 mask1, mask2, mask3;
  1320.     v8i16 filter_vec, const_vec;
  1321.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
  1322.     v16i8 vec8, vec9, vec10, vec11, vec12, vec13, vec14, vec15;
  1323.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
  1324.     v4i32 dst0_r, dst0_l;
  1325.     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
  1326.     v8i16 dst10_l, dst32_l, dst54_l, dst76_l;
  1327.     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
  1328.     v8i16 dst21_l, dst43_l, dst65_l, dst87_l;
  1329.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1330.  
  1331.     src -= ((3 * src_stride) + 3);
  1332.     filter_vec = LD_SH(filter_x);
  1333.     SPLATI_H4_SH(filter_vec, 0, 1, 2, 3, filt0, filt1, filt2, filt3);
  1334.  
  1335.     filter_vec = LD_SH(filter_y);
  1336.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  1337.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  1338.  
  1339.     SPLATI_W4_SW(filter_vec, filt_h0, filt_h1, filt_h2, filt_h3);
  1340.  
  1341.     mask1 = mask0 + 2;
  1342.     mask2 = mask0 + 4;
  1343.     mask3 = mask0 + 6;
  1344.  
  1345.     const_vec = __msa_ldi_h(128);
  1346.     const_vec <<= 6;
  1347.  
  1348.     for (cnt = width >> 3; cnt--;) {
  1349.         src_tmp = src;
  1350.         dst_tmp = dst;
  1351.  
  1352.         LD_SB7(src_tmp, src_stride, src0, src1, src2, src3, src4, src5, src6);
  1353.         src_tmp += (7 * src_stride);
  1354.         XORI_B7_128_SB(src0, src1, src2, src3, src4, src5, src6);
  1355.  
  1356.         /* row 0 row 1 row 2 row 3 */
  1357.         VSHF_B4_SB(src0, src0, mask0, mask1, mask2, mask3,
  1358.                    vec0, vec1, vec2, vec3);
  1359.         VSHF_B4_SB(src1, src1, mask0, mask1, mask2, mask3,
  1360.                    vec4, vec5, vec6, vec7);
  1361.         VSHF_B4_SB(src2, src2, mask0, mask1, mask2, mask3,
  1362.                    vec8, vec9, vec10, vec11);
  1363.         VSHF_B4_SB(src3, src3, mask0, mask1, mask2, mask3,
  1364.                    vec12, vec13, vec14, vec15);
  1365.         dst0 = const_vec;
  1366.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1367.                      dst0, dst0, dst0, dst0);
  1368.         dst1 = const_vec;
  1369.         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
  1370.                      dst1, dst1, dst1, dst1);
  1371.         dst2 = const_vec;
  1372.         DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
  1373.                      dst2, dst2, dst2, dst2);
  1374.         dst3 = const_vec;
  1375.         DPADD_SB4_SH(vec12, vec13, vec14, vec15, filt0, filt1, filt2, filt3,
  1376.                      dst3, dst3, dst3, dst3);
  1377.  
  1378.         /* row 4 row 5 row 6 */
  1379.         VSHF_B4_SB(src4, src4, mask0, mask1, mask2, mask3,
  1380.                    vec0, vec1, vec2, vec3);
  1381.         VSHF_B4_SB(src5, src5, mask0, mask1, mask2, mask3,
  1382.                    vec4, vec5, vec6, vec7);
  1383.         VSHF_B4_SB(src6, src6, mask0, mask1, mask2, mask3,
  1384.                    vec8, vec9, vec10, vec11);
  1385.         dst4 = const_vec;
  1386.         DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1387.                      dst4, dst4, dst4, dst4);
  1388.         dst5 = const_vec;
  1389.         DPADD_SB4_SH(vec4, vec5, vec6, vec7, filt0, filt1, filt2, filt3,
  1390.                      dst5, dst5, dst5, dst5);
  1391.         dst6 = const_vec;
  1392.         DPADD_SB4_SH(vec8, vec9, vec10, vec11, filt0, filt1, filt2, filt3,
  1393.                      dst6, dst6, dst6, dst6);
  1394.  
  1395.         ILVR_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst2, dst1,
  1396.                    dst10_r, dst32_r, dst54_r, dst21_r);
  1397.         ILVR_H2_SH(dst4, dst3, dst6, dst5, dst43_r, dst65_r);
  1398.         ILVL_H4_SH(dst1, dst0, dst3, dst2, dst5, dst4, dst2, dst1,
  1399.                    dst10_l, dst32_l, dst54_l, dst21_l);
  1400.         ILVL_H2_SH(dst4, dst3, dst6, dst5, dst43_l, dst65_l);
  1401.  
  1402.         for (loop_cnt = height >> 1; loop_cnt--;) {
  1403.             LD_SB2(src_tmp, src_stride, src7, src8);
  1404.             XORI_B2_128_SB(src7, src8);
  1405.             src_tmp += 2 * src_stride;
  1406.  
  1407.             VSHF_B4_SB(src7, src7, mask0, mask1, mask2, mask3,
  1408.                        vec0, vec1, vec2, vec3);
  1409.             dst7 = const_vec;
  1410.             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1411.                          dst7, dst7, dst7, dst7);
  1412.  
  1413.             ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
  1414.             dst0_r = HEVC_FILT_8TAP(dst10_r, dst32_r, dst54_r, dst76_r,
  1415.                                     filt_h0, filt_h1, filt_h2, filt_h3);
  1416.             dst0_l = HEVC_FILT_8TAP(dst10_l, dst32_l, dst54_l, dst76_l,
  1417.                                     filt_h0, filt_h1, filt_h2, filt_h3);
  1418.             dst0_r >>= 6;
  1419.             dst0_l >>= 6;
  1420.  
  1421.             dst0_r = (v4i32) __msa_pckev_h((v8i16) dst0_l, (v8i16) dst0_r);
  1422.             ST_SW(dst0_r, dst_tmp);
  1423.             dst_tmp += dst_stride;
  1424.  
  1425.             VSHF_B4_SB(src8, src8, mask0, mask1, mask2, mask3,
  1426.                        vec0, vec1, vec2, vec3);
  1427.             dst8 = const_vec;
  1428.             DPADD_SB4_SH(vec0, vec1, vec2, vec3, filt0, filt1, filt2, filt3,
  1429.                          dst8, dst8, dst8, dst8);
  1430.  
  1431.             ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
  1432.             dst6 = dst8;
  1433.             dst0_r = HEVC_FILT_8TAP(dst21_r, dst43_r, dst65_r, dst87_r,
  1434.                                     filt_h0, filt_h1, filt_h2, filt_h3);
  1435.             dst0_l = HEVC_FILT_8TAP(dst21_l, dst43_l, dst65_l, dst87_l,
  1436.                                     filt_h0, filt_h1, filt_h2, filt_h3);
  1437.             dst0_r >>= 6;
  1438.             dst0_l >>= 6;
  1439.  
  1440.             dst0_r = (v4i32) __msa_pckev_h((v8i16) dst0_l, (v8i16) dst0_r);
  1441.             ST_SW(dst0_r, dst_tmp);
  1442.             dst_tmp += dst_stride;
  1443.  
  1444.             dst10_r = dst32_r;
  1445.             dst32_r = dst54_r;
  1446.             dst54_r = dst76_r;
  1447.             dst10_l = dst32_l;
  1448.             dst32_l = dst54_l;
  1449.             dst54_l = dst76_l;
  1450.             dst21_r = dst43_r;
  1451.             dst43_r = dst65_r;
  1452.             dst65_r = dst87_r;
  1453.             dst21_l = dst43_l;
  1454.             dst43_l = dst65_l;
  1455.             dst65_l = dst87_l;
  1456.         }
  1457.  
  1458.         src += 8;
  1459.         dst += 8;
  1460.     }
  1461. }
  1462.  
  1463. static void hevc_hv_8t_8w_msa(uint8_t *src, int32_t src_stride,
  1464.                               int16_t *dst, int32_t dst_stride,
  1465.                               const int8_t *filter_x, const int8_t *filter_y,
  1466.                               int32_t height)
  1467. {
  1468.     hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1469.                                filter_x, filter_y, height, 8);
  1470. }
  1471.  
  1472. static void hevc_hv_8t_12w_msa(uint8_t *src, int32_t src_stride,
  1473.                                int16_t *dst, int32_t dst_stride,
  1474.                                const int8_t *filter_x, const int8_t *filter_y,
  1475.                                int32_t height)
  1476. {
  1477.     hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1478.                                filter_x, filter_y, height, 8);
  1479.  
  1480.     hevc_hv_8t_4w_msa(src + 8, src_stride, dst + 8, dst_stride,
  1481.                       filter_x, filter_y, height);
  1482. }
  1483.  
  1484. static void hevc_hv_8t_16w_msa(uint8_t *src, int32_t src_stride,
  1485.                                int16_t *dst, int32_t dst_stride,
  1486.                                const int8_t *filter_x, const int8_t *filter_y,
  1487.                                int32_t height)
  1488. {
  1489.     hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1490.                                filter_x, filter_y, height, 16);
  1491. }
  1492.  
  1493. static void hevc_hv_8t_24w_msa(uint8_t *src, int32_t src_stride,
  1494.                                int16_t *dst, int32_t dst_stride,
  1495.                                const int8_t *filter_x, const int8_t *filter_y,
  1496.                                int32_t height)
  1497. {
  1498.     hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1499.                                filter_x, filter_y, height, 24);
  1500. }
  1501.  
  1502. static void hevc_hv_8t_32w_msa(uint8_t *src, int32_t src_stride,
  1503.                                int16_t *dst, int32_t dst_stride,
  1504.                                const int8_t *filter_x, const int8_t *filter_y,
  1505.                                int32_t height)
  1506. {
  1507.     hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1508.                                filter_x, filter_y, height, 32);
  1509. }
  1510.  
  1511. static void hevc_hv_8t_48w_msa(uint8_t *src, int32_t src_stride,
  1512.                                int16_t *dst, int32_t dst_stride,
  1513.                                const int8_t *filter_x, const int8_t *filter_y,
  1514.                                int32_t height)
  1515. {
  1516.     hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1517.                                filter_x, filter_y, height, 48);
  1518. }
  1519.  
  1520. static void hevc_hv_8t_64w_msa(uint8_t *src, int32_t src_stride,
  1521.                                int16_t *dst, int32_t dst_stride,
  1522.                                const int8_t *filter_x, const int8_t *filter_y,
  1523.                                int32_t height)
  1524. {
  1525.     hevc_hv_8t_8multx2mult_msa(src, src_stride, dst, dst_stride,
  1526.                                filter_x, filter_y, height, 64);
  1527. }
  1528.  
  1529. static void hevc_hz_4t_4x2_msa(uint8_t *src,
  1530.                                int32_t src_stride,
  1531.                                int16_t *dst,
  1532.                                int32_t dst_stride,
  1533.                                const int8_t *filter)
  1534. {
  1535.     v8i16 filt0, filt1;
  1536.     v16i8 src0, src1;
  1537.     v16i8 mask1, vec0, vec1;
  1538.     v8i16 dst0;
  1539.     v8i16 filter_vec, const_vec;
  1540.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  1541.  
  1542.     src -= 1;
  1543.  
  1544.     filter_vec = LD_SH(filter);
  1545.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1546.  
  1547.     mask1 = mask0 + 2;
  1548.  
  1549.     const_vec = __msa_ldi_h(128);
  1550.     const_vec <<= 6;
  1551.  
  1552.     LD_SB2(src, src_stride, src0, src1);
  1553.     XORI_B2_128_SB(src0, src1);
  1554.  
  1555.     VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
  1556.     dst0 = const_vec;
  1557.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1558.  
  1559.     ST8x2_UB(dst0, dst, 2 * dst_stride);
  1560. }
  1561.  
  1562. static void hevc_hz_4t_4x4_msa(uint8_t *src,
  1563.                                int32_t src_stride,
  1564.                                int16_t *dst,
  1565.                                int32_t dst_stride,
  1566.                                const int8_t *filter)
  1567. {
  1568.     v8i16 filt0, filt1;
  1569.     v16i8 src0, src1, src2, src3;
  1570.     v16i8 mask1, vec0, vec1;
  1571.     v8i16 dst0, dst1;
  1572.     v8i16 filter_vec, const_vec;
  1573.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  1574.  
  1575.     src -= 1;
  1576.  
  1577.     filter_vec = LD_SH(filter);
  1578.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1579.  
  1580.     mask1 = mask0 + 2;
  1581.  
  1582.     const_vec = __msa_ldi_h(128);
  1583.     const_vec <<= 6;
  1584.  
  1585.     LD_SB4(src, src_stride, src0, src1, src2, src3);
  1586.     XORI_B4_128_SB(src0, src1, src2, src3);
  1587.  
  1588.     VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
  1589.     dst0 = const_vec;
  1590.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1591.  
  1592.     VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
  1593.     dst1 = const_vec;
  1594.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  1595.  
  1596.     ST8x4_UB(dst0, dst1, dst, 2 * dst_stride);
  1597. }
  1598.  
  1599. static void hevc_hz_4t_4x8multiple_msa(uint8_t *src,
  1600.                                        int32_t src_stride,
  1601.                                        int16_t *dst,
  1602.                                        int32_t dst_stride,
  1603.                                        const int8_t *filter,
  1604.                                        int32_t height)
  1605. {
  1606.     uint32_t loop_cnt;
  1607.     v8i16 filt0, filt1;
  1608.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  1609.     v16i8 mask1, vec0, vec1;
  1610.     v8i16 dst0, dst1, dst2, dst3;
  1611.     v8i16 filter_vec, const_vec;
  1612.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
  1613.  
  1614.     src -= 1;
  1615.  
  1616.     filter_vec = LD_SH(filter);
  1617.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1618.  
  1619.     mask1 = mask0 + 2;
  1620.  
  1621.     const_vec = __msa_ldi_h(128);
  1622.     const_vec <<= 6;
  1623.  
  1624.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  1625.         LD_SB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  1626.         src += (8 * src_stride);
  1627.  
  1628.         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
  1629.  
  1630.         VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
  1631.         dst0 = const_vec;
  1632.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1633.         VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
  1634.         dst1 = const_vec;
  1635.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  1636.         VSHF_B2_SB(src4, src5, src4, src5, mask0, mask1, vec0, vec1);
  1637.         dst2 = const_vec;
  1638.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  1639.         VSHF_B2_SB(src6, src7, src6, src7, mask0, mask1, vec0, vec1);
  1640.         dst3 = const_vec;
  1641.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  1642.  
  1643.         ST8x8_UB(dst0, dst1, dst2, dst3, dst, 2 * dst_stride);
  1644.         dst += (8 * dst_stride);
  1645.     }
  1646. }
  1647.  
  1648. static void hevc_hz_4t_4w_msa(uint8_t *src,
  1649.                               int32_t src_stride,
  1650.                               int16_t *dst,
  1651.                               int32_t dst_stride,
  1652.                               const int8_t *filter,
  1653.                               int32_t height)
  1654. {
  1655.     if (2 == height) {
  1656.         hevc_hz_4t_4x2_msa(src, src_stride, dst, dst_stride, filter);
  1657.     } else if (4 == height) {
  1658.         hevc_hz_4t_4x4_msa(src, src_stride, dst, dst_stride, filter);
  1659.     } else if (0 == height % 8) {
  1660.         hevc_hz_4t_4x8multiple_msa(src, src_stride, dst, dst_stride,
  1661.                                    filter, height);
  1662.     }
  1663. }
  1664.  
  1665. static void hevc_hz_4t_6w_msa(uint8_t *src,
  1666.                               int32_t src_stride,
  1667.                               int16_t *dst,
  1668.                               int32_t dst_stride,
  1669.                               const int8_t *filter,
  1670.                               int32_t height)
  1671. {
  1672.     uint32_t loop_cnt;
  1673.     uint64_t dst_val0, dst_val1, dst_val2, dst_val3;
  1674.     uint32_t dst_val_int0, dst_val_int1, dst_val_int2, dst_val_int3;
  1675.     v8i16 filt0, filt1, dst0, dst1, dst2, dst3;
  1676.     v16i8 src0, src1, src2, src3;
  1677.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1678.     v16i8 mask1;
  1679.     v16i8 vec0, vec1;
  1680.     v8i16 filter_vec, const_vec;
  1681.  
  1682.     src -= 1;
  1683.  
  1684.     filter_vec = LD_SH(filter);
  1685.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1686.  
  1687.     mask1 = mask0 + 2;
  1688.  
  1689.     const_vec = __msa_ldi_h(128);
  1690.     const_vec <<= 6;
  1691.  
  1692.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1693.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  1694.         src += (4 * src_stride);
  1695.  
  1696.         XORI_B4_128_SB(src0, src1, src2, src3);
  1697.  
  1698.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  1699.         dst0 = const_vec;
  1700.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1701.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  1702.         dst1 = const_vec;
  1703.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  1704.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  1705.         dst2 = const_vec;
  1706.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  1707.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  1708.         dst3 = const_vec;
  1709.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  1710.  
  1711.         dst_val0 = __msa_copy_u_d((v2i64) dst0, 0);
  1712.         dst_val1 = __msa_copy_u_d((v2i64) dst1, 0);
  1713.         dst_val2 = __msa_copy_u_d((v2i64) dst2, 0);
  1714.         dst_val3 = __msa_copy_u_d((v2i64) dst3, 0);
  1715.  
  1716.         dst_val_int0 = __msa_copy_u_w((v4i32) dst0, 2);
  1717.         dst_val_int1 = __msa_copy_u_w((v4i32) dst1, 2);
  1718.         dst_val_int2 = __msa_copy_u_w((v4i32) dst2, 2);
  1719.         dst_val_int3 = __msa_copy_u_w((v4i32) dst3, 2);
  1720.  
  1721.         SD(dst_val0, dst);
  1722.         SW(dst_val_int0, dst + 4);
  1723.         dst += dst_stride;
  1724.         SD(dst_val1, dst);
  1725.         SW(dst_val_int1, dst + 4);
  1726.         dst += dst_stride;
  1727.         SD(dst_val2, dst);
  1728.         SW(dst_val_int2, dst + 4);
  1729.         dst += dst_stride;
  1730.         SD(dst_val3, dst);
  1731.         SW(dst_val_int3, dst + 4);
  1732.         dst += dst_stride;
  1733.     }
  1734. }
  1735.  
  1736. static void hevc_hz_4t_8x2multiple_msa(uint8_t *src,
  1737.                                        int32_t src_stride,
  1738.                                        int16_t *dst,
  1739.                                        int32_t dst_stride,
  1740.                                        const int8_t *filter,
  1741.                                        int32_t height)
  1742. {
  1743.     uint32_t loop_cnt;
  1744.     v8i16 filt0, filt1, dst0, dst1;
  1745.     v16i8 src0, src1;
  1746.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1747.     v16i8 mask1;
  1748.     v16i8 vec0, vec1;
  1749.     v8i16 filter_vec, const_vec;
  1750.  
  1751.     src -= 1;
  1752.  
  1753.     filter_vec = LD_SH(filter);
  1754.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1755.  
  1756.     mask1 = mask0 + 2;
  1757.  
  1758.     const_vec = __msa_ldi_h(128);
  1759.     const_vec <<= 6;
  1760.  
  1761.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  1762.         LD_SB2(src, src_stride, src0, src1);
  1763.         src += (2 * src_stride);
  1764.  
  1765.         XORI_B2_128_SB(src0, src1);
  1766.  
  1767.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  1768.         dst0 = const_vec;
  1769.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1770.  
  1771.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  1772.         dst1 = const_vec;
  1773.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  1774.  
  1775.         ST_SH2(dst0, dst1, dst, dst_stride);
  1776.         dst += (2 * dst_stride);
  1777.     }
  1778. }
  1779.  
  1780. static void hevc_hz_4t_8x4multiple_msa(uint8_t *src,
  1781.                                        int32_t src_stride,
  1782.                                        int16_t *dst,
  1783.                                        int32_t dst_stride,
  1784.                                        const int8_t *filter,
  1785.                                        int32_t height)
  1786. {
  1787.     uint32_t loop_cnt;
  1788.     v8i16 filt0, filt1;
  1789.     v16i8 src0, src1, src2, src3;
  1790.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1791.     v16i8 mask1;
  1792.     v16i8 vec0, vec1;
  1793.     v8i16 dst0, dst1, dst2, dst3;
  1794.     v8i16 filter_vec, const_vec;
  1795.  
  1796.     src -= 1;
  1797.  
  1798.     filter_vec = LD_SH(filter);
  1799.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1800.  
  1801.     mask1 = mask0 + 2;
  1802.  
  1803.     const_vec = __msa_ldi_h(128);
  1804.     const_vec <<= 6;
  1805.  
  1806.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1807.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  1808.         src += (4 * src_stride);
  1809.  
  1810.         XORI_B4_128_SB(src0, src1, src2, src3);
  1811.  
  1812.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  1813.         dst0 = const_vec;
  1814.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1815.  
  1816.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  1817.         dst1 = const_vec;
  1818.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  1819.  
  1820.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  1821.         dst2 = const_vec;
  1822.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  1823.  
  1824.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  1825.         dst3 = const_vec;
  1826.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  1827.  
  1828.         ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
  1829.         dst += (4 * dst_stride);
  1830.     }
  1831. }
  1832.  
  1833. static void hevc_hz_4t_8w_msa(uint8_t *src,
  1834.                               int32_t src_stride,
  1835.                               int16_t *dst,
  1836.                               int32_t dst_stride,
  1837.                               const int8_t *filter,
  1838.                               int32_t height)
  1839. {
  1840.     if (2 == height || 6 == height) {
  1841.         hevc_hz_4t_8x2multiple_msa(src, src_stride, dst, dst_stride,
  1842.                                    filter, height);
  1843.     } else {
  1844.         hevc_hz_4t_8x4multiple_msa(src, src_stride, dst, dst_stride,
  1845.                                    filter, height);
  1846.     }
  1847. }
  1848.  
  1849. static void hevc_hz_4t_12w_msa(uint8_t *src,
  1850.                                int32_t src_stride,
  1851.                                int16_t *dst,
  1852.                                int32_t dst_stride,
  1853.                                const int8_t *filter,
  1854.                                int32_t height)
  1855. {
  1856.     uint32_t loop_cnt;
  1857.     v8i16 filt0, filt1;
  1858.     v16i8 src0, src1, src2, src3;
  1859.     v16i8 mask1;
  1860.     v16i8 vec0, vec1;
  1861.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  1862.     v8i16 filter_vec, const_vec;
  1863.     v16i8 mask3;
  1864.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1865.     v16i8 mask2 = {
  1866.         8, 9, 9, 10, 10, 11, 11, 12, 24, 25, 25, 26, 26, 27, 27, 28
  1867.     };
  1868.  
  1869.     src -= 1;
  1870.  
  1871.     filter_vec = LD_SH(filter);
  1872.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1873.  
  1874.     mask1 = mask0 + 2;
  1875.     mask3 = mask2 + 2;
  1876.  
  1877.     const_vec = __msa_ldi_h(128);
  1878.     const_vec <<= 6;
  1879.  
  1880.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1881.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  1882.         src += (4 * src_stride);
  1883.         XORI_B4_128_SB(src0, src1, src2, src3);
  1884.  
  1885.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  1886.         dst0 = const_vec;
  1887.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1888.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  1889.         dst1 = const_vec;
  1890.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  1891.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  1892.         dst2 = const_vec;
  1893.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  1894.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  1895.         dst3 = const_vec;
  1896.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  1897.         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
  1898.         dst4 = const_vec;
  1899.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  1900.         VSHF_B2_SB(src2, src3, src2, src3, mask2, mask3, vec0, vec1);
  1901.         dst5 = const_vec;
  1902.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  1903.  
  1904.         ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
  1905.         ST8x4_UB(dst4, dst5, dst + 8, 2 * dst_stride);
  1906.         dst += (4 * dst_stride);
  1907.     }
  1908. }
  1909.  
  1910. static void hevc_hz_4t_16w_msa(uint8_t *src,
  1911.                                int32_t src_stride,
  1912.                                int16_t *dst,
  1913.                                int32_t dst_stride,
  1914.                                const int8_t *filter,
  1915.                                int32_t height)
  1916. {
  1917.     uint32_t loop_cnt;
  1918.     v16i8 src0, src1, src2, src3;
  1919.     v16i8 src4, src5, src6, src7;
  1920.     v8i16 filt0, filt1;
  1921.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1922.     v16i8 mask1;
  1923.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
  1924.     v16i8 vec0, vec1;
  1925.     v8i16 filter_vec, const_vec;
  1926.  
  1927.     src -= 1;
  1928.  
  1929.     filter_vec = LD_SH(filter);
  1930.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  1931.  
  1932.     mask1 = mask0 + 2;
  1933.  
  1934.     const_vec = __msa_ldi_h(128);
  1935.     const_vec <<= 6;
  1936.  
  1937.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1938.         LD_SB4(src, src_stride, src0, src2, src4, src6);
  1939.         LD_SB4(src + 8, src_stride, src1, src3, src5, src7);
  1940.         src += (4 * src_stride);
  1941.  
  1942.         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
  1943.  
  1944.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  1945.         dst0 = const_vec;
  1946.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  1947.  
  1948.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  1949.         dst1 = const_vec;
  1950.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  1951.  
  1952.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  1953.         dst2 = const_vec;
  1954.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  1955.  
  1956.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  1957.         dst3 = const_vec;
  1958.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  1959.  
  1960.         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  1961.         dst4 = const_vec;
  1962.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  1963.  
  1964.         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  1965.         dst5 = const_vec;
  1966.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  1967.  
  1968.         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  1969.         dst6 = const_vec;
  1970.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
  1971.  
  1972.         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
  1973.         dst7 = const_vec;
  1974.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
  1975.  
  1976.         ST_SH4(dst0, dst2, dst4, dst6, dst, dst_stride);
  1977.         ST_SH4(dst1, dst3, dst5, dst7, dst + 8, dst_stride);
  1978.         dst += (4 * dst_stride);
  1979.     }
  1980. }
  1981.  
  1982. static void hevc_hz_4t_24w_msa(uint8_t *src,
  1983.                                int32_t src_stride,
  1984.                                int16_t *dst,
  1985.                                int32_t dst_stride,
  1986.                                const int8_t *filter,
  1987.                                int32_t height)
  1988. {
  1989.     uint32_t loop_cnt;
  1990.     int16_t *dst_tmp = dst + 16;
  1991.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  1992.     v8i16 filt0, filt1;
  1993.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  1994.     v16i8 mask1, mask00, mask11;
  1995.     v16i8 vec0, vec1;
  1996.     v8i16 dst0, dst1, dst2, dst3;
  1997.     v8i16 filter_vec, const_vec;
  1998.  
  1999.     src -= 1;
  2000.  
  2001.     filter_vec = LD_SH(filter);
  2002.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2003.  
  2004.     mask1 = mask0 + 2;
  2005.     mask00 = mask0 + 8;
  2006.     mask11 = mask0 + 10;
  2007.  
  2008.     const_vec = __msa_ldi_h(128);
  2009.     const_vec <<= 6;
  2010.  
  2011.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2012.         /* 16 width */
  2013.         LD_SB4(src, src_stride, src0, src2, src4, src6);
  2014.         LD_SB4(src + 16, src_stride, src1, src3, src5, src7);
  2015.         src += (4 * src_stride);
  2016.  
  2017.         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
  2018.  
  2019.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2020.         dst0 = const_vec;
  2021.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2022.  
  2023.         VSHF_B2_SB(src0, src1, src0, src1, mask00, mask11, vec0, vec1);
  2024.         dst1 = const_vec;
  2025.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2026.  
  2027.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2028.         dst2 = const_vec;
  2029.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2030.  
  2031.         VSHF_B2_SB(src2, src3, src2, src3, mask00, mask11, vec0, vec1);
  2032.         dst3 = const_vec;
  2033.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2034.  
  2035.         ST_SH2(dst0, dst1, dst, 8);
  2036.         dst += dst_stride;
  2037.         ST_SH2(dst2, dst3, dst, 8);
  2038.         dst += dst_stride;
  2039.  
  2040.         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  2041.         dst0 = const_vec;
  2042.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2043.  
  2044.         VSHF_B2_SB(src4, src5, src4, src5, mask00, mask11, vec0, vec1);
  2045.         dst1 = const_vec;
  2046.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2047.  
  2048.         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  2049.         dst2 = const_vec;
  2050.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2051.  
  2052.         VSHF_B2_SB(src6, src7, src6, src7, mask00, mask11, vec0, vec1);
  2053.         dst3 = const_vec;
  2054.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2055.  
  2056.         ST_SH2(dst0, dst1, dst, 8);
  2057.         dst += dst_stride;
  2058.         ST_SH2(dst2, dst3, dst, 8);
  2059.         dst += dst_stride;
  2060.  
  2061.         /* 8 width */
  2062.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2063.         dst0 = const_vec;
  2064.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2065.  
  2066.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  2067.         dst1 = const_vec;
  2068.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2069.  
  2070.         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  2071.         dst2 = const_vec;
  2072.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2073.  
  2074.         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
  2075.         dst3 = const_vec;
  2076.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2077.  
  2078.         ST_SH4(dst0, dst1, dst2, dst3, dst_tmp, dst_stride);
  2079.         dst_tmp += (4 * dst_stride);
  2080.     }
  2081. }
  2082.  
  2083. static void hevc_hz_4t_32w_msa(uint8_t *src,
  2084.                                int32_t src_stride,
  2085.                                int16_t *dst,
  2086.                                int32_t dst_stride,
  2087.                                const int8_t *filter,
  2088.                                int32_t height)
  2089. {
  2090.     uint32_t loop_cnt;
  2091.     v16i8 src0, src1, src2;
  2092.     v8i16 filt0, filt1;
  2093.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2094.     v16i8 mask1, mask2, mask3;
  2095.     v8i16 dst0, dst1, dst2, dst3;
  2096.     v16i8 vec0, vec1;
  2097.     v8i16 filter_vec, const_vec;
  2098.  
  2099.     src -= 1;
  2100.  
  2101.     filter_vec = LD_SH(filter);
  2102.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2103.  
  2104.     const_vec = __msa_ldi_h(128);
  2105.     const_vec <<= 6;
  2106.  
  2107.     mask1 = mask0 + 2;
  2108.     mask2 = mask0 + 8;
  2109.     mask3 = mask0 + 10;
  2110.  
  2111.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  2112.         LD_SB2(src, 16, src0, src1);
  2113.         src2 = LD_SB(src + 24);
  2114.         src += src_stride;
  2115.  
  2116.         XORI_B3_128_SB(src0, src1, src2);
  2117.  
  2118.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2119.         dst0 = const_vec;
  2120.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2121.  
  2122.         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
  2123.         dst1 = const_vec;
  2124.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2125.  
  2126.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2127.         dst2 = const_vec;
  2128.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2129.  
  2130.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2131.         dst3 = const_vec;
  2132.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2133.  
  2134.         ST_SH4(dst0, dst1, dst2, dst3, dst, 8);
  2135.         dst += dst_stride;
  2136.  
  2137.         LD_SB2(src, 16, src0, src1);
  2138.         src2 = LD_SB(src + 24);
  2139.         src += src_stride;
  2140.  
  2141.         XORI_B3_128_SB(src0, src1, src2);
  2142.  
  2143.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2144.         dst0 = const_vec;
  2145.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2146.  
  2147.         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
  2148.         dst1 = const_vec;
  2149.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
  2150.  
  2151.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
  2152.         dst2 = const_vec;
  2153.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  2154.  
  2155.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
  2156.         dst3 = const_vec;
  2157.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2158.  
  2159.         ST_SH4(dst0, dst1, dst2, dst3, dst, 8);
  2160.         dst += dst_stride;
  2161.     }
  2162. }
  2163.  
  2164. static void hevc_vt_4t_4x2_msa(uint8_t *src,
  2165.                                int32_t src_stride,
  2166.                                int16_t *dst,
  2167.                                int32_t dst_stride,
  2168.                                const int8_t *filter)
  2169. {
  2170.     v16i8 src0, src1, src2, src3, src4;
  2171.     v16i8 src10_r, src32_r, src21_r, src43_r;
  2172.     v16i8 src2110, src4332;
  2173.     v8i16 dst10;
  2174.     v8i16 filt0, filt1;
  2175.     v8i16 filter_vec, const_vec;
  2176.  
  2177.     src -= src_stride;
  2178.  
  2179.     const_vec = __msa_ldi_h(128);
  2180.     const_vec <<= 6;
  2181.  
  2182.     filter_vec = LD_SH(filter);
  2183.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2184.  
  2185.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  2186.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  2187.                src10_r, src21_r, src32_r, src43_r);
  2188.  
  2189.     ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
  2190.     XORI_B2_128_SB(src2110, src4332);
  2191.     dst10 = const_vec;
  2192.     DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
  2193.  
  2194.     ST8x2_UB(dst10, dst, 2 * dst_stride);
  2195. }
  2196.  
  2197. static void hevc_vt_4t_4x4_msa(uint8_t *src,
  2198.                                int32_t src_stride,
  2199.                                int16_t *dst,
  2200.                                int32_t dst_stride,
  2201.                                const int8_t *filter,
  2202.                                int32_t height)
  2203. {
  2204.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  2205.     v16i8 src10_r, src32_r, src54_r, src21_r, src43_r, src65_r;
  2206.     v16i8 src2110, src4332, src6554;
  2207.     v8i16 dst10, dst32;
  2208.     v8i16 filt0, filt1;
  2209.     v8i16 filter_vec, const_vec;
  2210.  
  2211.     src -= src_stride;
  2212.  
  2213.     const_vec = __msa_ldi_h(128);
  2214.     const_vec <<= 6;
  2215.  
  2216.     filter_vec = LD_SH(filter);
  2217.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2218.  
  2219.     LD_SB7(src, src_stride, src0, src1, src2, src3, src4, src5, src6);
  2220.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  2221.                src10_r, src21_r, src32_r, src43_r);
  2222.     ILVR_B2_SB(src5, src4, src6, src5, src54_r, src65_r);
  2223.     ILVR_D3_SB(src21_r, src10_r, src43_r, src32_r, src65_r, src54_r,
  2224.                src2110, src4332, src6554);
  2225.     XORI_B3_128_SB(src2110, src4332, src6554);
  2226.     dst10 = const_vec;
  2227.     DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
  2228.     dst32 = const_vec;
  2229.     DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
  2230.  
  2231.     ST8x4_UB(dst10, dst32, dst, 2 * dst_stride);
  2232. }
  2233.  
  2234. static void hevc_vt_4t_4x8multiple_msa(uint8_t *src,
  2235.                                        int32_t src_stride,
  2236.                                        int16_t *dst,
  2237.                                        int32_t dst_stride,
  2238.                                        const int8_t *filter,
  2239.                                        int32_t height)
  2240. {
  2241.     int32_t loop_cnt;
  2242.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9;
  2243.     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
  2244.     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
  2245.     v16i8 src2110, src4332, src6554, src8776;
  2246.     v8i16 dst10, dst32, dst54, dst76;
  2247.     v8i16 filt0, filt1;
  2248.     v8i16 filter_vec, const_vec;
  2249.  
  2250.     src -= src_stride;
  2251.     const_vec = __msa_ldi_h(128);
  2252.     const_vec <<= 6;
  2253.  
  2254.     filter_vec = LD_SH(filter);
  2255.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2256.  
  2257.     LD_SB3(src, src_stride, src0, src1, src2);
  2258.     src += (3 * src_stride);
  2259.  
  2260.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2261.     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
  2262.     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
  2263.  
  2264.     for (loop_cnt = (height >> 3); loop_cnt--;) {
  2265.         LD_SB6(src, src_stride, src3, src4, src5, src6, src7, src8);
  2266.         src += (6 * src_stride);
  2267.  
  2268.         ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
  2269.                    src32_r, src43_r, src54_r, src65_r);
  2270.         ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
  2271.         ILVR_D3_SB(src43_r, src32_r, src65_r, src54_r, src87_r, src76_r,
  2272.                    src4332, src6554, src8776);
  2273.         XORI_B3_128_SB(src4332, src6554, src8776);
  2274.  
  2275.         dst10 = const_vec;
  2276.         DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
  2277.         dst32 = const_vec;
  2278.         DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
  2279.         dst54 = const_vec;
  2280.         DPADD_SB2_SH(src6554, src8776, filt0, filt1, dst54, dst54);
  2281.  
  2282.         LD_SB2(src, src_stride, src9, src2);
  2283.         src += (2 * src_stride);
  2284.         ILVR_B2_SB(src9, src8, src2, src9, src98_r, src109_r);
  2285.         src2110 = (v16i8) __msa_ilvr_d((v2i64) src109_r, (v2i64) src98_r);
  2286.         src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
  2287.         dst76 = const_vec;
  2288.         DPADD_SB2_SH(src8776, src2110, filt0, filt1, dst76, dst76);
  2289.  
  2290.         ST8x8_UB(dst10, dst32, dst54, dst76, dst, 2 * dst_stride);
  2291.         dst += (8 * dst_stride);
  2292.     }
  2293. }
  2294.  
  2295. static void hevc_vt_4t_4w_msa(uint8_t *src,
  2296.                               int32_t src_stride,
  2297.                               int16_t *dst,
  2298.                               int32_t dst_stride,
  2299.                               const int8_t *filter,
  2300.                               int32_t height)
  2301. {
  2302.     if (2 == height) {
  2303.         hevc_vt_4t_4x2_msa(src, src_stride, dst, dst_stride, filter);
  2304.     } else if (4 == height) {
  2305.         hevc_vt_4t_4x4_msa(src, src_stride, dst, dst_stride, filter, height);
  2306.     } else if (0 == (height % 8)) {
  2307.         hevc_vt_4t_4x8multiple_msa(src, src_stride, dst, dst_stride,
  2308.                                    filter, height);
  2309.     }
  2310. }
  2311.  
  2312. static void hevc_vt_4t_6w_msa(uint8_t *src,
  2313.                               int32_t src_stride,
  2314.                               int16_t *dst,
  2315.                               int32_t dst_stride,
  2316.                               const int8_t *filter,
  2317.                               int32_t height)
  2318. {
  2319.     int32_t loop_cnt;
  2320.     uint32_t dst_val_int0, dst_val_int1, dst_val_int2, dst_val_int3;
  2321.     uint64_t dst_val0, dst_val1, dst_val2, dst_val3;
  2322.     v16i8 src0, src1, src2, src3, src4;
  2323.     v16i8 src10_r, src32_r, src21_r, src43_r;
  2324.     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
  2325.     v8i16 filt0, filt1;
  2326.     v8i16 filter_vec, const_vec;
  2327.  
  2328.     src -= src_stride;
  2329.     const_vec = __msa_ldi_h(128);
  2330.     const_vec <<= 6;
  2331.  
  2332.     filter_vec = LD_SH(filter);
  2333.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2334.  
  2335.     LD_SB3(src, src_stride, src0, src1, src2);
  2336.     src += (3 * src_stride);
  2337.     XORI_B3_128_SB(src0, src1, src2);
  2338.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2339.  
  2340.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2341.         LD_SB2(src, src_stride, src3, src4);
  2342.         src += (2 * src_stride);
  2343.         XORI_B2_128_SB(src3, src4);
  2344.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2345.  
  2346.         dst0_r = const_vec;
  2347.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2348.         dst1_r = const_vec;
  2349.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2350.  
  2351.         LD_SB2(src, src_stride, src1, src2);
  2352.         src += (2 * src_stride);
  2353.         XORI_B2_128_SB(src1, src2);
  2354.         ILVR_B2_SB(src1, src4, src2, src1, src10_r, src21_r);
  2355.  
  2356.         dst2_r = const_vec;
  2357.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
  2358.         dst3_r = const_vec;
  2359.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
  2360.  
  2361.         dst_val0 = __msa_copy_u_d((v2i64) dst0_r, 0);
  2362.         dst_val1 = __msa_copy_u_d((v2i64) dst1_r, 0);
  2363.         dst_val2 = __msa_copy_u_d((v2i64) dst2_r, 0);
  2364.         dst_val3 = __msa_copy_u_d((v2i64) dst3_r, 0);
  2365.  
  2366.         dst_val_int0 = __msa_copy_u_w((v4i32) dst0_r, 2);
  2367.         dst_val_int1 = __msa_copy_u_w((v4i32) dst1_r, 2);
  2368.         dst_val_int2 = __msa_copy_u_w((v4i32) dst2_r, 2);
  2369.         dst_val_int3 = __msa_copy_u_w((v4i32) dst3_r, 2);
  2370.  
  2371.         SD(dst_val0, dst);
  2372.         SW(dst_val_int0, dst + 4);
  2373.         dst += dst_stride;
  2374.         SD(dst_val1, dst);
  2375.         SW(dst_val_int1, dst + 4);
  2376.         dst += dst_stride;
  2377.         SD(dst_val2, dst);
  2378.         SW(dst_val_int2, dst + 4);
  2379.         dst += dst_stride;
  2380.         SD(dst_val3, dst);
  2381.         SW(dst_val_int3, dst + 4);
  2382.         dst += dst_stride;
  2383.     }
  2384. }
  2385.  
  2386. static void hevc_vt_4t_8x2_msa(uint8_t *src,
  2387.                                int32_t src_stride,
  2388.                                int16_t *dst,
  2389.                                int32_t dst_stride,
  2390.                                const int8_t *filter)
  2391. {
  2392.     v16i8 src0, src1, src2, src3, src4;
  2393.     v16i8 src10_r, src32_r, src21_r, src43_r;
  2394.     v8i16 dst0_r, dst1_r;
  2395.     v8i16 filt0, filt1;
  2396.     v8i16 filter_vec, const_vec;
  2397.  
  2398.     src -= src_stride;
  2399.     const_vec = __msa_ldi_h(128);
  2400.     const_vec <<= 6;
  2401.  
  2402.     filter_vec = LD_SH(filter);
  2403.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2404.  
  2405.     LD_SB3(src, src_stride, src0, src1, src2);
  2406.     src += (3 * src_stride);
  2407.     XORI_B3_128_SB(src0, src1, src2);
  2408.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2409.  
  2410.     LD_SB2(src, src_stride, src3, src4);
  2411.     XORI_B2_128_SB(src3, src4);
  2412.     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2413.     dst0_r = const_vec;
  2414.     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2415.     dst1_r = const_vec;
  2416.     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2417.  
  2418.     ST_SH2(dst0_r, dst1_r, dst, dst_stride);
  2419. }
  2420.  
  2421. static void hevc_vt_4t_8x6_msa(uint8_t *src,
  2422.                                int32_t src_stride,
  2423.                                int16_t *dst,
  2424.                                int32_t dst_stride,
  2425.                                const int8_t *filter)
  2426. {
  2427.     v16i8 src0, src1, src2, src3, src4;
  2428.     v16i8 src10_r, src32_r, src21_r, src43_r;
  2429.     v8i16 dst0_r, dst1_r;
  2430.     v8i16 filt0, filt1;
  2431.     v8i16 filter_vec, const_vec;
  2432.  
  2433.     src -= src_stride;
  2434.     const_vec = __msa_ldi_h(128);
  2435.     const_vec <<= 6;
  2436.  
  2437.     filter_vec = LD_SH(filter);
  2438.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2439.  
  2440.     LD_SB3(src, src_stride, src0, src1, src2);
  2441.     src += (3 * src_stride);
  2442.     XORI_B3_128_SB(src0, src1, src2);
  2443.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2444.  
  2445.     LD_SB2(src, src_stride, src3, src4);
  2446.     src += (2 * src_stride);
  2447.     XORI_B2_128_SB(src3, src4);
  2448.  
  2449.     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2450.     dst0_r = const_vec;
  2451.     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2452.     dst1_r = const_vec;
  2453.     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2454.  
  2455.     ST_SH2(dst0_r, dst1_r, dst, dst_stride);
  2456.     dst += (2 * dst_stride);
  2457.  
  2458.     LD_SB2(src, src_stride, src1, src2);
  2459.     src += (2 * src_stride);
  2460.     XORI_B2_128_SB(src1, src2);
  2461.  
  2462.     ILVR_B2_SB(src1, src4, src2, src1, src10_r, src21_r);
  2463.     dst0_r = const_vec;
  2464.     DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
  2465.     dst1_r = const_vec;
  2466.     DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
  2467.  
  2468.     ST_SH2(dst0_r, dst1_r, dst, dst_stride);
  2469.     dst += (2 * dst_stride);
  2470.  
  2471.     LD_SB2(src, src_stride, src3, src4);
  2472.     XORI_B2_128_SB(src3, src4);
  2473.  
  2474.     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2475.     dst0_r = const_vec;
  2476.     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2477.     dst1_r = const_vec;
  2478.     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2479.  
  2480.     ST_SH2(dst0_r, dst1_r, dst, dst_stride);
  2481. }
  2482.  
  2483. static void hevc_vt_4t_8x4multiple_msa(uint8_t *src,
  2484.                                        int32_t src_stride,
  2485.                                        int16_t *dst,
  2486.                                        int32_t dst_stride,
  2487.                                        const int8_t *filter,
  2488.                                        int32_t height)
  2489. {
  2490.     int32_t loop_cnt;
  2491.     v16i8 src0, src1, src2, src3, src4, src5;
  2492.     v16i8 src10_r, src32_r, src21_r, src43_r;
  2493.     v8i16 dst0_r, dst1_r;
  2494.     v8i16 filt0, filt1;
  2495.     v8i16 filter_vec, const_vec;
  2496.  
  2497.     src -= src_stride;
  2498.     const_vec = __msa_ldi_h(128);
  2499.     const_vec <<= 6;
  2500.  
  2501.     filter_vec = LD_SH(filter);
  2502.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2503.  
  2504.     LD_SB3(src, src_stride, src0, src1, src2);
  2505.     src += (3 * src_stride);
  2506.     XORI_B3_128_SB(src0, src1, src2);
  2507.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2508.  
  2509.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2510.         LD_SB2(src, src_stride, src3, src4);
  2511.         src += (2 * src_stride);
  2512.         XORI_B2_128_SB(src3, src4);
  2513.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2514.         dst0_r = const_vec;
  2515.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2516.         dst1_r = const_vec;
  2517.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2518.  
  2519.         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
  2520.         dst += (2 * dst_stride);
  2521.  
  2522.         LD_SB2(src, src_stride, src5, src2);
  2523.         src += (2 * src_stride);
  2524.         XORI_B2_128_SB(src5, src2);
  2525.         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
  2526.         dst0_r = const_vec;
  2527.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
  2528.         dst1_r = const_vec;
  2529.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
  2530.  
  2531.         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
  2532.         dst += (2 * dst_stride);
  2533.     }
  2534. }
  2535.  
  2536. static void hevc_vt_4t_8w_msa(uint8_t *src,
  2537.                               int32_t src_stride,
  2538.                               int16_t *dst,
  2539.                               int32_t dst_stride,
  2540.                               const int8_t *filter,
  2541.                               int32_t height)
  2542. {
  2543.     if (2 == height) {
  2544.         hevc_vt_4t_8x2_msa(src, src_stride, dst, dst_stride, filter);
  2545.     } else if (6 == height) {
  2546.         hevc_vt_4t_8x6_msa(src, src_stride, dst, dst_stride, filter);
  2547.     } else {
  2548.         hevc_vt_4t_8x4multiple_msa(src, src_stride, dst, dst_stride,
  2549.                                    filter, height);
  2550.     }
  2551. }
  2552.  
  2553. static void hevc_vt_4t_12w_msa(uint8_t *src,
  2554.                                int32_t src_stride,
  2555.                                int16_t *dst,
  2556.                                int32_t dst_stride,
  2557.                                const int8_t *filter,
  2558.                                int32_t height)
  2559. {
  2560.     int32_t loop_cnt;
  2561.     v16i8 src0, src1, src2, src3, src4, src5;
  2562.     v16i8 src10_r, src32_r, src21_r, src43_r;
  2563.     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
  2564.     v16i8 src10_l, src32_l, src54_l, src21_l, src43_l, src65_l;
  2565.     v16i8 src2110, src4332;
  2566.     v8i16 dst0_l, dst1_l;
  2567.     v8i16 filt0, filt1;
  2568.     v8i16 filter_vec, const_vec;
  2569.  
  2570.     src -= (1 * src_stride);
  2571.     const_vec = __msa_ldi_h(128);
  2572.     const_vec <<= 6;
  2573.  
  2574.     filter_vec = LD_SH(filter);
  2575.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2576.  
  2577.     LD_SB3(src, src_stride, src0, src1, src2);
  2578.     src += (3 * src_stride);
  2579.     XORI_B3_128_SB(src0, src1, src2);
  2580.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2581.     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
  2582.     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_l, (v2i64) src10_l);
  2583.  
  2584.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2585.         LD_SB2(src, src_stride, src3, src4);
  2586.         src += (2 * src_stride);
  2587.         XORI_B2_128_SB(src3, src4);
  2588.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2589.         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
  2590.         src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_l, (v2i64) src32_l);
  2591.         dst0_r = const_vec;
  2592.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2593.         dst1_r = const_vec;
  2594.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2595.         dst0_l = const_vec;
  2596.         DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst0_l, dst0_l);
  2597.  
  2598.         LD_SB2(src, src_stride, src5, src2);
  2599.         src += (2 * src_stride);
  2600.         XORI_B2_128_SB(src5, src2);
  2601.         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
  2602.         ILVL_B2_SB(src5, src4, src2, src5, src54_l, src65_l);
  2603.         src2110 = (v16i8) __msa_ilvr_d((v2i64) src65_l, (v2i64) src54_l);
  2604.         dst2_r = const_vec;
  2605.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
  2606.         dst3_r = const_vec;
  2607.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
  2608.         dst1_l = const_vec;
  2609.         DPADD_SB2_SH(src4332, src2110, filt0, filt1, dst1_l, dst1_l);
  2610.  
  2611.         ST_SH4(dst0_r, dst1_r, dst2_r, dst3_r, dst, dst_stride);
  2612.         ST8x4_UB(dst0_l, dst1_l, dst + 8, (2 * dst_stride));
  2613.         dst += (4 * dst_stride);
  2614.     }
  2615. }
  2616.  
  2617. static void hevc_vt_4t_16w_msa(uint8_t *src,
  2618.                                int32_t src_stride,
  2619.                                int16_t *dst,
  2620.                                int32_t dst_stride,
  2621.                                const int8_t *filter,
  2622.                                int32_t height)
  2623. {
  2624.     int32_t loop_cnt;
  2625.     v16i8 src0, src1, src2, src3, src4, src5;
  2626.     v16i8 src10_r, src32_r, src21_r, src43_r;
  2627.     v16i8 src10_l, src32_l, src21_l, src43_l;
  2628.     v8i16 dst0_r, dst1_r, dst0_l, dst1_l;
  2629.     v8i16 filt0, filt1;
  2630.     v8i16 filter_vec, const_vec;
  2631.  
  2632.     src -= src_stride;
  2633.     const_vec = __msa_ldi_h(128);
  2634.     const_vec <<= 6;
  2635.  
  2636.     filter_vec = LD_SH(filter);
  2637.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2638.  
  2639.     LD_SB3(src, src_stride, src0, src1, src2);
  2640.     src += (3 * src_stride);
  2641.     XORI_B3_128_SB(src0, src1, src2);
  2642.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2643.     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
  2644.  
  2645.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2646.         LD_SB2(src, src_stride, src3, src4);
  2647.         src += (2 * src_stride);
  2648.         XORI_B2_128_SB(src3, src4);
  2649.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2650.         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
  2651.         dst0_r = const_vec;
  2652.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2653.         dst0_l = const_vec;
  2654.         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
  2655.         dst1_r = const_vec;
  2656.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2657.         dst1_l = const_vec;
  2658.         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
  2659.         ST_SH2(dst0_r, dst0_l, dst, 8);
  2660.         dst += dst_stride;
  2661.         ST_SH2(dst1_r, dst1_l, dst, 8);
  2662.         dst += dst_stride;
  2663.  
  2664.         LD_SB2(src, src_stride, src5, src2);
  2665.         src += (2 * src_stride);
  2666.         XORI_B2_128_SB(src5, src2);
  2667.         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
  2668.         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
  2669.         dst0_r = const_vec;
  2670.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
  2671.         dst0_l = const_vec;
  2672.         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
  2673.         dst1_r = const_vec;
  2674.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
  2675.         dst1_l = const_vec;
  2676.         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
  2677.         ST_SH2(dst0_r, dst0_l, dst, 8);
  2678.         dst += dst_stride;
  2679.         ST_SH2(dst1_r, dst1_l, dst, 8);
  2680.         dst += dst_stride;
  2681.     }
  2682. }
  2683.  
  2684. static void hevc_vt_4t_24w_msa(uint8_t *src,
  2685.                                int32_t src_stride,
  2686.                                int16_t *dst,
  2687.                                int32_t dst_stride,
  2688.                                const int8_t *filter,
  2689.                                int32_t height)
  2690. {
  2691.     int32_t loop_cnt;
  2692.     v16i8 src0, src1, src2, src3, src4, src5;
  2693.     v16i8 src6, src7, src8, src9, src10, src11;
  2694.     v16i8 src10_r, src32_r, src76_r, src98_r;
  2695.     v16i8 src21_r, src43_r, src87_r, src109_r;
  2696.     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
  2697.     v16i8 src10_l, src32_l, src21_l, src43_l;
  2698.     v8i16 dst0_l, dst1_l;
  2699.     v8i16 filt0, filt1;
  2700.     v8i16 filter_vec, const_vec;
  2701.  
  2702.     src -= src_stride;
  2703.     const_vec = __msa_ldi_h(128);
  2704.     const_vec <<= 6;
  2705.  
  2706.     filter_vec = LD_SH(filter);
  2707.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2708.  
  2709.     LD_SB3(src, src_stride, src0, src1, src2);
  2710.     XORI_B3_128_SB(src0, src1, src2);
  2711.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2712.     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
  2713.  
  2714.     LD_SB3(src + 16, src_stride, src6, src7, src8);
  2715.     src += (3 * src_stride);
  2716.     XORI_B3_128_SB(src6, src7, src8);
  2717.     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
  2718.  
  2719.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2720.         LD_SB2(src, src_stride, src3, src4);
  2721.         XORI_B2_128_SB(src3, src4);
  2722.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2723.         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
  2724.  
  2725.         LD_SB2(src + 16, src_stride, src9, src10);
  2726.         src += (2 * src_stride);
  2727.         XORI_B2_128_SB(src9, src10);
  2728.         ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
  2729.  
  2730.         dst0_r = const_vec;
  2731.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2732.         dst0_l = const_vec;
  2733.         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
  2734.         dst1_r = const_vec;
  2735.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2736.         dst1_l = const_vec;
  2737.         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
  2738.         dst2_r = const_vec;
  2739.         DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
  2740.         dst3_r = const_vec;
  2741.         DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
  2742.  
  2743.         ST_SH2(dst0_r, dst0_l, dst, 8);
  2744.         ST_SH(dst2_r, dst + 16);
  2745.         dst += dst_stride;
  2746.         ST_SH2(dst1_r, dst1_l, dst, 8);
  2747.         ST_SH(dst3_r, dst + 16);
  2748.         dst += dst_stride;
  2749.  
  2750.         LD_SB2(src, src_stride, src5, src2);
  2751.         XORI_B2_128_SB(src5, src2);
  2752.         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
  2753.         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
  2754.  
  2755.         LD_SB2(src + 16, src_stride, src11, src8);
  2756.         src += (2 * src_stride);
  2757.         XORI_B2_128_SB(src11, src8);
  2758.         ILVR_B2_SB(src11, src10, src8, src11, src76_r, src87_r);
  2759.  
  2760.         dst0_r = const_vec;
  2761.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
  2762.         dst0_l = const_vec;
  2763.         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
  2764.         dst1_r = const_vec;
  2765.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
  2766.         dst1_l = const_vec;
  2767.         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
  2768.         dst2_r = const_vec;
  2769.         DPADD_SB2_SH(src98_r, src76_r, filt0, filt1, dst2_r, dst2_r);
  2770.         dst3_r = const_vec;
  2771.         DPADD_SB2_SH(src109_r, src87_r, filt0, filt1, dst3_r, dst3_r);
  2772.  
  2773.         ST_SH2(dst0_r, dst0_l, dst, 8);
  2774.         ST_SH(dst2_r, dst + 16);
  2775.         dst += dst_stride;
  2776.         ST_SH2(dst1_r, dst1_l, dst, 8);
  2777.         ST_SH(dst3_r, dst + 16);
  2778.         dst += dst_stride;
  2779.     }
  2780. }
  2781.  
  2782. static void hevc_vt_4t_32w_msa(uint8_t *src,
  2783.                                int32_t src_stride,
  2784.                                int16_t *dst,
  2785.                                int32_t dst_stride,
  2786.                                const int8_t *filter,
  2787.                                int32_t height)
  2788. {
  2789.     int32_t loop_cnt;
  2790.     v16i8 src0, src1, src2, src3, src4, src5;
  2791.     v16i8 src6, src7, src8, src9, src10, src11;
  2792.     v16i8 src10_r, src32_r, src76_r, src98_r;
  2793.     v16i8 src21_r, src43_r, src87_r, src109_r;
  2794.     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
  2795.     v16i8 src10_l, src32_l, src76_l, src98_l;
  2796.     v16i8 src21_l, src43_l, src87_l, src109_l;
  2797.     v8i16 dst0_l, dst1_l, dst2_l, dst3_l;
  2798.     v8i16 filt0, filt1;
  2799.     v8i16 filter_vec, const_vec;
  2800.  
  2801.     src -= src_stride;
  2802.     const_vec = __msa_ldi_h(128);
  2803.     const_vec <<= 6;
  2804.  
  2805.     filter_vec = LD_SH(filter);
  2806.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2807.  
  2808.     LD_SB3(src, src_stride, src0, src1, src2);
  2809.     XORI_B3_128_SB(src0, src1, src2);
  2810.     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
  2811.     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
  2812.  
  2813.     LD_SB3(src + 16, src_stride, src6, src7, src8);
  2814.     src += (3 * src_stride);
  2815.     XORI_B3_128_SB(src6, src7, src8);
  2816.     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
  2817.     ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
  2818.  
  2819.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2820.         LD_SB2(src, src_stride, src3, src4);
  2821.         XORI_B2_128_SB(src3, src4);
  2822.         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
  2823.         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
  2824.  
  2825.         LD_SB2(src + 16, src_stride, src9, src10);
  2826.         src += (2 * src_stride);
  2827.         XORI_B2_128_SB(src9, src10);
  2828.         ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
  2829.         ILVL_B2_SB(src9, src8, src10, src9, src98_l, src109_l);
  2830.  
  2831.         dst0_r = const_vec;
  2832.         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
  2833.         dst0_l = const_vec;
  2834.         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
  2835.         dst1_r = const_vec;
  2836.         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
  2837.         dst1_l = const_vec;
  2838.         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
  2839.         dst2_r = const_vec;
  2840.         DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
  2841.         dst2_l = const_vec;
  2842.         DPADD_SB2_SH(src76_l, src98_l, filt0, filt1, dst2_l, dst2_l);
  2843.         dst3_r = const_vec;
  2844.         DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
  2845.         dst3_l = const_vec;
  2846.         DPADD_SB2_SH(src87_l, src109_l, filt0, filt1, dst3_l, dst3_l);
  2847.  
  2848.         ST_SH4(dst0_r, dst0_l, dst2_r, dst2_l, dst, 8);
  2849.         dst += dst_stride;
  2850.         ST_SH4(dst1_r, dst1_l, dst3_r, dst3_l, dst, 8);
  2851.         dst += dst_stride;
  2852.  
  2853.         LD_SB2(src, src_stride, src5, src2);
  2854.         XORI_B2_128_SB(src5, src2);
  2855.         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
  2856.         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
  2857.  
  2858.         LD_SB2(src + 16, src_stride, src11, src8);
  2859.         src += (2 * src_stride);
  2860.         XORI_B2_128_SB(src11, src8);
  2861.         ILVR_B2_SB(src11, src10, src8, src11, src76_r, src87_r);
  2862.         ILVL_B2_SB(src11, src10, src8, src11, src76_l, src87_l);
  2863.  
  2864.         dst0_r = const_vec;
  2865.         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
  2866.         dst0_l = const_vec;
  2867.         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
  2868.         dst1_r = const_vec;
  2869.         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
  2870.         dst1_l = const_vec;
  2871.         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
  2872.         dst2_r = const_vec;
  2873.         DPADD_SB2_SH(src98_r, src76_r, filt0, filt1, dst2_r, dst2_r);
  2874.         dst2_l = const_vec;
  2875.         DPADD_SB2_SH(src98_l, src76_l, filt0, filt1, dst2_l, dst2_l);
  2876.         dst3_r = const_vec;
  2877.         DPADD_SB2_SH(src109_r, src87_r, filt0, filt1, dst3_r, dst3_r);
  2878.         dst3_l = const_vec;
  2879.         DPADD_SB2_SH(src109_l, src87_l, filt0, filt1, dst3_l, dst3_l);
  2880.  
  2881.         ST_SH4(dst0_r, dst0_l, dst2_r, dst2_l, dst, 8);
  2882.         dst += dst_stride;
  2883.         ST_SH4(dst1_r, dst1_l, dst3_r, dst3_l, dst, 8);
  2884.         dst += dst_stride;
  2885.     }
  2886. }
  2887.  
  2888. static void hevc_hv_4t_4x2_msa(uint8_t *src,
  2889.                                int32_t src_stride,
  2890.                                int16_t *dst,
  2891.                                int32_t dst_stride,
  2892.                                const int8_t *filter_x,
  2893.                                const int8_t *filter_y)
  2894. {
  2895.     v16i8 src0, src1, src2, src3, src4;
  2896.     v8i16 filt0, filt1;
  2897.     v4i32 filt_h0, filt_h1;
  2898.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2899.     v16i8 mask1;
  2900.     v8i16 filter_vec, const_vec;
  2901.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  2902.     v8i16 dst0, dst1, dst2, dst3, dst4;
  2903.     v4i32 dst0_r, dst1_r;
  2904.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  2905.  
  2906.     src -= (src_stride + 1);
  2907.     filter_vec = LD_SH(filter_x);
  2908.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2909.  
  2910.     filter_vec = LD_SH(filter_y);
  2911.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  2912.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  2913.  
  2914.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  2915.  
  2916.     mask1 = mask0 + 2;
  2917.  
  2918.     const_vec = __msa_ldi_h(128);
  2919.     const_vec <<= 6;
  2920.  
  2921.     LD_SB3(src, src_stride, src0, src1, src2);
  2922.     src += (3 * src_stride);
  2923.     XORI_B3_128_SB(src0, src1, src2);
  2924.  
  2925.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  2926.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  2927.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  2928.  
  2929.     dst0 = const_vec;
  2930.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  2931.     dst1 = const_vec;
  2932.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  2933.     dst2 = const_vec;
  2934.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  2935.     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
  2936.  
  2937.     LD_SB2(src, src_stride, src3, src4);
  2938.     XORI_B2_128_SB(src3, src4);
  2939.  
  2940.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  2941.     dst3 = const_vec;
  2942.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  2943.  
  2944.     dst32_r = __msa_ilvr_h(dst3, dst2);
  2945.     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  2946.     dst0_r >>= 6;
  2947.  
  2948.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  2949.     dst4 = const_vec;
  2950.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  2951.  
  2952.     dst43_r = __msa_ilvr_h(dst4, dst3);
  2953.     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  2954.     dst1_r >>= 6;
  2955.  
  2956.     dst0_r = (v4i32) __msa_pckev_h((v8i16) dst1_r, (v8i16) dst0_r);
  2957.     ST8x2_UB(dst0_r, dst, 2 * dst_stride);
  2958. }
  2959.  
  2960. static void hevc_hv_4t_4x4_msa(uint8_t *src,
  2961.                                int32_t src_stride,
  2962.                                int16_t *dst,
  2963.                                int32_t dst_stride,
  2964.                                const int8_t *filter_x,
  2965.                                const int8_t *filter_y)
  2966. {
  2967.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  2968.     v8i16 filt0, filt1;
  2969.     v4i32 filt_h0, filt_h1;
  2970.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  2971.     v16i8 mask1;
  2972.     v8i16 filter_vec, const_vec;
  2973.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  2974.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  2975.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r;
  2976.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  2977.  
  2978.     src -= (src_stride + 1);
  2979.  
  2980.     filter_vec = LD_SH(filter_x);
  2981.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  2982.  
  2983.     filter_vec = LD_SH(filter_y);
  2984.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  2985.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  2986.  
  2987.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  2988.  
  2989.     mask1 = mask0 + 2;
  2990.  
  2991.     const_vec = __msa_ldi_h(128);
  2992.     const_vec <<= 6;
  2993.  
  2994.     LD_SB3(src, src_stride, src0, src1, src2);
  2995.     src += (3 * src_stride);
  2996.  
  2997.     XORI_B3_128_SB(src0, src1, src2);
  2998.  
  2999.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3000.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3001.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3002.  
  3003.     dst0 = const_vec;
  3004.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3005.     dst1 = const_vec;
  3006.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3007.     dst2 = const_vec;
  3008.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3009.  
  3010.     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
  3011.  
  3012.     LD_SB4(src, src_stride, src3, src4, src5, src6);
  3013.     XORI_B4_128_SB(src3, src4, src5, src6);
  3014.  
  3015.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3016.     dst3 = const_vec;
  3017.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3018.  
  3019.     dst32_r = __msa_ilvr_h(dst3, dst2);
  3020.     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3021.     dst0_r >>= 6;
  3022.  
  3023.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3024.     dst4 = const_vec;
  3025.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3026.  
  3027.     dst43_r = __msa_ilvr_h(dst4, dst3);
  3028.     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3029.     dst1_r >>= 6;
  3030.  
  3031.     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  3032.     dst5 = const_vec;
  3033.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  3034.  
  3035.     dst10_r = __msa_ilvr_h(dst5, dst4);
  3036.     dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
  3037.     dst2_r >>= 6;
  3038.  
  3039.     VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  3040.     dst2 = const_vec;
  3041.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  3042.  
  3043.     dst21_r = __msa_ilvr_h(dst2, dst5);
  3044.     dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
  3045.     dst3_r >>= 6;
  3046.  
  3047.     PCKEV_H2_SW(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
  3048.     ST8x4_UB(dst0_r, dst1_r, dst, 2 * dst_stride);
  3049. }
  3050.  
  3051.  
  3052. static void hevc_hv_4t_4multx8mult_msa(uint8_t *src,
  3053.                                        int32_t src_stride,
  3054.                                        int16_t *dst,
  3055.                                        int32_t dst_stride,
  3056.                                        const int8_t *filter_x,
  3057.                                        const int8_t *filter_y,
  3058.                                        int32_t height)
  3059. {
  3060.     uint32_t loop_cnt;
  3061.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  3062.     v16i8 src7, src8, src9, src10;
  3063.     v8i16 filt0, filt1;
  3064.     v4i32 filt_h0, filt_h1;
  3065.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  3066.     v16i8 mask1;
  3067.     v8i16 filter_vec, const_vec;
  3068.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  3069.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8, dst9;
  3070.     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r, dst6_r, dst7_r;
  3071.     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
  3072.     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
  3073.  
  3074.     src -= (src_stride + 1);
  3075.     filter_vec = LD_SH(filter_x);
  3076.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3077.  
  3078.     filter_vec = LD_SH(filter_y);
  3079.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  3080.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  3081.  
  3082.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  3083.  
  3084.     mask1 = mask0 + 2;
  3085.  
  3086.     const_vec = __msa_ldi_h(128);
  3087.     const_vec <<= 6;
  3088.  
  3089.     LD_SB3(src, src_stride, src0, src1, src2);
  3090.     src += (3 * src_stride);
  3091.     XORI_B3_128_SB(src0, src1, src2);
  3092.  
  3093.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3094.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3095.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3096.  
  3097.     dst0 = const_vec;
  3098.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3099.     dst1 = const_vec;
  3100.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3101.     dst2 = const_vec;
  3102.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3103.  
  3104.     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
  3105.  
  3106.     for (loop_cnt = height >> 3; loop_cnt--;) {
  3107.         LD_SB8(src, src_stride,
  3108.                src3, src4, src5, src6, src7, src8, src9, src10);
  3109.         src += (8 * src_stride);
  3110.         XORI_B8_128_SB(src3, src4, src5, src6, src7, src8, src9, src10);
  3111.  
  3112.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3113.         dst3 = const_vec;
  3114.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3115.  
  3116.         dst32_r = __msa_ilvr_h(dst3, dst2);
  3117.         dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3118.         dst0_r >>= 6;
  3119.  
  3120.         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3121.         dst4 = const_vec;
  3122.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3123.  
  3124.         dst43_r = __msa_ilvr_h(dst4, dst3);
  3125.         dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3126.         dst1_r >>= 6;
  3127.  
  3128.         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  3129.         dst5 = const_vec;
  3130.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  3131.  
  3132.         dst54_r = __msa_ilvr_h(dst5, dst4);
  3133.         dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
  3134.         dst2_r >>= 6;
  3135.  
  3136.         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  3137.         dst6 = const_vec;
  3138.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
  3139.  
  3140.         dst65_r = __msa_ilvr_h(dst6, dst5);
  3141.         dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
  3142.         dst3_r >>= 6;
  3143.  
  3144.         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
  3145.         dst7 = const_vec;
  3146.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
  3147.  
  3148.         dst76_r = __msa_ilvr_h(dst7, dst6);
  3149.         dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
  3150.         dst4_r >>= 6;
  3151.  
  3152.         VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
  3153.         dst8 = const_vec;
  3154.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
  3155.  
  3156.         dst87_r = __msa_ilvr_h(dst8, dst7);
  3157.         dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
  3158.         dst5_r >>= 6;
  3159.  
  3160.         VSHF_B2_SB(src9, src9, src9, src9, mask0, mask1, vec0, vec1);
  3161.         dst9 = const_vec;
  3162.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst9, dst9);
  3163.  
  3164.         dst10_r = __msa_ilvr_h(dst9, dst8);
  3165.         dst6_r = HEVC_FILT_4TAP(dst76_r, dst10_r, filt_h0, filt_h1);
  3166.         dst6_r >>= 6;
  3167.  
  3168.         VSHF_B2_SB(src10, src10, src10, src10, mask0, mask1, vec0, vec1);
  3169.         dst2 = const_vec;
  3170.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  3171.  
  3172.         dst21_r = __msa_ilvr_h(dst2, dst9);
  3173.         dst7_r = HEVC_FILT_4TAP(dst87_r, dst21_r, filt_h0, filt_h1);
  3174.         dst7_r >>= 6;
  3175.  
  3176.         PCKEV_H4_SW(dst1_r, dst0_r, dst3_r, dst2_r,
  3177.                     dst5_r, dst4_r, dst7_r, dst6_r,
  3178.                     dst0_r, dst1_r, dst2_r, dst3_r);
  3179.         ST8x8_UB(dst0_r, dst1_r, dst2_r, dst3_r, dst, 2 * dst_stride);
  3180.         dst += (8 * dst_stride);
  3181.     }
  3182. }
  3183.  
  3184. static void hevc_hv_4t_4w_msa(uint8_t *src,
  3185.                               int32_t src_stride,
  3186.                               int16_t *dst,
  3187.                               int32_t dst_stride,
  3188.                               const int8_t *filter_x,
  3189.                               const int8_t *filter_y,
  3190.                               int32_t height)
  3191. {
  3192.     if (2 == height) {
  3193.         hevc_hv_4t_4x2_msa(src, src_stride, dst, dst_stride,
  3194.                            filter_x, filter_y);
  3195.     } else if (4 == height) {
  3196.         hevc_hv_4t_4x4_msa(src, src_stride, dst, dst_stride,
  3197.                            filter_x, filter_y);
  3198.     } else if (0 == (height % 8)) {
  3199.         hevc_hv_4t_4multx8mult_msa(src, src_stride, dst, dst_stride,
  3200.                                    filter_x, filter_y, height);
  3201.     }
  3202. }
  3203.  
  3204. static void hevc_hv_4t_6w_msa(uint8_t *src,
  3205.                               int32_t src_stride,
  3206.                               int16_t *dst,
  3207.                               int32_t dst_stride,
  3208.                               const int8_t *filter_x,
  3209.                               const int8_t *filter_y,
  3210.                               int32_t height)
  3211. {
  3212.     uint32_t loop_cnt;
  3213.     uint64_t dst_val0, dst_val1, dst_val2, dst_val3;
  3214.     uint32_t dst_val_int0, dst_val_int1, dst_val_int2, dst_val_int3;
  3215.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  3216.     v8i16 filt0, filt1;
  3217.     v4i32 filt_h0, filt_h1;
  3218.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  3219.     v16i8 mask1;
  3220.     v8i16 filter_vec, const_vec;
  3221.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  3222.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  3223.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
  3224.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  3225.     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
  3226.  
  3227.     src -= (src_stride + 1);
  3228.     filter_vec = LD_SH(filter_x);
  3229.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3230.  
  3231.     filter_vec = LD_SH(filter_y);
  3232.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  3233.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  3234.  
  3235.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  3236.  
  3237.     mask1 = mask0 + 2;
  3238.  
  3239.     const_vec = __msa_ldi_h(128);
  3240.     const_vec <<= 6;
  3241.  
  3242.     LD_SB3(src, src_stride, src0, src1, src2);
  3243.     src += (3 * src_stride);
  3244.     XORI_B3_128_SB(src0, src1, src2);
  3245.  
  3246.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3247.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3248.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3249.  
  3250.     dst0 = const_vec;
  3251.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3252.     dst1 = const_vec;
  3253.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3254.     dst2 = const_vec;
  3255.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3256.  
  3257.     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
  3258.     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
  3259.  
  3260.     for (loop_cnt = height >> 2; loop_cnt--;) {
  3261.         LD_SB4(src, src_stride, src3, src4, src5, src6);
  3262.         src += (4 * src_stride);
  3263.         XORI_B4_128_SB(src3, src4, src5, src6);
  3264.  
  3265.         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3266.         dst3 = const_vec;
  3267.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3268.  
  3269.         ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
  3270.         dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3271.         dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
  3272.         dst0_r >>= 6;
  3273.         dst0_l >>= 6;
  3274.  
  3275.         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3276.         dst4 = const_vec;
  3277.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3278.  
  3279.         ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
  3280.         dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3281.         dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
  3282.         dst1_r >>= 6;
  3283.         dst1_l >>= 6;
  3284.  
  3285.         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  3286.         dst5 = const_vec;
  3287.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  3288.  
  3289.         ILVRL_H2_SH(dst5, dst4, dst10_r, dst10_l);
  3290.         dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
  3291.         dst2_l = HEVC_FILT_4TAP(dst32_l, dst10_l, filt_h0, filt_h1);
  3292.         dst2_r >>= 6;
  3293.         dst2_l >>= 6;
  3294.  
  3295.         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  3296.         dst2 = const_vec;
  3297.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  3298.  
  3299.         ILVRL_H2_SH(dst2, dst5, dst21_r, dst21_l);
  3300.         dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
  3301.         dst3_l = HEVC_FILT_4TAP(dst43_l, dst21_l, filt_h0, filt_h1);
  3302.         dst3_r >>= 6;
  3303.         dst3_l >>= 6;
  3304.  
  3305.         PCKEV_H4_SW(dst0_l, dst0_r, dst1_l, dst1_r,
  3306.                     dst2_l, dst2_r, dst3_l, dst3_r,
  3307.                     dst0_r, dst1_r, dst2_r, dst3_r);
  3308.  
  3309.         dst_val0 = __msa_copy_u_d((v2i64) dst0_r, 0);
  3310.         dst_val1 = __msa_copy_u_d((v2i64) dst1_r, 0);
  3311.         dst_val2 = __msa_copy_u_d((v2i64) dst2_r, 0);
  3312.         dst_val3 = __msa_copy_u_d((v2i64) dst3_r, 0);
  3313.  
  3314.         dst_val_int0 = __msa_copy_u_w((v4i32) dst0_r, 2);
  3315.         dst_val_int1 = __msa_copy_u_w((v4i32) dst1_r, 2);
  3316.         dst_val_int2 = __msa_copy_u_w((v4i32) dst2_r, 2);
  3317.         dst_val_int3 = __msa_copy_u_w((v4i32) dst3_r, 2);
  3318.  
  3319.         SD(dst_val0, dst);
  3320.         SW(dst_val_int0, dst + 4);
  3321.         dst += dst_stride;
  3322.         SD(dst_val1, dst);
  3323.         SW(dst_val_int1, dst + 4);
  3324.         dst += dst_stride;
  3325.         SD(dst_val2, dst);
  3326.         SW(dst_val_int2, dst + 4);
  3327.         dst += dst_stride;
  3328.         SD(dst_val3, dst);
  3329.         SW(dst_val_int3, dst + 4);
  3330.         dst += dst_stride;
  3331.  
  3332.     }
  3333. }
  3334.  
  3335. static void hevc_hv_4t_8x2_msa(uint8_t *src,
  3336.                                int32_t src_stride,
  3337.                                int16_t *dst,
  3338.                                int32_t dst_stride,
  3339.                                const int8_t *filter_x,
  3340.                                const int8_t *filter_y,
  3341.                                int32_t height)
  3342. {
  3343.     v16i8 src0, src1, src2, src3, src4;
  3344.     v8i16 filt0, filt1;
  3345.     v4i32 filt_h0, filt_h1;
  3346.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  3347.     v16i8 mask1;
  3348.     v8i16 filter_vec, const_vec;
  3349.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  3350.     v8i16 dst0, dst1, dst2, dst3, dst4;
  3351.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
  3352.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  3353.     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
  3354.  
  3355.     src -= (src_stride + 1);
  3356.  
  3357.     filter_vec = LD_SH(filter_x);
  3358.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3359.  
  3360.     filter_vec = LD_SH(filter_y);
  3361.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  3362.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  3363.  
  3364.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  3365.  
  3366.     mask1 = mask0 + 2;
  3367.  
  3368.     const_vec = __msa_ldi_h(128);
  3369.     const_vec <<= 6;
  3370.  
  3371.     LD_SB3(src, src_stride, src0, src1, src2);
  3372.     src += (3 * src_stride);
  3373.     XORI_B3_128_SB(src0, src1, src2);
  3374.  
  3375.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3376.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3377.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3378.  
  3379.     dst0 = const_vec;
  3380.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3381.     dst1 = const_vec;
  3382.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3383.     dst2 = const_vec;
  3384.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3385.  
  3386.     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
  3387.     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
  3388.  
  3389.     LD_SB2(src, src_stride, src3, src4);
  3390.     src += (2 * src_stride);
  3391.     XORI_B2_128_SB(src3, src4);
  3392.  
  3393.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3394.     dst3 = const_vec;
  3395.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3396.  
  3397.     ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
  3398.     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3399.     dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
  3400.     dst0_r >>= 6;
  3401.     dst0_l >>= 6;
  3402.  
  3403.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3404.     dst4 = const_vec;
  3405.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3406.  
  3407.     ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
  3408.     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3409.     dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
  3410.     dst1_r >>= 6;
  3411.     dst1_l >>= 6;
  3412.  
  3413.     PCKEV_H2_SW(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
  3414.     ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  3415. }
  3416.  
  3417. static void hevc_hv_4t_8x6_msa(uint8_t *src,
  3418.                                int32_t src_stride,
  3419.                                int16_t *dst,
  3420.                                int32_t dst_stride,
  3421.                                const int8_t *filter_x,
  3422.                                const int8_t *filter_y,
  3423.                                int32_t height)
  3424. {
  3425.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  3426.     v8i16 filt0, filt1;
  3427.     v4i32 filt_h0, filt_h1;
  3428.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  3429.     v16i8 mask1;
  3430.     v8i16 filter_vec, const_vec;
  3431.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  3432.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
  3433.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
  3434.     v4i32 dst4_r, dst4_l, dst5_r, dst5_l;
  3435.     v8i16 dst10_r, dst32_r, dst10_l, dst32_l;
  3436.     v8i16 dst21_r, dst43_r, dst21_l, dst43_l;
  3437.     v8i16 dst54_r, dst54_l, dst65_r, dst65_l;
  3438.     v8i16 dst76_r, dst76_l, dst87_r, dst87_l;
  3439.  
  3440.     src -= (src_stride + 1);
  3441.  
  3442.     filter_vec = LD_SH(filter_x);
  3443.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3444.  
  3445.     filter_vec = LD_SH(filter_y);
  3446.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  3447.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  3448.  
  3449.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  3450.  
  3451.     mask1 = mask0 + 2;
  3452.  
  3453.     const_vec = __msa_ldi_h(128);
  3454.     const_vec <<= 6;
  3455.  
  3456.     LD_SB3(src, src_stride, src0, src1, src2);
  3457.     src += (3 * src_stride);
  3458.  
  3459.     XORI_B3_128_SB(src0, src1, src2);
  3460.  
  3461.     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3462.     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3463.     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3464.  
  3465.     dst0 = const_vec;
  3466.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3467.     dst1 = const_vec;
  3468.     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3469.     dst2 = const_vec;
  3470.     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3471.  
  3472.     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
  3473.     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
  3474.  
  3475.     LD_SB2(src, src_stride, src3, src4);
  3476.     src += (2 * src_stride);
  3477.  
  3478.     XORI_B2_128_SB(src3, src4);
  3479.  
  3480.     /* row 3 */
  3481.     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3482.     dst3 = const_vec;
  3483.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3484.  
  3485.     ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
  3486.     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3487.  
  3488.     dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
  3489.  
  3490.     dst0_r >>= 6;
  3491.     dst0_l >>= 6;
  3492.  
  3493.     /* row 4 */
  3494.     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3495.     dst4 = const_vec;
  3496.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3497.  
  3498.     ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
  3499.     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3500.     dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
  3501.     dst1_r >>= 6;
  3502.     dst1_l >>= 6;
  3503.  
  3504.     LD_SB2(src, src_stride, src5, src6);
  3505.     src += (2 * src_stride);
  3506.  
  3507.     XORI_B2_128_SB(src5, src6);
  3508.  
  3509.     /* row 5 */
  3510.     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  3511.     dst5 = const_vec;
  3512.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  3513.  
  3514.     ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
  3515.     dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
  3516.     dst2_l = HEVC_FILT_4TAP(dst32_l, dst54_l, filt_h0, filt_h1);
  3517.     dst2_r >>= 6;
  3518.     dst2_l >>= 6;
  3519.  
  3520.     /* row 6 */
  3521.     VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  3522.     dst6 = const_vec;
  3523.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
  3524.  
  3525.     ILVRL_H2_SH(dst6, dst5, dst65_r, dst65_l);
  3526.     dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
  3527.     dst3_l = HEVC_FILT_4TAP(dst43_l, dst65_l, filt_h0, filt_h1);
  3528.     dst3_r >>= 6;
  3529.     dst3_l >>= 6;
  3530.  
  3531.     LD_SB2(src, src_stride, src7, src8);
  3532.  
  3533.     XORI_B2_128_SB(src7, src8);
  3534.  
  3535.     /* row 7 */
  3536.     VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
  3537.     dst7 = const_vec;
  3538.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
  3539.  
  3540.     ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
  3541.     dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
  3542.     dst4_l = HEVC_FILT_4TAP(dst54_l, dst76_l, filt_h0, filt_h1);
  3543.     dst4_r >>= 6;
  3544.     dst4_l >>= 6;
  3545.  
  3546.     /* row 8 */
  3547.     VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
  3548.     dst8 = const_vec;
  3549.     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
  3550.  
  3551.     ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
  3552.     dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
  3553.     dst5_l = HEVC_FILT_4TAP(dst65_l, dst87_l, filt_h0, filt_h1);
  3554.     dst5_r >>= 6;
  3555.     dst5_l >>= 6;
  3556.  
  3557.     PCKEV_H4_SW(dst0_l, dst0_r, dst1_l, dst1_r,
  3558.                 dst2_l, dst2_r, dst3_l, dst3_r, dst0_r, dst1_r, dst2_r, dst3_r);
  3559.     PCKEV_H2_SW(dst4_l, dst4_r, dst5_l, dst5_r, dst4_r, dst5_r);
  3560.  
  3561.     ST_SW2(dst0_r, dst1_r, dst, dst_stride);
  3562.     dst += (2 * dst_stride);
  3563.     ST_SW2(dst2_r, dst3_r, dst, dst_stride);
  3564.     dst += (2 * dst_stride);
  3565.     ST_SW2(dst4_r, dst5_r, dst, dst_stride);
  3566. }
  3567.  
  3568. static void hevc_hv_4t_8multx4mult_msa(uint8_t *src,
  3569.                                        int32_t src_stride,
  3570.                                        int16_t *dst,
  3571.                                        int32_t dst_stride,
  3572.                                        const int8_t *filter_x,
  3573.                                        const int8_t *filter_y,
  3574.                                        int32_t height,
  3575.                                        int32_t width)
  3576. {
  3577.     uint32_t loop_cnt, cnt;
  3578.     uint8_t *src_tmp;
  3579.     int16_t *dst_tmp;
  3580.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  3581.     v8i16 filt0, filt1;
  3582.     v4i32 filt_h0, filt_h1;
  3583.     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
  3584.     v16i8 mask1;
  3585.     v8i16 filter_vec, const_vec;
  3586.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  3587.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
  3588.     v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
  3589.     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
  3590.     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
  3591.  
  3592.     src -= (src_stride + 1);
  3593.  
  3594.     filter_vec = LD_SH(filter_x);
  3595.     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
  3596.  
  3597.     filter_vec = LD_SH(filter_y);
  3598.     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
  3599.     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
  3600.  
  3601.     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
  3602.  
  3603.     mask1 = mask0 + 2;
  3604.  
  3605.     const_vec = __msa_ldi_h(128);
  3606.     const_vec <<= 6;
  3607.  
  3608.     for (cnt = width >> 3; cnt--;) {
  3609.         src_tmp = src;
  3610.         dst_tmp = dst;
  3611.  
  3612.         LD_SB3(src_tmp, src_stride, src0, src1, src2);
  3613.         src_tmp += (3 * src_stride);
  3614.  
  3615.         XORI_B3_128_SB(src0, src1, src2);
  3616.  
  3617.         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
  3618.         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
  3619.         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
  3620.  
  3621.         dst0 = const_vec;
  3622.         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
  3623.         dst1 = const_vec;
  3624.         DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
  3625.         dst2 = const_vec;
  3626.         DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
  3627.  
  3628.         ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
  3629.         ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
  3630.  
  3631.         for (loop_cnt = height >> 2; loop_cnt--;) {
  3632.             LD_SB4(src_tmp, src_stride, src3, src4, src5, src6);
  3633.             src_tmp += (4 * src_stride);
  3634.             XORI_B4_128_SB(src3, src4, src5, src6);
  3635.  
  3636.             VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
  3637.             dst3 = const_vec;
  3638.             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
  3639.  
  3640.             ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
  3641.             dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
  3642.             dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
  3643.  
  3644.             dst0_r >>= 6;
  3645.             dst0_l >>= 6;
  3646.  
  3647.             /* row 4 */
  3648.             VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
  3649.             dst4 = const_vec;
  3650.             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
  3651.  
  3652.             ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
  3653.             dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
  3654.             dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
  3655.             dst1_r >>= 6;
  3656.             dst1_l >>= 6;
  3657.  
  3658.             /* row 5 */
  3659.             VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
  3660.             dst5 = const_vec;
  3661.             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
  3662.  
  3663.             ILVRL_H2_SH(dst5, dst4, dst10_r, dst10_l);
  3664.             dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
  3665.             dst2_l = HEVC_FILT_4TAP(dst32_l, dst10_l, filt_h0, filt_h1);
  3666.  
  3667.             dst2_r >>= 6;
  3668.             dst2_l >>= 6;
  3669.  
  3670.             /* row 6 */
  3671.             VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
  3672.             dst2 = const_vec;
  3673.             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
  3674.  
  3675.             ILVRL_H2_SH(dst2, dst5, dst21_r, dst21_l);
  3676.             dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
  3677.             dst3_l = HEVC_FILT_4TAP(dst43_l, dst21_l, filt_h0, filt_h1);
  3678.  
  3679.             dst3_r >>= 6;
  3680.             dst3_l >>= 6;
  3681.  
  3682.             PCKEV_H4_SW(dst0_l, dst0_r, dst1_l, dst1_r,
  3683.                         dst2_l, dst2_r, dst3_l, dst3_r,
  3684.                         dst0_r, dst1_r, dst2_r, dst3_r);
  3685.  
  3686.             ST_SW2(dst0_r, dst1_r, dst_tmp, dst_stride);
  3687.             dst_tmp += (2 * dst_stride);
  3688.             ST_SW2(dst2_r, dst3_r, dst_tmp, dst_stride);
  3689.             dst_tmp += (2 * dst_stride);
  3690.         }
  3691.  
  3692.         src += 8;
  3693.         dst += 8;
  3694.     }
  3695. }
  3696.  
  3697. static void hevc_hv_4t_8w_msa(uint8_t *src,
  3698.                               int32_t src_stride,
  3699.                               int16_t *dst,
  3700.                               int32_t dst_stride,
  3701.                               const int8_t *filter_x,
  3702.                               const int8_t *filter_y,
  3703.                               int32_t height)
  3704. {
  3705.  
  3706.     if (2 == height) {
  3707.         hevc_hv_4t_8x2_msa(src, src_stride, dst, dst_stride,
  3708.                            filter_x, filter_y, height);
  3709.     } else if (6 == height) {
  3710.         hevc_hv_4t_8x6_msa(src, src_stride, dst, dst_stride,
  3711.                            filter_x, filter_y, height);
  3712.     } else if (0 == (height % 4)) {
  3713.         hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  3714.                                    filter_x, filter_y, height, 8);
  3715.     }
  3716. }
  3717.  
  3718. static void hevc_hv_4t_12w_msa(uint8_t *src,
  3719.                                int32_t src_stride,
  3720.                                int16_t *dst,
  3721.                                int32_t dst_stride,
  3722.                                const int8_t *filter_x,
  3723.                                const int8_t *filter_y,
  3724.                                int32_t height)
  3725. {
  3726.     hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  3727.                                filter_x, filter_y, height, 8);
  3728.  
  3729.     hevc_hv_4t_4w_msa(src + 8, src_stride, dst + 8, dst_stride,
  3730.                       filter_x, filter_y, height);
  3731.  
  3732. }
  3733.  
  3734. static void hevc_hv_4t_16w_msa(uint8_t *src,
  3735.                                int32_t src_stride,
  3736.                                int16_t *dst,
  3737.                                int32_t dst_stride,
  3738.                                const int8_t *filter_x,
  3739.                                const int8_t *filter_y,
  3740.                                int32_t height)
  3741. {
  3742.     hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  3743.                                filter_x, filter_y, height, 16);
  3744. }
  3745.  
  3746. static void hevc_hv_4t_24w_msa(uint8_t *src,
  3747.                                int32_t src_stride,
  3748.                                int16_t *dst,
  3749.                                int32_t dst_stride,
  3750.                                const int8_t *filter_x,
  3751.                                const int8_t *filter_y,
  3752.                                int32_t height)
  3753. {
  3754.     hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  3755.                                filter_x, filter_y, height, 24);
  3756. }
  3757.  
  3758. static void hevc_hv_4t_32w_msa(uint8_t *src,
  3759.                                int32_t src_stride,
  3760.                                int16_t *dst,
  3761.                                int32_t dst_stride,
  3762.                                const int8_t *filter_x,
  3763.                                const int8_t *filter_y,
  3764.                                int32_t height)
  3765. {
  3766.     hevc_hv_4t_8multx4mult_msa(src, src_stride, dst, dst_stride,
  3767.                                filter_x, filter_y, height, 32);
  3768. }
  3769.  
  3770. #define MC_COPY(WIDTH)                                                    \
  3771. void ff_hevc_put_hevc_pel_pixels##WIDTH##_8_msa(int16_t *dst,             \
  3772.                                                 uint8_t *src,             \
  3773.                                                 ptrdiff_t src_stride,     \
  3774.                                                 int height,               \
  3775.                                                 intptr_t mx,              \
  3776.                                                 intptr_t my,              \
  3777.                                                 int width)                \
  3778. {                                                                         \
  3779.     hevc_copy_##WIDTH##w_msa(src, src_stride, dst, MAX_PB_SIZE, height);  \
  3780. }
  3781.  
  3782. MC_COPY(4);
  3783. MC_COPY(6);
  3784. MC_COPY(8);
  3785. MC_COPY(12);
  3786. MC_COPY(16);
  3787. MC_COPY(24);
  3788. MC_COPY(32);
  3789. MC_COPY(48);
  3790. MC_COPY(64);
  3791.  
  3792. #undef MC_COPY
  3793.  
  3794. #define MC(PEL, DIR, WIDTH, TAP, DIR1, FILT_DIR)                            \
  3795. void ff_hevc_put_hevc_##PEL##_##DIR##WIDTH##_8_msa(int16_t *dst,            \
  3796.                                                      uint8_t *src,          \
  3797.                                                      ptrdiff_t src_stride,  \
  3798.                                                      int height,            \
  3799.                                                      intptr_t mx,           \
  3800.                                                      intptr_t my,           \
  3801.                                                      int width)             \
  3802. {                                                                           \
  3803.     const int8_t *filter = ff_hevc_##PEL##_filters[FILT_DIR - 1];           \
  3804.                                                                             \
  3805.     hevc_##DIR1##_##TAP##t_##WIDTH##w_msa(src, src_stride, dst,             \
  3806.                                           MAX_PB_SIZE, filter, height);     \
  3807. }
  3808.  
  3809. MC(qpel, h, 4, 8, hz, mx);
  3810. MC(qpel, h, 8, 8, hz, mx);
  3811. MC(qpel, h, 12, 8, hz, mx);
  3812. MC(qpel, h, 16, 8, hz, mx);
  3813. MC(qpel, h, 24, 8, hz, mx);
  3814. MC(qpel, h, 32, 8, hz, mx);
  3815. MC(qpel, h, 48, 8, hz, mx);
  3816. MC(qpel, h, 64, 8, hz, mx);
  3817.  
  3818. MC(qpel, v, 4, 8, vt, my);
  3819. MC(qpel, v, 8, 8, vt, my);
  3820. MC(qpel, v, 12, 8, vt, my);
  3821. MC(qpel, v, 16, 8, vt, my);
  3822. MC(qpel, v, 24, 8, vt, my);
  3823. MC(qpel, v, 32, 8, vt, my);
  3824. MC(qpel, v, 48, 8, vt, my);
  3825. MC(qpel, v, 64, 8, vt, my);
  3826.  
  3827. MC(epel, h, 4, 4, hz, mx);
  3828. MC(epel, h, 6, 4, hz, mx);
  3829. MC(epel, h, 8, 4, hz, mx);
  3830. MC(epel, h, 12, 4, hz, mx);
  3831. MC(epel, h, 16, 4, hz, mx);
  3832. MC(epel, h, 24, 4, hz, mx);
  3833. MC(epel, h, 32, 4, hz, mx);
  3834.  
  3835. MC(epel, v, 4, 4, vt, my);
  3836. MC(epel, v, 6, 4, vt, my);
  3837. MC(epel, v, 8, 4, vt, my);
  3838. MC(epel, v, 12, 4, vt, my);
  3839. MC(epel, v, 16, 4, vt, my);
  3840. MC(epel, v, 24, 4, vt, my);
  3841. MC(epel, v, 32, 4, vt, my);
  3842.  
  3843. #undef MC
  3844.  
  3845. #define MC_HV(PEL, DIR, WIDTH, TAP, DIR1)                                     \
  3846. void ff_hevc_put_hevc_##PEL##_##DIR##WIDTH##_8_msa(int16_t *dst,              \
  3847.                                                      uint8_t *src,            \
  3848.                                                      ptrdiff_t src_stride,    \
  3849.                                                      int height,              \
  3850.                                                      intptr_t mx,             \
  3851.                                                      intptr_t my,             \
  3852.                                                      int width)               \
  3853. {                                                                             \
  3854.     const int8_t *filter_x = ff_hevc_##PEL##_filters[mx - 1];                 \
  3855.     const int8_t *filter_y = ff_hevc_##PEL##_filters[my - 1];                 \
  3856.                                                                               \
  3857.     hevc_##DIR1##_##TAP##t_##WIDTH##w_msa(src, src_stride, dst, MAX_PB_SIZE,  \
  3858.                                           filter_x, filter_y, height);        \
  3859. }
  3860.  
  3861. MC_HV(qpel, hv, 4, 8, hv);
  3862. MC_HV(qpel, hv, 8, 8, hv);
  3863. MC_HV(qpel, hv, 12, 8, hv);
  3864. MC_HV(qpel, hv, 16, 8, hv);
  3865. MC_HV(qpel, hv, 24, 8, hv);
  3866. MC_HV(qpel, hv, 32, 8, hv);
  3867. MC_HV(qpel, hv, 48, 8, hv);
  3868. MC_HV(qpel, hv, 64, 8, hv);
  3869.  
  3870. MC_HV(epel, hv, 4, 4, hv);
  3871. MC_HV(epel, hv, 6, 4, hv);
  3872. MC_HV(epel, hv, 8, 4, hv);
  3873. MC_HV(epel, hv, 12, 4, hv);
  3874. MC_HV(epel, hv, 16, 4, hv);
  3875. MC_HV(epel, hv, 24, 4, hv);
  3876. MC_HV(epel, hv, 32, 4, hv);
  3877.  
  3878. #undef MC_HV
  3879.