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

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