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