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

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