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

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