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 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
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 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
2230     v16i8 mask1;
2231     v8i16 tmp0, tmp1;
2232     v8i16 filter_vec, const_vec;
2233
2234     src0_ptr -= 1;
2235
2236     const_vec = __msa_ldi_h(128);
2237     const_vec <<= 6;
2238
2239     filter_vec = LD_SH(filter);
2240     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2241
2242     mask1 = mask0 + 2;
2243
2244     LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2245     LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2246
2247     ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
2248     XORI_B4_128_SB(src0, src1, src2, src3);
2249
2250     VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
2251     tmp0 = const_vec;
2252     DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp0, tmp0);
2253     VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
2254     tmp1 = const_vec;
2255     DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp1, tmp1);
2256     HEVC_BI_RND_CLIP2(in0, in1, tmp0, tmp1, 7, tmp0, tmp1);
2257     dst0 = __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
2258
2259     ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
2260 }
2261
2262 static void hevc_hz_bi_4t_4x8multiple_msa(uint8_t *src0_ptr,
2263                                           int32_t src_stride,
2264                                           int16_t *src1_ptr,
2265                                           int32_t src2_stride,
2266                                           uint8_t *dst,
2267                                           int32_t dst_stride,
2268                                           const int8_t *filter,
2269                                           int32_t height)
2270 {
2271     uint32_t loop_cnt;
2272     v8i16 filt0, filt1;
2273     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
2274     v16i8 dst0, dst1;
2275     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2276     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20 };
2277     v16i8 mask1, vec0, vec1;
2278     v8i16 tmp0, tmp1, tmp2, tmp3;
2279     v8i16 filter_vec, const_vec;
2280
2281     src0_ptr -= 1;
2282
2283     const_vec = __msa_ldi_h(128);
2284     const_vec <<= 6;
2285
2286     filter_vec = LD_SH(filter);
2287     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2288
2289     mask1 = mask0 + 2;
2290
2291     for (loop_cnt = (height >> 3); loop_cnt--;) {
2292         LD_SB8(src0_ptr, src_stride,
2293                src0, src1, src2, src3, src4, src5, src6, src7);
2294         src0_ptr += (8 * src_stride);
2295         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2296         src1_ptr += (4 * src2_stride);
2297         LD_SH4(src1_ptr, src2_stride, in4, in5, in6, in7);
2298         src1_ptr += (4 * src2_stride);
2299         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
2300         ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
2301         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
2302
2303         VSHF_B2_SB(src0, src1, src0, src1, mask0, mask1, vec0, vec1);
2304         tmp0 = const_vec;
2305         DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp0, tmp0);
2306         VSHF_B2_SB(src2, src3, src2, src3, mask0, mask1, vec0, vec1);
2307         tmp1 = const_vec;
2308         DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp1, tmp1);
2309         VSHF_B2_SB(src4, src5, src4, src5, mask0, mask1, vec0, vec1);
2310         tmp2 = const_vec;
2311         DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp2, tmp2);
2312         VSHF_B2_SB(src6, src7, src6, src7, mask0, mask1, vec0, vec1);
2313         tmp3 = const_vec;
2314         DPADD_SB2_SH(vec0, vec1, filt0, filt1, tmp3, tmp3);
2315
2316         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2317                           tmp0, tmp1, tmp2, tmp3, 7, tmp0, tmp1, tmp2, tmp3);
2318
2319         PCKEV_B2_SB(tmp1, tmp0, tmp3, tmp2, dst0, dst1);
2320         ST4x8_UB(dst0, dst1, dst, dst_stride);
2321         dst += (8 * dst_stride);
2322     }
2323 }
2324
2325 static void hevc_hz_bi_4t_4w_msa(uint8_t *src0_ptr,
2326                                  int32_t src_stride,
2327                                  int16_t *src1_ptr,
2328                                  int32_t src2_stride,
2329                                  uint8_t *dst,
2330                                  int32_t dst_stride,
2331                                  const int8_t *filter,
2332                                  int32_t height)
2333 {
2334     if (2 == height) {
2335         hevc_hz_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2336                               dst, dst_stride, filter, height);
2337     } else if (4 == height) {
2338         hevc_hz_bi_4t_4x4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2339                               dst, dst_stride, filter, height);
2340     } else if (8 == height || 16 == height) {
2341         hevc_hz_bi_4t_4x8multiple_msa(src0_ptr, src_stride,
2342                                       src1_ptr, src2_stride,
2343                                       dst, dst_stride, filter, height);
2344     }
2345 }
2346
2347 static void hevc_hz_bi_4t_6w_msa(uint8_t *src0_ptr,
2348                                  int32_t src_stride,
2349                                  int16_t *src1_ptr,
2350                                  int32_t src2_stride,
2351                                  uint8_t *dst,
2352                                  int32_t dst_stride,
2353                                  const int8_t *filter,
2354                                  int32_t height)
2355 {
2356     uint32_t loop_cnt;
2357     v8i16 filt0, filt1;
2358     v16i8 src0, src1, src2, src3;
2359     v8i16 in0, in1, in2, in3;
2360     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2361     v16i8 mask1;
2362     v16i8 vec0, vec1;
2363     v8i16 dst0, dst1, dst2, dst3;
2364     v8i16 filter_vec, const_vec;
2365
2366     src0_ptr -= 1;
2367
2368     const_vec = __msa_ldi_h(128);
2369     const_vec <<= 6;
2370
2371     filter_vec = LD_SH(filter);
2372     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2373
2374     mask1 = mask0 + 2;
2375
2376     for (loop_cnt = (height >> 2); loop_cnt--;) {
2377         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2378         src0_ptr += (4 * src_stride);
2379         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2380         src1_ptr += (4 * src2_stride);
2381         XORI_B4_128_SB(src0, src1, src2, src3);
2382
2383         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2384         dst0 = const_vec;
2385         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2386         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2387         dst1 = const_vec;
2388         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2389         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2390         dst2 = const_vec;
2391         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2392         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2393         dst3 = const_vec;
2394         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2395
2396         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2397                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2398
2399         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2400         ST6x4_UB(dst0, dst1, dst, dst_stride);
2401         dst += (4 * dst_stride);
2402     }
2403 }
2404
2405 static void hevc_hz_bi_4t_8x2_msa(uint8_t *src0_ptr,
2406                                   int32_t src_stride,
2407                                   int16_t *src1_ptr,
2408                                   int32_t src2_stride,
2409                                   uint8_t *dst,
2410                                   int32_t dst_stride,
2411                                   const int8_t *filter,
2412                                   int32_t height)
2413 {
2414     v8i16 filt0, filt1;
2415     v16i8 src0, src1;
2416     v8i16 in0, in1;
2417     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2418     v16i8 mask1, vec0, vec1;
2419     v8i16 dst0, dst1;
2420     v8i16 filter_vec, const_vec;
2421
2422     src0_ptr -= 1;
2423
2424     const_vec = __msa_ldi_h(128);
2425     const_vec <<= 6;
2426
2427     filter_vec = LD_SH(filter);
2428     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2429
2430     mask1 = mask0 + 2;
2431
2432     LD_SB2(src0_ptr, src_stride, src0, src1);
2433     LD_SH2(src1_ptr, src2_stride, in0, in1);
2434     XORI_B2_128_SB(src0, src1);
2435
2436     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2437     dst0 = const_vec;
2438     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2439     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2440     dst1 = const_vec;
2441     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2442     HEVC_BI_RND_CLIP2(in0, in1, dst0, dst1, 7, dst0, dst1);
2443
2444     dst0 = (v8i16) __msa_pckev_b((v16i8) dst1, (v16i8) dst0);
2445     ST8x2_UB(dst0, dst, dst_stride);
2446 }
2447
2448 static void hevc_hz_bi_4t_8x6_msa(uint8_t *src0_ptr,
2449                                   int32_t src_stride,
2450                                   int16_t *src1_ptr,
2451                                   int32_t src2_stride,
2452                                   uint8_t *dst,
2453                                   int32_t dst_stride,
2454                                   const int8_t *filter,
2455                                   int32_t height)
2456 {
2457     v8i16 filt0, filt1;
2458     v16i8 src0, src1, src2, src3, src4, src5;
2459     v8i16 in0, in1, in2, in3, in4, in5;
2460     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2461     v16i8 mask1;
2462     v16i8 vec0, vec1;
2463     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
2464     v8i16 filter_vec, const_vec;
2465
2466     src0_ptr -= 1;
2467
2468     const_vec = __msa_ldi_h(128);
2469     const_vec <<= 6;
2470
2471     filter_vec = LD_SH(filter);
2472     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2473
2474     mask1 = mask0 + 2;
2475
2476     LD_SB6(src0_ptr, src_stride, src0, src1, src2, src3, src4, src5);
2477     LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2478     src1_ptr += (4 * src2_stride);
2479     LD_SH2(src1_ptr, src2_stride, in4, in5);
2480     XORI_B6_128_SB(src0, src1, src2, src3, src4, src5);
2481
2482     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2483     dst0 = const_vec;
2484     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2485     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2486     dst1 = const_vec;
2487     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2488     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2489     dst2 = const_vec;
2490     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2491     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2492     dst3 = const_vec;
2493     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2494     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
2495     dst4 = const_vec;
2496     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2497     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
2498     dst5 = const_vec;
2499     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
2500
2501     HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2502                       dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2503     HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
2504
2505     PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2506     dst2 = (v8i16) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
2507     ST8x4_UB(dst0, dst1, dst, dst_stride);
2508     dst += (4 * dst_stride);
2509     ST8x2_UB(dst2, dst, dst_stride);
2510 }
2511
2512 static void hevc_hz_bi_4t_8x4multiple_msa(uint8_t *src0_ptr,
2513                                           int32_t src_stride,
2514                                           int16_t *src1_ptr,
2515                                           int32_t src2_stride,
2516                                           uint8_t *dst,
2517                                           int32_t dst_stride,
2518                                           const int8_t *filter,
2519                                           int32_t height)
2520 {
2521     uint32_t loop_cnt;
2522     v8i16 filt0, filt1;
2523     v16i8 src0, src1, src2, src3;
2524     v8i16 in0, in1, in2, in3;
2525     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2526     v16i8 mask1;
2527     v16i8 vec0, vec1;
2528     v8i16 dst0, dst1, dst2, dst3;
2529     v8i16 filter_vec, const_vec;
2530
2531     src0_ptr -= 1;
2532
2533     const_vec = __msa_ldi_h(128);
2534     const_vec <<= 6;
2535
2536     filter_vec = LD_SH(filter);
2537     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2538
2539     mask1 = mask0 + 2;
2540
2541     for (loop_cnt = (height >> 2); loop_cnt--;) {
2542         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2543         src0_ptr += (4 * src_stride);
2544         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2545         src1_ptr += (4 * src2_stride);
2546         XORI_B4_128_SB(src0, src1, src2, src3);
2547
2548         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2549         dst0 = const_vec;
2550         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2551         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2552         dst1 = const_vec;
2553         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2554         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2555         dst2 = const_vec;
2556         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2557         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2558         dst3 = const_vec;
2559         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2560
2561         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2562                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2563
2564         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2565         ST8x4_UB(dst0, dst1, dst, dst_stride);
2566         dst += (4 * dst_stride);
2567     }
2568 }
2569
2570 static void hevc_hz_bi_4t_8w_msa(uint8_t *src0_ptr,
2571                                  int32_t src_stride,
2572                                  int16_t *src1_ptr,
2573                                  int32_t src2_stride,
2574                                  uint8_t *dst,
2575                                  int32_t dst_stride,
2576                                  const int8_t *filter,
2577                                  int32_t height)
2578 {
2579     if (2 == height) {
2580         hevc_hz_bi_4t_8x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2581                               dst, dst_stride, filter, height);
2582     } else if (6 == height) {
2583         hevc_hz_bi_4t_8x6_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
2584                               dst, dst_stride, filter, height);
2585     } else if (0 == (height % 4)) {
2586         hevc_hz_bi_4t_8x4multiple_msa(src0_ptr, src_stride,
2587                                       src1_ptr, src2_stride,
2588                                       dst, dst_stride, filter, height);
2589     }
2590 }
2591
2592 static void hevc_hz_bi_4t_12w_msa(uint8_t *src0_ptr,
2593                                   int32_t src_stride,
2594                                   int16_t *src1_ptr,
2595                                   int32_t src2_stride,
2596                                   uint8_t *dst,
2597                                   int32_t dst_stride,
2598                                   const int8_t *filter,
2599                                   int32_t height)
2600 {
2601     uint32_t loop_cnt;
2602     v8i16 filt0, filt1;
2603     v16i8 src0, src1, src2, src3;
2604     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2605     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2606     v16i8 mask2 = {
2607         8, 9, 9, 10, 10, 11, 11, 12, 24, 25, 25, 26, 26, 27, 27, 28
2608     };
2609     v16i8 mask1, mask3;
2610     v16i8 vec0, vec1;
2611     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
2612     v8i16 filter_vec, const_vec;
2613
2614     src0_ptr -= 1;
2615
2616     const_vec = __msa_ldi_h(128);
2617     const_vec <<= 6;
2618
2619     filter_vec = LD_SH(filter);
2620     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2621
2622     mask1 = mask0 + 2;
2623     mask3 = mask2 + 2;
2624
2625     for (loop_cnt = (height >> 2); loop_cnt--;) {
2626         LD_SB4(src0_ptr, src_stride, src0, src1, src2, src3);
2627         src0_ptr += (4 * src_stride);
2628         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
2629         LD_SH4(src1_ptr + 8, src2_stride, in4, in5, in6, in7);
2630         src1_ptr += (4 * src2_stride);
2631
2632         ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
2633         XORI_B4_128_SB(src0, src1, src2, src3);
2634
2635         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2636         dst0 = const_vec;
2637         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2638         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2639         dst1 = const_vec;
2640         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2641         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2642         dst2 = const_vec;
2643         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2644         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2645         dst3 = const_vec;
2646         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2647         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2648         dst4 = const_vec;
2649         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2650         VSHF_B2_SB(src2, src3, src2, src3, mask2, mask3, vec0, vec1);
2651         dst5 = const_vec;
2652         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
2653
2654         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2655                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2656         HEVC_BI_RND_CLIP2(in4, in5, dst4, dst5, 7, dst4, dst5);
2657
2658         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2659         dst2 = (v8i16) __msa_pckev_b((v16i8) dst5, (v16i8) dst4);
2660         ST12x4_UB(dst0, dst1, dst2, dst, dst_stride);
2661         dst += (4 * dst_stride);
2662     }
2663 }
2664
2665 static void hevc_hz_bi_4t_16w_msa(uint8_t *src0_ptr,
2666                                   int32_t src_stride,
2667                                   int16_t *src1_ptr,
2668                                   int32_t src2_stride,
2669                                   uint8_t *dst,
2670                                   int32_t dst_stride,
2671                                   const int8_t *filter,
2672                                   int32_t height)
2673 {
2674     uint32_t loop_cnt;
2675     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
2676     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2677     v8i16 filt0, filt1;
2678     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2679     v16i8 mask1;
2680     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2681     v16i8 vec0, vec1;
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 >> 2); loop_cnt--;) {
2695         LD_SB4(src0_ptr, src_stride, src0, src2, src4, src6);
2696         LD_SB4(src0_ptr + 8, src_stride, src1, src3, src5, src7);
2697         src0_ptr += (4 * src_stride);
2698         LD_SH4(src1_ptr, src2_stride, in0, in2, in4, in6);
2699         LD_SH4(src1_ptr + 8, src2_stride, in1, in3, in5, in7);
2700         src1_ptr += (4 * src2_stride);
2701         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
2702
2703         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2704         dst0 = const_vec;
2705         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2706         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2707         dst1 = const_vec;
2708         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2709         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2710         dst2 = const_vec;
2711         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2712         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2713         dst3 = const_vec;
2714         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2715         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
2716         dst4 = const_vec;
2717         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2718         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
2719         dst5 = const_vec;
2720         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
2721         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
2722         dst6 = const_vec;
2723         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
2724         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
2725         dst7 = const_vec;
2726         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
2727
2728         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2729                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2730         HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
2731                           dst4, dst5, dst6, dst7, 7, dst4, dst5, dst6, dst7);
2732
2733         PCKEV_B4_SH(dst1, dst0, dst3, dst2,
2734                     dst5, dst4, dst7, dst6, dst0, dst1, dst2, dst3);
2735         ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
2736         dst += (4 * dst_stride);
2737     }
2738 }
2739
2740 static void hevc_hz_bi_4t_24w_msa(uint8_t *src0_ptr,
2741                                   int32_t src_stride,
2742                                   int16_t *src1_ptr,
2743                                   int32_t src2_stride,
2744                                   uint8_t *dst,
2745                                   int32_t dst_stride,
2746                                   const int8_t *filter,
2747                                   int32_t height)
2748 {
2749     int16_t *src1_ptr_tmp;
2750     uint8_t *dst_tmp;
2751     uint32_t loop_cnt;
2752     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
2753     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
2754     v8i16 filt0, filt1;
2755     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2756     v16i8 mask1, mask2, mask3;
2757     v16i8 vec0, vec1;
2758     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2759     v8i16 filter_vec, const_vec;
2760
2761     src0_ptr -= 1;
2762
2763     const_vec = __msa_ldi_h(128);
2764     const_vec <<= 6;
2765
2766     filter_vec = LD_SH(filter);
2767     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2768
2769     mask1 = mask0 + 2;
2770     mask2 = mask0 + 8;
2771     mask3 = mask0 + 10;
2772
2773     dst_tmp = dst + 16;
2774     src1_ptr_tmp = src1_ptr + 16;
2775
2776     for (loop_cnt = (height >> 2); loop_cnt--;) {
2777         LD_SB4(src0_ptr, src_stride, src0, src2, src4, src6);
2778         LD_SB4(src0_ptr + 16, src_stride, src1, src3, src5, src7);
2779         src0_ptr += (4 * src_stride);
2780         LD_SH4(src1_ptr, src2_stride, in0, in2, in4, in6);
2781         LD_SH4(src1_ptr + 8, src2_stride, in1, in3, in5, in7);
2782         src1_ptr += (4 * src2_stride);
2783         XORI_B8_128_SB(src0, src1, src2, src3, src4, src5, src6, src7);
2784
2785         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2786         dst0 = const_vec;
2787         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2788         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2789         dst1 = const_vec;
2790         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2791         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2792         dst2 = const_vec;
2793         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2794         VSHF_B2_SB(src2, src3, src2, src3, mask2, mask3, vec0, vec1);
2795         dst3 = const_vec;
2796         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2797         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
2798         dst4 = const_vec;
2799         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
2800         VSHF_B2_SB(src4, src5, src4, src5, mask2, mask3, vec0, vec1);
2801         dst5 = const_vec;
2802         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
2803         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
2804         dst6 = const_vec;
2805         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
2806         VSHF_B2_SB(src6, src7, src6, src7, mask2, mask3, vec0, vec1);
2807         dst7 = const_vec;
2808         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
2809
2810         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2811                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2812         HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
2813                           dst4, dst5, dst6, dst7, 7, dst4, dst5, dst6, dst7);
2814
2815         PCKEV_B4_SH(dst1, dst0, dst3, dst2,
2816                     dst5, dst4, dst7, dst6, dst0, dst1, dst2, dst3);
2817         ST_SH4(dst0, dst1, dst2, dst3, dst, dst_stride);
2818         dst += (4 * dst_stride);
2819
2820         LD_SH4(src1_ptr_tmp, src2_stride, in0, in1, in2, in3);
2821         src1_ptr_tmp += (4 * src2_stride);
2822
2823         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2824         dst0 = const_vec;
2825         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2826         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
2827         dst1 = const_vec;
2828         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2829         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
2830         dst2 = const_vec;
2831         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2832         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
2833         dst3 = const_vec;
2834         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2835
2836         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2837                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2838
2839         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2840         ST8x4_UB(dst0, dst1, dst_tmp, dst_stride);
2841         dst_tmp += (4 * dst_stride);
2842     }
2843 }
2844
2845 static void hevc_hz_bi_4t_32w_msa(uint8_t *src0_ptr,
2846                                   int32_t src_stride,
2847                                   int16_t *src1_ptr,
2848                                   int32_t src2_stride,
2849                                   uint8_t *dst,
2850                                   int32_t dst_stride,
2851                                   const int8_t *filter,
2852                                   int32_t height)
2853 {
2854     uint32_t loop_cnt;
2855     v16i8 src0, src1, src2;
2856     v8i16 in0, in1, in2, in3;
2857     v8i16 filt0, filt1;
2858     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
2859     v16i8 mask1, mask2, mask3;
2860     v8i16 dst0, dst1, dst2, dst3;
2861     v16i8 vec0, vec1;
2862     v8i16 filter_vec, const_vec;
2863
2864     src0_ptr -= 1;
2865
2866     const_vec = __msa_ldi_h(128);
2867     const_vec <<= 6;
2868
2869     filter_vec = LD_SH(filter);
2870     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2871
2872     mask1 = mask0 + 2;
2873     mask2 = mask0 + 8;
2874     mask3 = mask0 + 10;
2875
2876     for (loop_cnt = (height >> 1); loop_cnt--;) {
2877         LD_SB2(src0_ptr, 16, src0, src1);
2878         src2 = LD_SB(src0_ptr + 24);
2879         src0_ptr += src_stride;
2880         LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
2881         src1_ptr += src2_stride;
2882         XORI_B3_128_SB(src0, src1, src2);
2883
2884         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2885         dst0 = const_vec;
2886         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2887         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2888         dst1 = const_vec;
2889         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2890         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2891         dst2 = const_vec;
2892         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2893         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2894         dst3 = const_vec;
2895         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2896
2897         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2898                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2899
2900         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2901         ST_SH2(dst0, dst1, dst, 16);
2902         dst += dst_stride;
2903
2904         LD_SB2(src0_ptr, 16, src0, src1);
2905         src2 = LD_SB(src0_ptr + 24);
2906         src0_ptr += src_stride;
2907         LD_SH4(src1_ptr, 8, in0, in1, in2, in3);
2908         src1_ptr += src2_stride;
2909         XORI_B3_128_SB(src0, src1, src2);
2910
2911         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
2912         dst0 = const_vec;
2913         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
2914         VSHF_B2_SB(src0, src1, src0, src1, mask2, mask3, vec0, vec1);
2915         dst1 = const_vec;
2916         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst1, dst1);
2917         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec0, vec1);
2918         dst2 = const_vec;
2919         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
2920         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec0, vec1);
2921         dst3 = const_vec;
2922         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
2923
2924         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
2925                           dst0, dst1, dst2, dst3, 7, dst0, dst1, dst2, dst3);
2926
2927         PCKEV_B2_SH(dst1, dst0, dst3, dst2, dst0, dst1);
2928         ST_SH2(dst0, dst1, dst, 16);
2929         dst += dst_stride;
2930     }
2931 }
2932
2933 static void hevc_vt_bi_4t_4x2_msa(uint8_t *src0_ptr,
2934                                   int32_t src_stride,
2935                                   int16_t *src1_ptr,
2936                                   int32_t src2_stride,
2937                                   uint8_t *dst,
2938                                   int32_t dst_stride,
2939                                   const int8_t *filter,
2940                                   int32_t height)
2941 {
2942     v16i8 src0, src1, src2, src3, src4;
2943     v8i16 in0, in1;
2944     v16i8 src10_r, src32_r, src21_r, src43_r, src2110, src4332;
2945     v8i16 dst10;
2946     v8i16 filt0, filt1;
2947     v8i16 filter_vec, const_vec;
2948
2949     src0_ptr -= src_stride;
2950
2951     const_vec = __msa_ldi_h(128);
2952     const_vec <<= 6;
2953
2954     filter_vec = LD_SH(filter);
2955     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
2956
2957     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
2958     src0_ptr += (3 * src_stride);
2959
2960     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
2961     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
2962     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
2963
2964     LD_SB2(src0_ptr, src_stride, src3, src4);
2965     LD_SH2(src1_ptr, src2_stride, in0, in1);
2966     in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
2967     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
2968     src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_r, (v2i64) src32_r);
2969     src4332 = (v16i8) __msa_xori_b((v16u8) src4332, 128);
2970
2971     dst10 = const_vec;
2972     DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
2973     dst10 = __msa_adds_s_h(dst10, in0);
2974     dst10 = __msa_srari_h(dst10, 7);
2975     dst10 = CLIP_SH_0_255(dst10);
2976
2977     dst10 = (v8i16) __msa_pckev_b((v16i8) dst10, (v16i8) dst10);
2978     ST4x2_UB(dst10, dst, dst_stride);
2979 }
2980
2981 static void hevc_vt_bi_4t_4x4_msa(uint8_t *src0_ptr,
2982                                   int32_t src_stride,
2983                                   int16_t *src1_ptr,
2984                                   int32_t src2_stride,
2985                                   uint8_t *dst,
2986                                   int32_t dst_stride,
2987                                   const int8_t *filter,
2988                                   int32_t height)
2989 {
2990     v16i8 src0, src1, src2, src3, src4, src5, src6;
2991     v8i16 in0, in1, in2, in3;
2992     v16i8 src10_r, src32_r, src54_r, src21_r, src43_r, src65_r;
2993     v16i8 src2110, src4332, src6554;
2994     v8i16 dst10, dst32;
2995     v8i16 filt0, filt1;
2996     v8i16 filter_vec, const_vec;
2997
2998     src0_ptr -= src_stride;
2999
3000     const_vec = __msa_ldi_h(128);
3001     const_vec <<= 6;
3002
3003     filter_vec = LD_SH(filter);
3004     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3005
3006     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3007     src0_ptr += (3 * src_stride);
3008     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3009     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
3010     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
3011
3012     LD_SB4(src0_ptr, src_stride, src3, src4, src5, src6);
3013     LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3014     ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
3015     ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
3016                src32_r, src43_r, src54_r, src65_r);
3017     ILVR_D2_SB(src43_r, src32_r, src65_r, src54_r, src4332, src6554);
3018     XORI_B2_128_SB(src4332, src6554);
3019
3020     dst10 = const_vec;
3021     DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
3022     dst32 = const_vec;
3023     DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
3024     HEVC_BI_RND_CLIP2(in0, in1, dst10, dst32, 7, dst10, dst32);
3025
3026     dst10 = (v8i16) __msa_pckev_b((v16i8) dst32, (v16i8) dst10);
3027     ST4x4_UB(dst10, dst10, 0, 1, 2, 3, dst, dst_stride);
3028 }
3029
3030 static void hevc_vt_bi_4t_4x8multiple_msa(uint8_t *src0_ptr,
3031                                           int32_t src_stride,
3032                                           int16_t *src1_ptr,
3033                                           int32_t src2_stride,
3034                                           uint8_t *dst,
3035                                           int32_t dst_stride,
3036                                           const int8_t *filter,
3037                                           int32_t height)
3038 {
3039     int32_t loop_cnt;
3040     v16i8 src0, src1, src2, src3, src4, src5;
3041     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3042     v16i8 src6, src7, src8, src9;
3043     v16i8 src10_r, src32_r, src54_r, src76_r, src98_r;
3044     v16i8 src21_r, src43_r, src65_r, src87_r, src109_r;
3045     v16i8 src2110, src4332, src6554, src8776;
3046     v8i16 dst10, dst32, dst54, dst76;
3047     v8i16 filt0, filt1;
3048     v8i16 filter_vec, const_vec;
3049
3050     src0_ptr -= src_stride;
3051
3052     const_vec = __msa_ldi_h(128);
3053     const_vec <<= 6;
3054
3055     filter_vec = LD_SH(filter);
3056     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3057
3058     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3059     src0_ptr += (3 * src_stride);
3060     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3061     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_r, (v2i64) src10_r);
3062     src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
3063
3064     for (loop_cnt = (height >> 3); loop_cnt--;) {
3065         LD_SB6(src0_ptr, src_stride, src3, src4, src5, src6, src7, src8);
3066         src0_ptr += (6 * src_stride);
3067         LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
3068         src1_ptr += (8 * src2_stride);
3069         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
3070         ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
3071         ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
3072                    src32_r, src43_r, src54_r, src65_r);
3073         ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3074         ILVR_D3_SB(src43_r, src32_r, src65_r, src54_r, src87_r, src76_r,
3075                    src4332, src6554, src8776);
3076         XORI_B3_128_SB(src4332, src6554, src8776);
3077
3078         dst10 = const_vec;
3079         DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst10, dst10);
3080         dst32 = const_vec;
3081         DPADD_SB2_SH(src4332, src6554, filt0, filt1, dst32, dst32);
3082         dst54 = const_vec;
3083         DPADD_SB2_SH(src6554, src8776, filt0, filt1, dst54, dst54);
3084
3085         LD_SB2(src0_ptr, src_stride, src9, src2);
3086         src0_ptr += (2 * src_stride);
3087         ILVR_B2_SB(src9, src8, src2, src9, src98_r, src109_r);
3088         src2110 = (v16i8) __msa_ilvr_d((v2i64) src109_r, (v2i64) src98_r);
3089         src2110 = (v16i8) __msa_xori_b((v16u8) src2110, 128);
3090         dst76 = const_vec;
3091         DPADD_SB2_SH(src8776, src2110, filt0, filt1, dst76, dst76);
3092
3093         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3094                           dst10, dst32, dst54, dst76, 7,
3095                           dst10, dst32, dst54, dst76);
3096
3097         PCKEV_B2_SH(dst32, dst10, dst76, dst54, dst10, dst54);
3098         ST4x8_UB(dst10, dst54, dst, dst_stride);
3099         dst += (8 * dst_stride);
3100     }
3101 }
3102
3103 static void hevc_vt_bi_4t_4w_msa(uint8_t *src0_ptr,
3104                                  int32_t src_stride,
3105                                  int16_t *src1_ptr,
3106                                  int32_t src2_stride,
3107                                  uint8_t *dst,
3108                                  int32_t dst_stride,
3109                                  const int8_t *filter,
3110                                  int32_t height)
3111 {
3112     if (2 == height) {
3113         hevc_vt_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3114                               dst, dst_stride, filter, height);
3115     } else if (4 == height) {
3116         hevc_vt_bi_4t_4x4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3117                               dst, dst_stride, filter, height);
3118     } else {
3119         hevc_vt_bi_4t_4x8multiple_msa(src0_ptr, src_stride,
3120                                       src1_ptr, src2_stride,
3121                                       dst, dst_stride, filter, height);
3122     }
3123 }
3124
3125 static void hevc_vt_bi_4t_6w_msa(uint8_t *src0_ptr,
3126                                  int32_t src_stride,
3127                                  int16_t *src1_ptr,
3128                                  int32_t src2_stride,
3129                                  uint8_t *dst,
3130                                  int32_t dst_stride,
3131                                  const int8_t *filter,
3132                                  int32_t height)
3133 {
3134     int32_t loop_cnt;
3135     v16i8 src0, src1, src2, src3, src4, src5;
3136     v8i16 in0, in1, in2, in3;
3137     v16i8 src10_r, src32_r, src21_r, src43_r;
3138     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3139     v8i16 filt0, filt1;
3140     v8i16 filter_vec, const_vec;
3141
3142     src0_ptr -= src_stride;
3143
3144     const_vec = __msa_ldi_h(128);
3145     const_vec <<= 6;
3146
3147     filter_vec = LD_SH(filter);
3148     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3149
3150     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3151     src0_ptr += (3 * src_stride);
3152     XORI_B3_128_SB(src0, src1, src2);
3153     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3154
3155     for (loop_cnt = (height >> 2); loop_cnt--;) {
3156         LD_SB2(src0_ptr, src_stride, src3, src4);
3157         src0_ptr += (2 * src_stride);
3158         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3159         src1_ptr += (4 * src2_stride);
3160         XORI_B2_128_SB(src3, src4);
3161         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3162
3163         dst0_r = const_vec;
3164         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3165         dst1_r = const_vec;
3166         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3167
3168         LD_SB2(src0_ptr, src_stride, src5, src2);
3169         src0_ptr += (2 * src_stride);
3170         XORI_B2_128_SB(src5, src2);
3171         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3172
3173         dst2_r = const_vec;
3174         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
3175         dst3_r = const_vec;
3176         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
3177
3178         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3179                           dst0_r, dst1_r, dst2_r, dst3_r, 7,
3180                           dst0_r, dst1_r, dst2_r, dst3_r);
3181
3182         PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3183         ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
3184         dst += (4 * dst_stride);
3185     }
3186 }
3187
3188 static void hevc_vt_bi_4t_8x2_msa(uint8_t *src0_ptr,
3189                                   int32_t src_stride,
3190                                   int16_t *src1_ptr,
3191                                   int32_t src2_stride,
3192                                   uint8_t *dst,
3193                                   int32_t dst_stride,
3194                                   const int8_t *filter,
3195                                   int32_t height)
3196 {
3197     v16i8 src0, src1, src2, src3, src4;
3198     v8i16 in0, in1, dst0_r, dst1_r;
3199     v16i8 src10_r, src32_r, src21_r, src43_r;
3200     v8i16 filt0, filt1;
3201     v8i16 filter_vec, const_vec;
3202
3203     src0_ptr -= src_stride;
3204
3205     const_vec = __msa_ldi_h(128);
3206     const_vec <<= 6;
3207
3208     filter_vec = LD_SH(filter);
3209     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3210
3211     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3212     src0_ptr += (3 * src_stride);
3213     XORI_B3_128_SB(src0, src1, src2);
3214     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3215
3216     LD_SB2(src0_ptr, src_stride, src3, src4);
3217     LD_SH2(src1_ptr, src2_stride, in0, in1);
3218     XORI_B2_128_SB(src3, src4);
3219     ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3220
3221     dst0_r = const_vec;
3222     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3223     dst1_r = const_vec;
3224     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3225
3226     HEVC_BI_RND_CLIP2(in0, in1, dst0_r, dst1_r, 7, dst0_r, dst1_r);
3227     dst0_r = (v8i16) __msa_pckev_b((v16i8) dst1_r, (v16i8) dst0_r);
3228
3229     ST8x2_UB(dst0_r, dst, dst_stride);
3230 }
3231
3232 static void hevc_vt_bi_4t_8x6_msa(uint8_t *src0_ptr,
3233                                   int32_t src_stride,
3234                                   int16_t *src1_ptr,
3235                                   int32_t src2_stride,
3236                                   uint8_t *dst,
3237                                   int32_t dst_stride,
3238                                   const int8_t *filter,
3239                                   int32_t height)
3240 {
3241     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
3242     v8i16 in0, in1, in2, in3, in4, in5;
3243     v16i8 src10_r, src32_r, src54_r, src76_r;
3244     v16i8 src21_r, src43_r, src65_r, src87_r;
3245     v8i16 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r;
3246     v8i16 filt0, filt1;
3247     v8i16 filter_vec, const_vec;
3248
3249     src0_ptr -= src_stride;
3250
3251     const_vec = __msa_ldi_h(128);
3252     const_vec <<= 6;
3253
3254     filter_vec = LD_SH(filter);
3255     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3256
3257     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3258     src0_ptr += (3 * src_stride);
3259     XORI_B3_128_SB(src0, src1, src2);
3260     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3261
3262     LD_SB6(src0_ptr, src_stride, src3, src4, src5, src6, src7, src8);
3263     LD_SH6(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5);
3264     XORI_B6_128_SB(src3, src4, src5, src6, src7, src8);
3265     ILVR_B4_SB(src3, src2, src4, src3, src5, src4, src6, src5,
3266                src32_r, src43_r, src54_r, src65_r);
3267     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3268
3269     dst0_r = const_vec;
3270     DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3271     dst1_r = const_vec;
3272     DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3273     dst2_r = const_vec;
3274     DPADD_SB2_SH(src32_r, src54_r, filt0, filt1, dst2_r, dst2_r);
3275     dst3_r = const_vec;
3276     DPADD_SB2_SH(src43_r, src65_r, filt0, filt1, dst3_r, dst3_r);
3277     dst4_r = const_vec;
3278     DPADD_SB2_SH(src54_r, src76_r, filt0, filt1, dst4_r, dst4_r);
3279     dst5_r = const_vec;
3280     DPADD_SB2_SH(src65_r, src87_r, filt0, filt1, dst5_r, dst5_r);
3281     HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3282                       dst0_r, dst1_r, dst2_r, dst3_r, 7,
3283                       dst0_r, dst1_r, dst2_r, dst3_r);
3284     HEVC_BI_RND_CLIP2(in4, in5, dst4_r, dst5_r, 7, dst4_r, dst5_r);
3285
3286     PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3287     dst2_r = (v8i16) __msa_pckev_b((v16i8) dst5_r, (v16i8) dst4_r);
3288     ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
3289     dst += (4 * dst_stride);
3290     ST8x2_UB(dst2_r, dst, dst_stride);
3291 }
3292
3293 static void hevc_vt_bi_4t_8x4multiple_msa(uint8_t *src0_ptr,
3294                                           int32_t src_stride,
3295                                           int16_t *src1_ptr,
3296                                           int32_t src2_stride,
3297                                           uint8_t *dst,
3298                                           int32_t dst_stride,
3299                                           const int8_t *filter,
3300                                           int32_t height)
3301 {
3302     int32_t loop_cnt;
3303     v16i8 src0, src1, src2, src3, src4, src5;
3304     v8i16 in0, in1, in2, in3;
3305     v16i8 src10_r, src32_r, src21_r, src43_r;
3306     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3307     v8i16 filt0, filt1;
3308     v8i16 filter_vec, const_vec;
3309
3310     src0_ptr -= src_stride;
3311
3312     const_vec = __msa_ldi_h(128);
3313     const_vec <<= 6;
3314
3315     filter_vec = LD_SH(filter);
3316     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3317
3318     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3319     src0_ptr += (3 * src_stride);
3320     XORI_B3_128_SB(src0, src1, src2);
3321     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3322
3323     for (loop_cnt = (height >> 2); loop_cnt--;) {
3324         LD_SB2(src0_ptr, src_stride, src3, src4);
3325         src0_ptr += (2 * src_stride);
3326         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3327         src1_ptr += (4 * src2_stride);
3328         XORI_B2_128_SB(src3, src4);
3329         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3330
3331         dst0_r = const_vec;
3332         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3333         dst1_r = const_vec;
3334         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3335
3336         LD_SB2(src0_ptr, src_stride, src5, src2);
3337         src0_ptr += (2 * src_stride);
3338         XORI_B2_128_SB(src5, src2);
3339         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3340
3341         dst2_r = const_vec;
3342         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
3343         dst3_r = const_vec;
3344         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
3345         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3346                           dst0_r, dst1_r, dst2_r, dst3_r, 7,
3347                           dst0_r, dst1_r, dst2_r, dst3_r);
3348
3349         PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3350         ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
3351         dst += (4 * dst_stride);
3352     }
3353 }
3354
3355 static void hevc_vt_bi_4t_8w_msa(uint8_t *src0_ptr,
3356                                  int32_t src_stride,
3357                                  int16_t *src1_ptr,
3358                                  int32_t src2_stride,
3359                                  uint8_t *dst,
3360                                  int32_t dst_stride,
3361                                  const int8_t *filter,
3362                                  int32_t height)
3363 {
3364     if (2 == height) {
3365         hevc_vt_bi_4t_8x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3366                               dst, dst_stride, filter, height);
3367     } else if (6 == height) {
3368         hevc_vt_bi_4t_8x6_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
3369                               dst, dst_stride, filter, height);
3370     } else {
3371         hevc_vt_bi_4t_8x4multiple_msa(src0_ptr, src_stride,
3372                                       src1_ptr, src2_stride,
3373                                       dst, dst_stride, filter, height);
3374     }
3375 }
3376
3377 static void hevc_vt_bi_4t_12w_msa(uint8_t *src0_ptr,
3378                                   int32_t src_stride,
3379                                   int16_t *src1_ptr,
3380                                   int32_t src2_stride,
3381                                   uint8_t *dst,
3382                                   int32_t dst_stride,
3383                                   const int8_t *filter,
3384                                   int32_t height)
3385 {
3386     int32_t loop_cnt;
3387     v16i8 src0, src1, src2, src3, src4, src5;
3388     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3389     v16i8 src10_r, src32_r, src21_r, src43_r;
3390     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3391     v16i8 src10_l, src32_l, src54_l, src21_l, src43_l, src65_l;
3392     v16i8 src2110, src4332;
3393     v8i16 dst0_l, dst1_l, filt0, filt1;
3394     v8i16 filter_vec, const_vec;
3395
3396     src0_ptr -= (1 * src_stride);
3397
3398     const_vec = __msa_ldi_h(128);
3399     const_vec <<= 6;
3400
3401     filter_vec = LD_SH(filter);
3402     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3403
3404     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3405     src0_ptr += (3 * src_stride);
3406     XORI_B3_128_SB(src0, src1, src2);
3407     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3408     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3409     src2110 = (v16i8) __msa_ilvr_d((v2i64) src21_l, (v2i64) src10_l);
3410
3411     for (loop_cnt = (height >> 2); loop_cnt--;) {
3412         LD_SB2(src0_ptr, src_stride, src3, src4);
3413         src0_ptr += (2 * src_stride);
3414         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3415         LD_SH4((src1_ptr + 8), src2_stride, in4, in5, in6, in7);
3416         src1_ptr += (4 * src2_stride);
3417         ILVR_D2_SH(in5, in4, in7, in6, in4, in5);
3418         XORI_B2_128_SB(src3, src4);
3419
3420         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3421         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3422         src4332 = (v16i8) __msa_ilvr_d((v2i64) src43_l, (v2i64) src32_l);
3423
3424         dst0_r = const_vec;
3425         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3426         dst1_r = const_vec;
3427         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3428         dst0_l = const_vec;
3429         DPADD_SB2_SH(src2110, src4332, filt0, filt1, dst0_l, dst0_l);
3430
3431         LD_SB2(src0_ptr, src_stride, src5, src2);
3432         src0_ptr += (2 * src_stride);
3433         XORI_B2_128_SB(src5, src2);
3434
3435         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3436         ILVL_B2_SB(src5, src4, src2, src5, src54_l, src65_l);
3437         src2110 = (v16i8) __msa_ilvr_d((v2i64) src65_l, (v2i64) src54_l);
3438
3439         dst2_r = const_vec;
3440         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst2_r, dst2_r);
3441         dst3_r = const_vec;
3442         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst3_r, dst3_r);
3443         dst1_l = const_vec;
3444         DPADD_SB2_SH(src4332, src2110, filt0, filt1, dst1_l, dst1_l);
3445         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3446                           dst0_r, dst1_r, dst2_r, dst3_r, 7,
3447                           dst0_r, dst1_r, dst2_r, dst3_r);
3448         HEVC_BI_RND_CLIP2(in4, in5, dst0_l, dst1_l, 7, dst0_l, dst1_l);
3449
3450         PCKEV_B2_SH(dst1_r, dst0_r, dst3_r, dst2_r, dst0_r, dst1_r);
3451         dst0_l = (v8i16) __msa_pckev_b((v16i8) dst1_l, (v16i8) dst0_l);
3452         ST12x4_UB(dst0_r, dst1_r, dst0_l, dst, dst_stride);
3453         dst += (4 * dst_stride);
3454     }
3455 }
3456
3457 static void hevc_vt_bi_4t_16w_msa(uint8_t *src0_ptr,
3458                                   int32_t src_stride,
3459                                   int16_t *src1_ptr,
3460                                   int32_t src2_stride,
3461                                   uint8_t *dst,
3462                                   int32_t dst_stride,
3463                                   const int8_t *filter,
3464                                   int32_t height)
3465 {
3466     int32_t loop_cnt;
3467     v16i8 src0, src1, src2, src3, src4, src5;
3468     v8i16 in0, in1, in2, in3;
3469     v16i8 src10_r, src32_r, src21_r, src43_r;
3470     v16i8 src10_l, src32_l, src21_l, src43_l;
3471     v8i16 dst0_r, dst1_r, dst0_l, dst1_l;
3472     v8i16 filt0, filt1;
3473     v8i16 filter_vec, const_vec;
3474
3475     src0_ptr -= src_stride;
3476
3477     const_vec = __msa_ldi_h(128);
3478     const_vec <<= 6;
3479
3480     filter_vec = LD_SH(filter);
3481     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3482
3483     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3484     src0_ptr += (3 * src_stride);
3485     XORI_B3_128_SB(src0, src1, src2);
3486     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3487     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3488
3489     for (loop_cnt = (height >> 2); loop_cnt--;) {
3490         LD_SB2(src0_ptr, src_stride, src3, src4);
3491         src0_ptr += (2 * src_stride);
3492         LD_SH2(src1_ptr, src2_stride, in0, in1);
3493         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3494         src1_ptr += (2 * src2_stride);
3495         XORI_B2_128_SB(src3, src4);
3496         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3497         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3498
3499         dst0_r = const_vec;
3500         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3501         dst1_r = const_vec;
3502         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3503         dst0_l = const_vec;
3504         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3505         dst1_l = const_vec;
3506         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3507         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3508                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3509                           dst0_r, dst1_r, dst0_l, dst1_l);
3510
3511         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3512         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3513         dst += (2 * dst_stride);
3514
3515         LD_SB2(src0_ptr, src_stride, src5, src2);
3516         src0_ptr += (2 * src_stride);
3517         LD_SH2(src1_ptr, src2_stride, in0, in1);
3518         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3519         src1_ptr += (2 * src2_stride);
3520         XORI_B2_128_SB(src5, src2);
3521         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3522         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
3523
3524         dst0_r = const_vec;
3525         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
3526         dst0_l = const_vec;
3527         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
3528         dst1_r = const_vec;
3529         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
3530         dst1_l = const_vec;
3531         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
3532         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3533                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3534                           dst0_r, dst1_r, dst0_l, dst1_l);
3535
3536         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3537         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3538         dst += (2 * dst_stride);
3539     }
3540 }
3541
3542 static void hevc_vt_bi_4t_24w_msa(uint8_t *src0_ptr,
3543                                   int32_t src_stride,
3544                                   int16_t *src1_ptr,
3545                                   int32_t src2_stride,
3546                                   uint8_t *dst,
3547                                   int32_t dst_stride,
3548                                   const int8_t *filter,
3549                                   int32_t height)
3550 {
3551     uint32_t loop_cnt;
3552     v16i8 src0, src1, src2, src3, src4, src5;
3553     v16i8 src6, src7, src8, src9, src10, src11;
3554     v8i16 in0, in1, in2, in3, in4, in5;
3555     v16i8 src10_r, src32_r, src76_r, src98_r;
3556     v16i8 src21_r, src43_r, src87_r, src109_r;
3557     v16i8 src10_l, src32_l, src21_l, src43_l;
3558     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3559     v8i16 dst0_l, dst1_l;
3560     v8i16 filt0, filt1;
3561     v8i16 filter_vec, const_vec;
3562
3563     src0_ptr -= src_stride;
3564
3565     const_vec = __msa_ldi_h(128);
3566     const_vec <<= 6;
3567
3568     filter_vec = LD_SH(filter);
3569     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3570
3571     /* 16width */
3572     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3573     XORI_B3_128_SB(src0, src1, src2);
3574     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3575     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3576     /* 8width */
3577     LD_SB3(src0_ptr + 16, src_stride, src6, src7, src8);
3578     src0_ptr += (3 * src_stride);
3579     XORI_B3_128_SB(src6, src7, src8);
3580     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3581
3582     for (loop_cnt = (height >> 2); loop_cnt--;) {
3583         /* 16width */
3584         LD_SB2(src0_ptr, src_stride, src3, src4);
3585         LD_SH2(src1_ptr, src2_stride, in0, in1);
3586         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3587         LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3588         src1_ptr += (2 * src2_stride);
3589         XORI_B2_128_SB(src3, src4);
3590         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3591         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3592         /* 8width */
3593         LD_SB2(src0_ptr + 16, src_stride, src9, src10);
3594         src0_ptr += (2 * src_stride);
3595         XORI_B2_128_SB(src9, src10);
3596         ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
3597         /* 16width */
3598         dst0_r = const_vec;
3599         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3600         dst0_l = const_vec;
3601         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3602         dst1_r = const_vec;
3603         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3604         dst1_l = const_vec;
3605         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3606         /* 8width */
3607         dst2_r = const_vec;
3608         DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
3609         dst3_r = const_vec;
3610         DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
3611         /* 16width */
3612         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3613                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3614                           dst0_r, dst1_r, dst0_l, dst1_l);
3615
3616         HEVC_BI_RND_CLIP2(in4, in5, dst2_r, dst3_r, 7, dst2_r, dst3_r);
3617
3618         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3619         dst2_r = (v8i16) __msa_pckev_b((v16i8) dst3_r, (v16i8) dst2_r);
3620         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3621         ST8x2_UB(dst2_r, dst + 16, dst_stride);
3622         dst += (2 * dst_stride);
3623
3624         /* 16width */
3625         LD_SB2(src0_ptr, src_stride, src5, src2);
3626         LD_SH2(src1_ptr, src2_stride, in0, in1);
3627         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3628         LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3629         src1_ptr += (2 * src2_stride);
3630         XORI_B2_128_SB(src5, src2);
3631         ILVR_B2_SB(src5, src4, src2, src5, src10_r, src21_r);
3632         ILVL_B2_SB(src5, src4, src2, src5, src10_l, src21_l);
3633         /* 8width */
3634         LD_SB2(src0_ptr + 16, src_stride, src11, src8);
3635         src0_ptr += (2 * src_stride);
3636         XORI_B2_128_SB(src11, src8);
3637         ILVR_B2_SB(src11, src10, src8, src11, src76_r, src87_r);
3638         /* 16width */
3639         dst0_r = const_vec;
3640         DPADD_SB2_SH(src32_r, src10_r, filt0, filt1, dst0_r, dst0_r);
3641         dst0_l = const_vec;
3642         DPADD_SB2_SH(src32_l, src10_l, filt0, filt1, dst0_l, dst0_l);
3643         dst1_r = const_vec;
3644         DPADD_SB2_SH(src43_r, src21_r, filt0, filt1, dst1_r, dst1_r);
3645         dst1_l = const_vec;
3646         DPADD_SB2_SH(src43_l, src21_l, filt0, filt1, dst1_l, dst1_l);
3647         /* 8width */
3648         dst2_r = const_vec;
3649         DPADD_SB2_SH(src98_r, src76_r, filt0, filt1, dst2_r, dst2_r);
3650         dst3_r = const_vec;
3651         DPADD_SB2_SH(src109_r, src87_r, filt0, filt1, dst3_r, dst3_r);
3652
3653         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3654                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3655                           dst0_r, dst1_r, dst0_l, dst1_l);
3656         HEVC_BI_RND_CLIP2(in4, in5, dst2_r, dst3_r, 7, dst2_r, dst3_r);
3657
3658         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3659         dst2_r = (v8i16) __msa_pckev_b((v16i8) dst3_r, (v16i8) dst2_r);
3660         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3661         ST8x2_UB(dst2_r, dst + 16, dst_stride);
3662         dst += (2 * dst_stride);
3663     }
3664 }
3665
3666 static void hevc_vt_bi_4t_32w_msa(uint8_t *src0_ptr,
3667                                   int32_t src_stride,
3668                                   int16_t *src1_ptr,
3669                                   int32_t src2_stride,
3670                                   uint8_t *dst,
3671                                   int32_t dst_stride,
3672                                   const int8_t *filter,
3673                                   int32_t height)
3674 {
3675     uint32_t loop_cnt;
3676     uint8_t *dst_tmp = dst + 16;
3677     v16i8 src0, src1, src2, src3, src4, src6, src7, src8, src9, src10;
3678     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3679     v16i8 src10_r, src32_r, src76_r, src98_r;
3680     v16i8 src21_r, src43_r, src87_r, src109_r;
3681     v8i16 dst0_r, dst1_r, dst2_r, dst3_r;
3682     v16i8 src10_l, src32_l, src76_l, src98_l;
3683     v16i8 src21_l, src43_l, src87_l, src109_l;
3684     v8i16 dst0_l, dst1_l, dst2_l, dst3_l;
3685     v8i16 filt0, filt1;
3686     v8i16 filter_vec, const_vec;
3687
3688     src0_ptr -= src_stride;
3689
3690     const_vec = __msa_ldi_h(128);
3691     const_vec <<= 6;
3692
3693     filter_vec = LD_SH(filter);
3694     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3695
3696     /* 16width */
3697     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3698     XORI_B3_128_SB(src0, src1, src2);
3699     ILVR_B2_SB(src1, src0, src2, src1, src10_r, src21_r);
3700     ILVL_B2_SB(src1, src0, src2, src1, src10_l, src21_l);
3701
3702     /* next 16width */
3703     LD_SB3(src0_ptr + 16, src_stride, src6, src7, src8);
3704     src0_ptr += (3 * src_stride);
3705     XORI_B3_128_SB(src6, src7, src8);
3706     ILVR_B2_SB(src7, src6, src8, src7, src76_r, src87_r);
3707     ILVL_B2_SB(src7, src6, src8, src7, src76_l, src87_l);
3708
3709     for (loop_cnt = (height >> 1); loop_cnt--;) {
3710         /* 16width */
3711         LD_SB2(src0_ptr, src_stride, src3, src4);
3712         LD_SH2(src1_ptr, src2_stride, in0, in1);
3713         LD_SH2((src1_ptr + 8), src2_stride, in2, in3);
3714         LD_SH2((src1_ptr + 16), src2_stride, in4, in5);
3715         LD_SH2((src1_ptr + 24), src2_stride, in6, in7);
3716         src1_ptr += (2 * src2_stride);
3717         XORI_B2_128_SB(src3, src4);
3718         ILVR_B2_SB(src3, src2, src4, src3, src32_r, src43_r);
3719         ILVL_B2_SB(src3, src2, src4, src3, src32_l, src43_l);
3720         /* 16width */
3721         dst0_r = const_vec;
3722         DPADD_SB2_SH(src10_r, src32_r, filt0, filt1, dst0_r, dst0_r);
3723         dst0_l = const_vec;
3724         DPADD_SB2_SH(src10_l, src32_l, filt0, filt1, dst0_l, dst0_l);
3725         dst1_r = const_vec;
3726         DPADD_SB2_SH(src21_r, src43_r, filt0, filt1, dst1_r, dst1_r);
3727         dst1_l = const_vec;
3728         DPADD_SB2_SH(src21_l, src43_l, filt0, filt1, dst1_l, dst1_l);
3729         /* 16width */
3730         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
3731                           dst0_r, dst1_r, dst0_l, dst1_l, 7,
3732                           dst0_r, dst1_r, dst0_l, dst1_l);
3733
3734         src10_r = src32_r;
3735         src21_r = src43_r;
3736         src10_l = src32_l;
3737         src21_l = src43_l;
3738         src2 = src4;
3739
3740         PCKEV_B2_SH(dst0_l, dst0_r, dst1_l, dst1_r, dst0_r, dst1_r);
3741         ST_SH2(dst0_r, dst1_r, dst, dst_stride);
3742         dst += (2 * dst_stride);
3743
3744         /* next 16width */
3745         LD_SB2(src0_ptr + 16, src_stride, src9, src10);
3746         src0_ptr += (2 * src_stride);
3747         XORI_B2_128_SB(src9, src10);
3748         ILVR_B2_SB(src9, src8, src10, src9, src98_r, src109_r);
3749         ILVL_B2_SB(src9, src8, src10, src9, src98_l, src109_l);
3750         /* next 16width */
3751         dst2_r = const_vec;
3752         DPADD_SB2_SH(src76_r, src98_r, filt0, filt1, dst2_r, dst2_r);
3753         dst2_l = const_vec;
3754         DPADD_SB2_SH(src76_l, src98_l, filt0, filt1, dst2_l, dst2_l);
3755         dst3_r = const_vec;
3756         DPADD_SB2_SH(src87_r, src109_r, filt0, filt1, dst3_r, dst3_r);
3757         dst3_l = const_vec;
3758         DPADD_SB2_SH(src87_l, src109_l, filt0, filt1, dst3_l, dst3_l);
3759         /* next 16width */
3760         HEVC_BI_RND_CLIP4(in4, in5, in6, in7,
3761                           dst2_r, dst3_r, dst2_l, dst3_l, 7,
3762                           dst2_r, dst3_r, dst2_l, dst3_l);
3763
3764         PCKEV_B2_SH(dst2_l, dst2_r, dst3_l, dst3_r, dst2_r, dst3_r);
3765         ST_SH2(dst2_r, dst3_r, dst_tmp, dst_stride);
3766         dst_tmp += (2 * dst_stride);
3767
3768         src76_r = src98_r;
3769         src87_r = src109_r;
3770         src76_l = src98_l;
3771         src87_l = src109_l;
3772         src8 = src10;
3773     }
3774 }
3775
3776 static void hevc_hv_bi_4t_4x2_msa(uint8_t *src0_ptr,
3777                                   int32_t src_stride,
3778                                   int16_t *src1_ptr,
3779                                   int32_t src2_stride,
3780                                   uint8_t *dst,
3781                                   int32_t dst_stride,
3782                                   const int8_t *filter_x,
3783                                   const int8_t *filter_y,
3784                                   int32_t height)
3785 {
3786     v8i16 in0, in1;
3787     v16i8 src0, src1, src2, src3, src4;
3788     v8i16 filt0, filt1;
3789     v4i32 filt_h0, filt_h1;
3790     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3791     v16i8 mask1;
3792     v8i16 filter_vec, const_vec;
3793     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3794     v8i16 dst0, dst1, dst2, dst3, dst4;
3795     v4i32 dst0_r, dst1_r;
3796     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
3797
3798     src0_ptr -= (src_stride + 1);
3799
3800     filter_vec = LD_SH(filter_x);
3801     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3802
3803     filter_vec = LD_SH(filter_y);
3804     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3805     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3806
3807     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3808
3809     mask1 = mask0 + 2;
3810
3811     const_vec = __msa_ldi_h(128);
3812     const_vec <<= 6;
3813
3814     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3815     src0_ptr += (3 * src_stride);
3816     XORI_B3_128_SB(src0, src1, src2);
3817
3818     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3819     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3820     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3821     dst0 = const_vec;
3822     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3823     dst1 = const_vec;
3824     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3825     dst2 = const_vec;
3826     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3827     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
3828
3829     LD_SB2(src0_ptr, src_stride, src3, src4);
3830     LD_SH2(src1_ptr, src2_stride, in0, in1);
3831     in0 = (v8i16) __msa_ilvr_d((v2i64) in1, (v2i64) in0);
3832     XORI_B2_128_SB(src3, src4);
3833     /* row 3 */
3834     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3835     dst3 = const_vec;
3836     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3837     dst32_r = __msa_ilvr_h(dst3, dst2);
3838     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3839     dst0_r >>= 6;
3840     /* row 4 */
3841     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3842     dst4 = const_vec;
3843     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3844     dst43_r = __msa_ilvr_h(dst4, dst3);
3845     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3846     dst1_r >>= 6;
3847     dst0_r = (v4i32) __msa_pckev_h((v8i16) dst1_r, (v8i16) dst0_r);
3848     dst0_r = (v4i32) __msa_adds_s_h((v8i16) dst0_r, in0);
3849     dst0_r = (v4i32) __msa_srari_h((v8i16) dst0_r, 7);
3850     dst0_r = (v4i32) CLIP_SH_0_255(dst0_r);
3851
3852     dst0_r = (v4i32) __msa_pckev_b((v16i8) dst0_r, (v16i8) dst0_r);
3853     ST4x2_UB(dst0_r, dst, dst_stride);
3854 }
3855
3856 static void hevc_hv_bi_4t_4x4_msa(uint8_t *src0_ptr,
3857                                   int32_t src_stride,
3858                                   int16_t *src1_ptr,
3859                                   int32_t src2_stride,
3860                                   uint8_t *dst,
3861                                   int32_t dst_stride,
3862                                   const int8_t *filter_x,
3863                                   const int8_t *filter_y,
3864                                   int32_t height)
3865 {
3866     v8i16 in0, in1, in2, in3;
3867     v16i8 src0, src1, src2, src3, src4, src5, src6;
3868     v8i16 filt0, filt1;
3869     v4i32 filt_h0, filt_h1;
3870     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3871     v16i8 mask1;
3872     v8i16 filter_vec, const_vec;
3873     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3874     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
3875     v8i16 dst0_r, dst1_r;
3876     v4i32 tmp0, tmp1, tmp2, tmp3;
3877     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
3878
3879     src0_ptr -= (src_stride + 1);
3880
3881     filter_vec = LD_SH(filter_x);
3882     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3883
3884     filter_vec = LD_SH(filter_y);
3885     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3886     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3887
3888     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3889
3890     mask1 = mask0 + 2;
3891
3892     const_vec = __msa_ldi_h(128);
3893     const_vec <<= 6;
3894
3895     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3896     src0_ptr += (3 * src_stride);
3897     XORI_B3_128_SB(src0, src1, src2);
3898
3899     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3900     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3901     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3902     dst0 = const_vec;
3903     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
3904     dst1 = const_vec;
3905     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
3906     dst2 = const_vec;
3907     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
3908     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
3909
3910     LD_SB4(src0_ptr, src_stride, src3, src4, src5, src6);
3911     LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
3912     ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
3913     XORI_B4_128_SB(src3, src4, src5, src6);
3914     /* row 3 */
3915     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
3916     dst3 = const_vec;
3917     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
3918     dst32_r = __msa_ilvr_h(dst3, dst2);
3919     tmp0 = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
3920     tmp0 >>= 6;
3921     /* row 4 */
3922     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
3923     dst4 = const_vec;
3924     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
3925     dst43_r = __msa_ilvr_h(dst4, dst3);
3926     tmp1 = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
3927     tmp1 >>= 6;
3928     /* row 5 */
3929     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
3930     dst5 = const_vec;
3931     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
3932     dst10_r = __msa_ilvr_h(dst5, dst4);
3933     tmp2 = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
3934     tmp2 >>= 6;
3935     /* row 6 */
3936     VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
3937     dst2 = const_vec;
3938     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
3939     dst21_r = __msa_ilvr_h(dst2, dst5);
3940     tmp3 = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
3941     tmp3 >>= 6;
3942     PCKEV_H2_SH(tmp1, tmp0, tmp3, tmp2, dst0_r, dst1_r);
3943     HEVC_BI_RND_CLIP2(in0, in1, dst0_r, dst1_r, 7, dst0_r, dst1_r);
3944
3945     dst0_r = (v8i16) __msa_pckev_b((v16i8) dst1_r, (v16i8) dst0_r);
3946     ST4x4_UB(dst0_r, dst0_r, 0, 1, 2, 3, dst, dst_stride);
3947     dst += (4 * dst_stride);
3948 }
3949
3950 static void hevc_hv_bi_4t_4multx8mult_msa(uint8_t *src0_ptr,
3951                                           int32_t src_stride,
3952                                           int16_t *src1_ptr,
3953                                           int32_t src2_stride,
3954                                           uint8_t *dst,
3955                                           int32_t dst_stride,
3956                                           const int8_t *filter_x,
3957                                           const int8_t *filter_y,
3958                                           int32_t height)
3959 {
3960     uint32_t loop_cnt;
3961     v8i16 in0, in1, in2, in3, in4, in5, in6, in7;
3962     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8, src9, src10;
3963     v8i16 filt0, filt1;
3964     v4i32 filt_h0, filt_h1;
3965     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
3966     v16i8 mask1;
3967     v8i16 filter_vec, const_vec;
3968     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
3969     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8, dst9;
3970     v8i16 tmp0, tmp1, tmp2, tmp3;
3971     v8i16 dst10_r, dst32_r, dst54_r, dst76_r;
3972     v8i16 dst21_r, dst43_r, dst65_r, dst87_r;
3973     v4i32 dst0_r, dst1_r, dst2_r, dst3_r, dst4_r, dst5_r, dst6_r, dst7_r;
3974
3975     src0_ptr -= (src_stride + 1);
3976
3977     filter_vec = LD_SH(filter_x);
3978     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
3979
3980     filter_vec = LD_SH(filter_y);
3981     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
3982     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
3983
3984     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
3985
3986     mask1 = mask0 + 2;
3987
3988     const_vec = __msa_ldi_h(128);
3989     const_vec <<= 6;
3990
3991     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
3992     src0_ptr += (3 * src_stride);
3993     XORI_B3_128_SB(src0, src1, src2);
3994
3995     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
3996     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
3997     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
3998     dst0 = const_vec;
3999     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
4000     dst1 = const_vec;
4001     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
4002     dst2 = const_vec;
4003     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
4004     ILVR_H2_SH(dst1, dst0, dst2, dst1, dst10_r, dst21_r);
4005
4006     for (loop_cnt = height >> 3; loop_cnt--;) {
4007         LD_SB8(src0_ptr, src_stride,
4008                src3, src4, src5, src6, src7, src8, src9, src10);
4009         src0_ptr += (8 * src_stride);
4010         LD_SH8(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5, in6, in7);
4011         src1_ptr += (8 * src2_stride);
4012         ILVR_D2_SH(in1, in0, in3, in2, in0, in1);
4013         ILVR_D2_SH(in5, in4, in7, in6, in2, in3);
4014         XORI_B8_128_SB(src3, src4, src5, src6, src7, src8, src9, src10);
4015         /* row 3 */
4016         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4017         dst3 = const_vec;
4018         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
4019         dst32_r = __msa_ilvr_h(dst3, dst2);
4020         dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4021         dst0_r >>= 6;
4022         /* row 4 */
4023         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
4024         dst4 = const_vec;
4025         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
4026         dst43_r = __msa_ilvr_h(dst4, dst3);
4027         dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4028         dst1_r >>= 6;
4029         /* row 5 */
4030         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
4031         dst5 = const_vec;
4032         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
4033         dst54_r = __msa_ilvr_h(dst5, dst4);
4034         dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4035         dst2_r >>= 6;
4036         /* row 6 */
4037         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
4038         dst6 = const_vec;
4039         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
4040         dst65_r = __msa_ilvr_h(dst6, dst5);
4041         dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4042         dst3_r >>= 6;
4043         /* row 7 */
4044         VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
4045         dst7 = const_vec;
4046         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
4047         dst76_r = __msa_ilvr_h(dst7, dst6);
4048         dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
4049         dst4_r >>= 6;
4050         /* row 8 */
4051         VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
4052         dst8 = const_vec;
4053         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
4054         dst87_r = __msa_ilvr_h(dst8, dst7);
4055         dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
4056         dst5_r >>= 6;
4057         /* row 9 */
4058         VSHF_B2_SB(src9, src9, src9, src9, mask0, mask1, vec0, vec1);
4059         dst9 = const_vec;
4060         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst9, dst9);
4061         dst10_r = __msa_ilvr_h(dst9, dst8);
4062         dst6_r = HEVC_FILT_4TAP(dst76_r, dst10_r, filt_h0, filt_h1);
4063         dst6_r >>= 6;
4064         /* row 10 */
4065         VSHF_B2_SB(src10, src10, src10, src10, mask0, mask1, vec0, vec1);
4066         dst2 = const_vec;
4067         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
4068         dst21_r = __msa_ilvr_h(dst2, dst9);
4069         dst7_r = HEVC_FILT_4TAP(dst87_r, dst21_r, filt_h0, filt_h1);
4070         dst7_r >>= 6;
4071         PCKEV_H4_SH(dst1_r, dst0_r, dst3_r, dst2_r,
4072                     dst5_r, dst4_r, dst7_r, dst6_r, tmp0, tmp1, tmp2, tmp3);
4073         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
4074                           tmp0, tmp1, tmp2, tmp3, 7, tmp0, tmp1, tmp2, tmp3);
4075
4076         PCKEV_B2_SH(tmp1, tmp0, tmp3, tmp2, tmp0, tmp1);
4077         ST4x8_UB(tmp0, tmp1, dst, dst_stride);
4078         dst += (8 * dst_stride);
4079     }
4080 }
4081
4082 static void hevc_hv_bi_4t_4w_msa(uint8_t *src0_ptr,
4083                                  int32_t src_stride,
4084                                  int16_t *src1_ptr,
4085                                  int32_t src2_stride,
4086                                  uint8_t *dst,
4087                                  int32_t dst_stride,
4088                                  const int8_t *filter_x,
4089                                  const int8_t *filter_y,
4090                                  int32_t height)
4091 {
4092     if (2 == height) {
4093         hevc_hv_bi_4t_4x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4094                               dst, dst_stride, filter_x, filter_y, height);
4095     } else if (4 == height) {
4096         hevc_hv_bi_4t_4x4_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4097                               dst, dst_stride, filter_x, filter_y, height);
4098     } else if (0 == (height % 8)) {
4099         hevc_hv_bi_4t_4multx8mult_msa(src0_ptr, src_stride,
4100                                       src1_ptr, src2_stride,
4101                                       dst, dst_stride,
4102                                       filter_x, filter_y, height);
4103     }
4104 }
4105
4106 static void hevc_hv_bi_4t_6w_msa(uint8_t *src0_ptr,
4107                                  int32_t src_stride,
4108                                  int16_t *src1_ptr,
4109                                  int32_t src2_stride,
4110                                  uint8_t *dst,
4111                                  int32_t dst_stride,
4112                                  const int8_t *filter_x,
4113                                  const int8_t *filter_y,
4114                                  int32_t height)
4115 {
4116     uint32_t loop_cnt;
4117     v16i8 src0, src1, src2, src3, src4, src5, src6;
4118     v8i16 in0, in1, in2, in3;
4119     v8i16 filt0, filt1;
4120     v4i32 filt_h0, filt_h1;
4121     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
4122     v16i8 mask1;
4123     v8i16 filter_vec, const_vec;
4124     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
4125     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
4126     v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
4127     v8i16 tmp0, tmp1, tmp2, tmp3;
4128     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
4129     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
4130
4131     src0_ptr -= (src_stride + 1);
4132
4133     filter_vec = LD_SH(filter_x);
4134     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4135
4136     filter_vec = LD_SH(filter_y);
4137     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
4138     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
4139
4140     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
4141
4142     mask1 = mask0 + 2;
4143
4144     const_vec = __msa_ldi_h(128);
4145     const_vec <<= 6;
4146
4147     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
4148     src0_ptr += (3 * src_stride);
4149     XORI_B3_128_SB(src0, src1, src2);
4150
4151     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4152     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4153     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4154     dst0 = const_vec;
4155     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
4156     dst1 = const_vec;
4157     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
4158     dst2 = const_vec;
4159     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
4160
4161     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
4162     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
4163
4164     for (loop_cnt = height >> 2; loop_cnt--;) {
4165         LD_SB4(src0_ptr, src_stride, src3, src4, src5, src6);
4166         src0_ptr += (4 * src_stride);
4167         LD_SH4(src1_ptr, src2_stride, in0, in1, in2, in3);
4168         src1_ptr += (4 * src2_stride);
4169         XORI_B4_128_SB(src3, src4, src5, src6);
4170
4171         VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4172         dst3 = const_vec;
4173         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
4174
4175         ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
4176         dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4177         dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4178         dst0_r >>= 6;
4179         dst0_l >>= 6;
4180
4181         VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
4182         dst4 = const_vec;
4183         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
4184
4185         ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
4186         dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4187         dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4188         dst1_r >>= 6;
4189         dst1_l >>= 6;
4190
4191         VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
4192         dst5 = const_vec;
4193         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
4194
4195         ILVRL_H2_SH(dst5, dst4, dst10_r, dst10_l);
4196         dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
4197         dst2_l = HEVC_FILT_4TAP(dst32_l, dst10_l, filt_h0, filt_h1);
4198         dst2_r >>= 6;
4199         dst2_l >>= 6;
4200
4201         VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
4202         dst2 = const_vec;
4203         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
4204
4205         ILVRL_H2_SH(dst2, dst5, dst21_r, dst21_l);
4206         dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
4207         dst3_l = HEVC_FILT_4TAP(dst43_l, dst21_l, filt_h0, filt_h1);
4208         dst3_r >>= 6;
4209         dst3_l >>= 6;
4210         PCKEV_H4_SH(dst0_l, dst0_r, dst1_l, dst1_r,
4211                     dst2_l, dst2_r, dst3_l, dst3_r, tmp0, tmp1, tmp2, tmp3);
4212         HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
4213                           tmp0, tmp1, tmp2, tmp3, 7, tmp0, tmp1, tmp2, tmp3);
4214
4215         PCKEV_B2_SW(tmp1, tmp0, tmp3, tmp2, dst0_r, dst1_r);
4216         ST6x4_UB(dst0_r, dst1_r, dst, dst_stride);
4217         dst += (4 * dst_stride);
4218     }
4219 }
4220
4221 static void hevc_hv_bi_4t_8x2_msa(uint8_t *src0_ptr,
4222                                   int32_t src_stride,
4223                                   int16_t *src1_ptr,
4224                                   int32_t src2_stride,
4225                                   uint8_t *dst,
4226                                   int32_t dst_stride,
4227                                   const int8_t *filter_x,
4228                                   const int8_t *filter_y,
4229                                   int32_t height)
4230 {
4231     v16i8 src0, src1, src2, src3, src4;
4232     v8i16 filt0, filt1;
4233     v4i32 filt_h0, filt_h1;
4234     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
4235     v16i8 mask1;
4236     v8i16 filter_vec, const_vec;
4237     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
4238     v8i16 dst0, dst1, dst2, dst3, dst4;
4239     v4i32 dst0_r, dst0_l, dst1_r, dst1_l;
4240     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
4241     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
4242     v8i16 tmp0, tmp1;
4243     v8i16 in0, in1;
4244
4245     src0_ptr -= (src_stride + 1);
4246
4247     filter_vec = LD_SH(filter_x);
4248     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4249
4250     filter_vec = LD_SH(filter_y);
4251     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
4252     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
4253
4254     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
4255
4256     mask1 = mask0 + 2;
4257
4258     const_vec = __msa_ldi_h(128);
4259     const_vec <<= 6;
4260
4261     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
4262     src0_ptr += (3 * src_stride);
4263     XORI_B3_128_SB(src0, src1, src2);
4264
4265     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4266     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4267     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4268     dst0 = const_vec;
4269     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
4270     dst1 = const_vec;
4271     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
4272     dst2 = const_vec;
4273     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
4274
4275     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
4276     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
4277
4278     LD_SB2(src0_ptr, src_stride, src3, src4);
4279     LD_SH2(src1_ptr, src2_stride, in0, in1);
4280     XORI_B2_128_SB(src3, src4);
4281
4282     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4283     dst3 = const_vec;
4284     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
4285
4286     ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
4287     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4288     dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4289     dst0_r >>= 6;
4290     dst0_l >>= 6;
4291
4292     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
4293     dst4 = const_vec;
4294     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
4295
4296     ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
4297     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4298     dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4299     dst1_r >>= 6;
4300     dst1_l >>= 6;
4301
4302     PCKEV_H2_SH(dst0_l, dst0_r, dst1_l, dst1_r, tmp0, tmp1);
4303     HEVC_BI_RND_CLIP2(in0, in1, tmp0, tmp1, 7, tmp0, tmp1);
4304
4305     dst0_r = (v4i32) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
4306     ST8x2_UB(dst0_r, dst, dst_stride);
4307 }
4308
4309 static void hevc_hv_bi_4t_8x6_msa(uint8_t *src0_ptr,
4310                                   int32_t src_stride,
4311                                   int16_t *src1_ptr,
4312                                   int32_t src2_stride,
4313                                   uint8_t *dst,
4314                                   int32_t dst_stride,
4315                                   const int8_t *filter_x,
4316                                   const int8_t *filter_y,
4317                                   int32_t height)
4318 {
4319     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
4320     v8i16 in0, in1, in2, in3, in4, in5;
4321     v8i16 filt0, filt1;
4322     v4i32 filt_h0, filt_h1;
4323     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
4324     v16i8 mask1;
4325     v8i16 filter_vec, const_vec;
4326     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
4327     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5;
4328     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst8;
4329     v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
4330     v4i32 dst4_r, dst4_l, dst5_r, dst5_l;
4331     v8i16 dst10_r, dst32_r, dst10_l, dst32_l;
4332     v8i16 dst21_r, dst43_r, dst21_l, dst43_l;
4333     v8i16 dst54_r, dst54_l, dst65_r, dst65_l;
4334     v8i16 dst76_r, dst76_l, dst87_r, dst87_l;
4335
4336     src0_ptr -= (src_stride + 1);
4337
4338     filter_vec = LD_SH(filter_x);
4339     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4340
4341     filter_vec = LD_SH(filter_y);
4342     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
4343     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
4344
4345     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
4346
4347     mask1 = mask0 + 2;
4348
4349     const_vec = __msa_ldi_h(128);
4350     const_vec <<= 6;
4351
4352     LD_SB3(src0_ptr, src_stride, src0, src1, src2);
4353     src0_ptr += (3 * src_stride);
4354     XORI_B3_128_SB(src0, src1, src2);
4355     VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4356     VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4357     VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4358     dst0 = const_vec;
4359     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
4360     dst1 = const_vec;
4361     DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
4362     dst2 = const_vec;
4363     DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
4364
4365     ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
4366     ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
4367
4368     LD_SB2(src0_ptr, src_stride, src3, src4);
4369     src0_ptr += (2 * src_stride);
4370     XORI_B2_128_SB(src3, src4);
4371     LD_SH6(src1_ptr, src2_stride, in0, in1, in2, in3, in4, in5);
4372     VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4373     dst3 = const_vec;
4374     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
4375
4376     ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
4377     dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4378     dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4379     dst0_r >>= 6;
4380     dst0_l >>= 6;
4381     tmp0 = __msa_pckev_h((v8i16) dst0_l, (v8i16) dst0_r);
4382
4383     VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
4384     dst4 = const_vec;
4385     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
4386
4387     ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
4388     dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4389     dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4390     dst1_r >>= 6;
4391     dst1_l >>= 6;
4392     tmp1 = __msa_pckev_h((v8i16) dst1_l, (v8i16) dst1_r);
4393
4394     LD_SB2(src0_ptr, src_stride, src5, src6);
4395     src0_ptr += (2 * src_stride);
4396     XORI_B2_128_SB(src5, src6);
4397     /* row 5 */
4398     VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
4399     dst5 = const_vec;
4400     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
4401
4402     ILVRL_H2_SH(dst5, dst4, dst54_r, dst54_l);
4403     dst2_r = HEVC_FILT_4TAP(dst32_r, dst54_r, filt_h0, filt_h1);
4404     dst2_l = HEVC_FILT_4TAP(dst32_l, dst54_l, filt_h0, filt_h1);
4405     dst2_r >>= 6;
4406     dst2_l >>= 6;
4407     tmp2 = __msa_pckev_h((v8i16) dst2_l, (v8i16) dst2_r);
4408
4409     /* row 6 */
4410     VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
4411     dst6 = const_vec;
4412     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst6, dst6);
4413
4414     ILVRL_H2_SH(dst6, dst5, dst65_r, dst65_l);
4415     dst3_r = HEVC_FILT_4TAP(dst43_r, dst65_r, filt_h0, filt_h1);
4416     dst3_l = HEVC_FILT_4TAP(dst43_l, dst65_l, filt_h0, filt_h1);
4417     dst3_r >>= 6;
4418     dst3_l >>= 6;
4419     tmp3 = __msa_pckev_h((v8i16) dst3_l, (v8i16) dst3_r);
4420
4421     LD_SB2(src0_ptr, src_stride, src7, src8);
4422     XORI_B2_128_SB(src7, src8);
4423     /* row 7 */
4424     VSHF_B2_SB(src7, src7, src7, src7, mask0, mask1, vec0, vec1);
4425     dst7 = const_vec;
4426     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst7, dst7);
4427
4428     ILVRL_H2_SH(dst7, dst6, dst76_r, dst76_l);
4429     dst4_r = HEVC_FILT_4TAP(dst54_r, dst76_r, filt_h0, filt_h1);
4430     dst4_l = HEVC_FILT_4TAP(dst54_l, dst76_l, filt_h0, filt_h1);
4431
4432     dst4_r >>= 6;
4433     dst4_l >>= 6;
4434     tmp4 = __msa_pckev_h((v8i16) dst4_l, (v8i16) dst4_r);
4435     /* row 8 */
4436     VSHF_B2_SB(src8, src8, src8, src8, mask0, mask1, vec0, vec1);
4437     dst8 = const_vec;
4438     DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst8, dst8);
4439
4440     ILVRL_H2_SH(dst8, dst7, dst87_r, dst87_l);
4441     dst5_r = HEVC_FILT_4TAP(dst65_r, dst87_r, filt_h0, filt_h1);
4442     dst5_l = HEVC_FILT_4TAP(dst65_l, dst87_l, filt_h0, filt_h1);
4443     dst5_r >>= 6;
4444     dst5_l >>= 6;
4445     tmp5 = __msa_pckev_h((v8i16) dst5_l, (v8i16) dst5_r);
4446
4447     HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
4448                       tmp0, tmp1, tmp2, tmp3, 7, tmp0, tmp1, tmp2, tmp3);
4449     HEVC_BI_RND_CLIP2(in4, in5, tmp4, tmp5, 7, tmp4, tmp5);
4450
4451     PCKEV_B2_SW(tmp1, tmp0, tmp3, tmp2, dst0_r, dst1_r);
4452     dst2_r = (v4i32) __msa_pckev_b((v16i8) tmp5, (v16i8) tmp4);
4453     ST8x4_UB(dst0_r, dst1_r, dst, dst_stride);
4454     dst += (4 * dst_stride);
4455     ST8x2_UB(dst2_r, dst, dst_stride);
4456 }
4457
4458 static void hevc_hv_bi_4t_8multx4mult_msa(uint8_t *src0_ptr,
4459                                           int32_t src_stride,
4460                                           int16_t *src1_ptr,
4461                                           int32_t src2_stride,
4462                                           uint8_t *dst,
4463                                           int32_t dst_stride,
4464                                           const int8_t *filter_x,
4465                                           const int8_t *filter_y,
4466                                           int32_t height,
4467                                           int32_t width)
4468 {
4469     uint32_t loop_cnt, cnt;
4470     uint8_t *src0_ptr_tmp;
4471     int16_t *src1_ptr_tmp;
4472     uint8_t *dst_tmp;
4473     v16i8 src0, src1, src2, src3, src4, src5, src6;
4474     v8i16 in0, in1, in2, in3;
4475     v8i16 filt0, filt1;
4476     v4i32 filt_h0, filt_h1;
4477     v16i8 mask0 = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8 };
4478     v16i8 mask1;
4479     v8i16 filter_vec, const_vec;
4480     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
4481     v8i16 dst0, dst1, dst2, dst3, dst4, dst5;
4482     v4i32 dst0_r, dst0_l, dst1_r, dst1_l, dst2_r, dst2_l, dst3_r, dst3_l;
4483     v8i16 tmp0, tmp1, tmp2, tmp3;
4484     v8i16 dst10_r, dst32_r, dst21_r, dst43_r;
4485     v8i16 dst10_l, dst32_l, dst21_l, dst43_l;
4486
4487     src0_ptr -= (src_stride + 1);
4488
4489     filter_vec = LD_SH(filter_x);
4490     SPLATI_H2_SH(filter_vec, 0, 1, filt0, filt1);
4491
4492     filter_vec = LD_SH(filter_y);
4493     vec0 = __msa_clti_s_b((v16i8) filter_vec, 0);
4494     filter_vec = (v8i16) __msa_ilvr_b(vec0, (v16i8) filter_vec);
4495
4496     SPLATI_W2_SW(filter_vec, 0, filt_h0, filt_h1);
4497
4498     mask1 = mask0 + 2;
4499
4500     const_vec = __msa_ldi_h(128);
4501     const_vec <<= 6;
4502
4503     for (cnt = width >> 3; cnt--;) {
4504         src0_ptr_tmp = src0_ptr;
4505         dst_tmp = dst;
4506         src1_ptr_tmp = src1_ptr;
4507
4508         LD_SB3(src0_ptr_tmp, src_stride, src0, src1, src2);
4509         src0_ptr_tmp += (3 * src_stride);
4510         XORI_B3_128_SB(src0, src1, src2);
4511
4512         VSHF_B2_SB(src0, src0, src0, src0, mask0, mask1, vec0, vec1);
4513         VSHF_B2_SB(src1, src1, src1, src1, mask0, mask1, vec2, vec3);
4514         VSHF_B2_SB(src2, src2, src2, src2, mask0, mask1, vec4, vec5);
4515         dst0 = const_vec;
4516         DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst0, dst0);
4517         dst1 = const_vec;
4518         DPADD_SB2_SH(vec2, vec3, filt0, filt1, dst1, dst1);
4519         dst2 = const_vec;
4520         DPADD_SB2_SH(vec4, vec5, filt0, filt1, dst2, dst2);
4521
4522         ILVRL_H2_SH(dst1, dst0, dst10_r, dst10_l);
4523         ILVRL_H2_SH(dst2, dst1, dst21_r, dst21_l);
4524
4525         for (loop_cnt = height >> 2; loop_cnt--;) {
4526             LD_SB4(src0_ptr_tmp, src_stride, src3, src4, src5, src6);
4527             src0_ptr_tmp += (4 * src_stride);
4528             LD_SH4(src1_ptr_tmp, src2_stride, in0, in1, in2, in3);
4529             src1_ptr_tmp += (4 * src2_stride);
4530             XORI_B4_128_SB(src3, src4, src5, src6);
4531
4532             VSHF_B2_SB(src3, src3, src3, src3, mask0, mask1, vec0, vec1);
4533             dst3 = const_vec;
4534             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst3, dst3);
4535
4536             ILVRL_H2_SH(dst3, dst2, dst32_r, dst32_l);
4537             dst0_r = HEVC_FILT_4TAP(dst10_r, dst32_r, filt_h0, filt_h1);
4538             dst0_l = HEVC_FILT_4TAP(dst10_l, dst32_l, filt_h0, filt_h1);
4539             dst0_r >>= 6;
4540             dst0_l >>= 6;
4541
4542             VSHF_B2_SB(src4, src4, src4, src4, mask0, mask1, vec0, vec1);
4543             dst4 = const_vec;
4544             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst4, dst4);
4545
4546             ILVRL_H2_SH(dst4, dst3, dst43_r, dst43_l);
4547             dst1_r = HEVC_FILT_4TAP(dst21_r, dst43_r, filt_h0, filt_h1);
4548             dst1_l = HEVC_FILT_4TAP(dst21_l, dst43_l, filt_h0, filt_h1);
4549             dst1_r >>= 6;
4550             dst1_l >>= 6;
4551
4552             VSHF_B2_SB(src5, src5, src5, src5, mask0, mask1, vec0, vec1);
4553             dst5 = const_vec;
4554             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst5, dst5);
4555
4556             ILVRL_H2_SH(dst5, dst4, dst10_r, dst10_l);
4557             dst2_r = HEVC_FILT_4TAP(dst32_r, dst10_r, filt_h0, filt_h1);
4558             dst2_l = HEVC_FILT_4TAP(dst32_l, dst10_l, filt_h0, filt_h1);
4559             dst2_r >>= 6;
4560             dst2_l >>= 6;
4561
4562             VSHF_B2_SB(src6, src6, src6, src6, mask0, mask1, vec0, vec1);
4563             dst2 = const_vec;
4564             DPADD_SB2_SH(vec0, vec1, filt0, filt1, dst2, dst2);
4565
4566             ILVRL_H2_SH(dst2, dst5, dst21_r, dst21_l);
4567             dst3_r = HEVC_FILT_4TAP(dst43_r, dst21_r, filt_h0, filt_h1);
4568             dst3_l = HEVC_FILT_4TAP(dst43_l, dst21_l, filt_h0, filt_h1);
4569             dst3_r >>= 6;
4570             dst3_l >>= 6;
4571
4572             PCKEV_H4_SH(dst0_l, dst0_r, dst1_l, dst1_r,
4573                         dst2_l, dst2_r, dst3_l, dst3_r, tmp0, tmp1, tmp2, tmp3);
4574             HEVC_BI_RND_CLIP4(in0, in1, in2, in3,
4575                               tmp0, tmp1, tmp2, tmp3, 7,
4576                               tmp0, tmp1, tmp2, tmp3);
4577
4578             PCKEV_B2_SW(tmp1, tmp0, tmp3, tmp2, dst0_r, dst1_r);
4579             ST8x4_UB(dst0_r, dst1_r, dst_tmp, dst_stride);
4580             dst_tmp += (4 * dst_stride);
4581         }
4582
4583         src0_ptr += 8;
4584         dst += 8;
4585         src1_ptr += 8;
4586     }
4587 }
4588
4589 static void hevc_hv_bi_4t_8w_msa(uint8_t *src0_ptr,
4590                                  int32_t src_stride,
4591                                  int16_t *src1_ptr,
4592                                  int32_t src2_stride,
4593                                  uint8_t *dst,
4594                                  int32_t dst_stride,
4595                                  const int8_t *filter_x,
4596                                  const int8_t *filter_y,
4597                                  int32_t height)
4598 {
4599     if (2 == height) {
4600         hevc_hv_bi_4t_8x2_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4601                               dst, dst_stride, filter_x, filter_y, height);
4602     } else if (6 == height) {
4603         hevc_hv_bi_4t_8x6_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4604                               dst, dst_stride, filter_x, filter_y, height);
4605     } else {
4606         hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride,
4607                                       src1_ptr, src2_stride,
4608                                       dst, dst_stride,
4609                                       filter_x, filter_y, height, 8);
4610     }
4611 }
4612
4613 static void hevc_hv_bi_4t_12w_msa(uint8_t *src0_ptr,
4614                                   int32_t src_stride,
4615                                   int16_t *src1_ptr,
4616                                   int32_t src2_stride,
4617                                   uint8_t *dst,
4618                                   int32_t dst_stride,
4619                                   const int8_t *filter_x,
4620                                   const int8_t *filter_y,
4621                                   int32_t height)
4622 {
4623     hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4624                                   dst, dst_stride, filter_x, filter_y,
4625                                   height, 8);
4626     hevc_hv_bi_4t_4w_msa(src0_ptr + 8, src_stride, src1_ptr + 8, src2_stride,
4627                          dst + 8, dst_stride, filter_x, filter_y, height);
4628 }
4629
4630 static void hevc_hv_bi_4t_16w_msa(uint8_t *src0_ptr,
4631                                   int32_t src_stride,
4632                                   int16_t *src1_ptr,
4633                                   int32_t src2_stride,
4634                                   uint8_t *dst,
4635                                   int32_t dst_stride,
4636                                   const int8_t *filter_x,
4637                                   const int8_t *filter_y,
4638                                   int32_t height)
4639 {
4640     hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4641                                   dst, dst_stride, filter_x, filter_y,
4642                                   height, 16);
4643 }
4644
4645 static void hevc_hv_bi_4t_24w_msa(uint8_t *src0_ptr,
4646                                   int32_t src_stride,
4647                                   int16_t *src1_ptr,
4648                                   int32_t src2_stride,
4649                                   uint8_t *dst,
4650                                   int32_t dst_stride,
4651                                   const int8_t *filter_x,
4652                                   const int8_t *filter_y,
4653                                   int32_t height)
4654 {
4655     hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4656                                   dst, dst_stride, filter_x, filter_y,
4657                                   height, 24);
4658 }
4659
4660 static void hevc_hv_bi_4t_32w_msa(uint8_t *src0_ptr,
4661                                   int32_t src_stride,
4662                                   int16_t *src1_ptr,
4663                                   int32_t src2_stride,
4664                                   uint8_t *dst,
4665                                   int32_t dst_stride,
4666                                   const int8_t *filter_x,
4667                                   const const int8_t *filter_y,
4668                                   int32_t height)
4669 {
4670     hevc_hv_bi_4t_8multx4mult_msa(src0_ptr, src_stride, src1_ptr, src2_stride,
4671                                   dst, dst_stride, filter_x, filter_y,
4672                                   height, 32);
4673 }
4674
4675 #define BI_MC_COPY(WIDTH)                                                 \
4676 void ff_hevc_put_hevc_bi_pel_pixels##WIDTH##_8_msa(uint8_t *dst,          \
4677                                                    ptrdiff_t dst_stride,  \
4678                                                    uint8_t *src,          \
4679                                                    ptrdiff_t src_stride,  \
4680                                                    int16_t *src_16bit,    \
4681                                                    int height,            \
4682                                                    intptr_t mx,           \
4683                                                    intptr_t my,           \
4684                                                    int width)             \
4685 {                                                                         \
4686     hevc_bi_copy_##WIDTH##w_msa(src, src_stride, src_16bit, MAX_PB_SIZE,  \
4687                                 dst, dst_stride, height);                 \
4688 }
4689
4690 BI_MC_COPY(4);
4691 BI_MC_COPY(6);
4692 BI_MC_COPY(8);
4693 BI_MC_COPY(12);
4694 BI_MC_COPY(16);
4695 BI_MC_COPY(24);
4696 BI_MC_COPY(32);
4697 BI_MC_COPY(48);
4698 BI_MC_COPY(64);
4699
4700 #undef BI_MC_COPY
4701
4702 #define BI_MC(PEL, DIR, WIDTH, TAP, DIR1, FILT_DIR)                          \
4703 void ff_hevc_put_hevc_bi_##PEL##_##DIR##WIDTH##_8_msa(uint8_t *dst,          \
4704                                                       ptrdiff_t dst_stride,  \
4705                                                       uint8_t *src,          \
4706                                                       ptrdiff_t src_stride,  \
4707                                                       int16_t *src_16bit,    \
4708                                                       int height,            \
4709                                                       intptr_t mx,           \
4710                                                       intptr_t my,           \
4711                                                       int width)             \
4712 {                                                                            \
4713     const int8_t *filter = ff_hevc_##PEL##_filters[FILT_DIR - 1];            \
4714                                                                              \
4715     hevc_##DIR1##_bi_##TAP##t_##WIDTH##w_msa(src, src_stride, src_16bit,     \
4716                                              MAX_PB_SIZE, dst, dst_stride,   \
4717                                              filter, height);                \
4718 }
4719
4720 BI_MC(qpel, h, 4, 8, hz, mx);
4721 BI_MC(qpel, h, 8, 8, hz, mx);
4722 BI_MC(qpel, h, 12, 8, hz, mx);
4723 BI_MC(qpel, h, 16, 8, hz, mx);
4724 BI_MC(qpel, h, 24, 8, hz, mx);
4725 BI_MC(qpel, h, 32, 8, hz, mx);
4726 BI_MC(qpel, h, 48, 8, hz, mx);
4727 BI_MC(qpel, h, 64, 8, hz, mx);
4728
4729 BI_MC(qpel, v, 4, 8, vt, my);
4730 BI_MC(qpel, v, 8, 8, vt, my);
4731 BI_MC(qpel, v, 12, 8, vt, my);
4732 BI_MC(qpel, v, 16, 8, vt, my);
4733 BI_MC(qpel, v, 24, 8, vt, my);
4734 BI_MC(qpel, v, 32, 8, vt, my);
4735 BI_MC(qpel, v, 48, 8, vt, my);
4736 BI_MC(qpel, v, 64, 8, vt, my);
4737
4738 BI_MC(epel, h, 4, 4, hz, mx);
4739 BI_MC(epel, h, 8, 4, hz, mx);
4740 BI_MC(epel, h, 6, 4, hz, mx);
4741 BI_MC(epel, h, 12, 4, hz, mx);
4742 BI_MC(epel, h, 16, 4, hz, mx);
4743 BI_MC(epel, h, 24, 4, hz, mx);
4744 BI_MC(epel, h, 32, 4, hz, mx);
4745
4746 BI_MC(epel, v, 4, 4, vt, my);
4747 BI_MC(epel, v, 8, 4, vt, my);
4748 BI_MC(epel, v, 6, 4, vt, my);
4749 BI_MC(epel, v, 12, 4, vt, my);
4750 BI_MC(epel, v, 16, 4, vt, my);
4751 BI_MC(epel, v, 24, 4, vt, my);
4752 BI_MC(epel, v, 32, 4, vt, my);
4753
4754 #undef BI_MC
4755
4756 #define BI_MC_HV(PEL, WIDTH, TAP)                                         \
4757 void ff_hevc_put_hevc_bi_##PEL##_hv##WIDTH##_8_msa(uint8_t *dst,          \
4758                                                    ptrdiff_t dst_stride,  \
4759                                                    uint8_t *src,          \
4760                                                    ptrdiff_t src_stride,  \
4761                                                    int16_t *src_16bit,    \
4762                                                    int height,            \
4763                                                    intptr_t mx,           \
4764                                                    intptr_t my,           \
4765                                                    int width)             \
4766 {                                                                         \
4767     const int8_t *filter_x = ff_hevc_##PEL##_filters[mx - 1];             \
4768     const int8_t *filter_y = ff_hevc_##PEL##_filters[my - 1];             \
4769                                                                           \
4770     hevc_hv_bi_##TAP##t_##WIDTH##w_msa(src, src_stride, src_16bit,        \
4771                                        MAX_PB_SIZE, dst, dst_stride,      \
4772                                        filter_x, filter_y, height);       \
4773 }
4774
4775 BI_MC_HV(qpel, 4, 8);
4776 BI_MC_HV(qpel, 8, 8);
4777 BI_MC_HV(qpel, 12, 8);
4778 BI_MC_HV(qpel, 16, 8);
4779 BI_MC_HV(qpel, 24, 8);
4780 BI_MC_HV(qpel, 32, 8);
4781 BI_MC_HV(qpel, 48, 8);
4782 BI_MC_HV(qpel, 64, 8);
4783
4784 BI_MC_HV(epel, 4, 4);
4785 BI_MC_HV(epel, 8, 4);
4786 BI_MC_HV(epel, 6, 4);
4787 BI_MC_HV(epel, 12, 4);
4788 BI_MC_HV(epel, 16, 4);
4789 BI_MC_HV(epel, 24, 4);
4790 BI_MC_HV(epel, 32, 4);
4791
4792 #undef BI_MC_HV