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

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