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