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