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

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