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