git.sesse.net Git - ffmpeg/blob - libavcodec/mips/hevc_mc_bi_msa.c

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