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