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

   1 /*
   2  * Copyright (c) 2015 - 2017 Shivraj Patil (Shivraj.Patil@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 "h264chroma_mips.h"
  23
  24 static const uint8_t chroma_mask_arr[16 * 5] = {
  25     0, 1, 1, 2, 2, 3, 3, 4, 16, 17, 17, 18, 18, 19, 19, 20,
  26     0, 2, 2, 4, 4, 6, 6, 8, 16, 18, 18, 20, 20, 22, 22, 24,
  27     0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8,
  28     0, 1, 1, 2, 16, 17, 17, 18, 4, 5, 5, 6, 6, 7, 7, 8,
  29     0, 1, 1, 2, 16, 17, 17, 18, 16, 17, 17, 18, 18, 19, 19, 20
  30 };
  31
  32 static void avc_chroma_hz_2x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
  33                                   uint32_t coeff0, uint32_t coeff1)
  34 {
  35     uint16_t out0, out1;
  36     v16i8 src0, src1;
  37     v8u16 res_r;
  38     v8i16 res;
  39     v16i8 mask;
  40     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
  41     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
  42     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
  43
  44     mask = LD_SB(&chroma_mask_arr[0]);
  45
  46     LD_SB2(src, stride, src0, src1);
  47
  48     src0 = __msa_vshf_b(mask, src1, src0);
  49     res_r = __msa_dotp_u_h((v16u8) src0, coeff_vec);
  50     res_r <<= 3;
  51     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
  52     res_r = __msa_sat_u_h(res_r, 7);
  53     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
  54
  55     out0 = __msa_copy_u_h(res, 0);
  56     out1 = __msa_copy_u_h(res, 2);
  57
  58     SH(out0, dst);
  59     dst += stride;
  60     SH(out1, dst);
  61 }
  62
  63 static void avc_chroma_hz_2x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
  64                                   uint32_t coeff0, uint32_t coeff1)
  65 {
  66     v16u8 src0, src1, src2, src3;
  67     v8u16 res_r;
  68     v8i16 res;
  69     v16i8 mask;
  70     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
  71     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
  72     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
  73
  74     mask = LD_SB(&chroma_mask_arr[64]);
  75
  76     LD_UB4(src, stride, src0, src1, src2, src3);
  77
  78     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
  79
  80     src0 = (v16u8) __msa_ilvr_d((v2i64) src2, (v2i64) src0);
  81
  82     res_r = __msa_dotp_u_h(src0, coeff_vec);
  83     res_r <<= 3;
  84     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
  85     res_r = __msa_sat_u_h(res_r, 7);
  86     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
  87
  88     ST2x4_UB(res, 0, dst, stride);
  89 }
  90
  91 static void avc_chroma_hz_2w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
  92                                  uint32_t coeff0, uint32_t coeff1,
  93                                  int32_t height)
  94 {
  95     if (2 == height) {
  96         avc_chroma_hz_2x2_msa(src, dst, stride, coeff0, coeff1);
  97     } else if (4 == height) {
  98         avc_chroma_hz_2x4_msa(src, dst, stride, coeff0, coeff1);
  99     }
 100 }
 101
 102 static void avc_chroma_hz_4x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 103                                   uint32_t coeff0, uint32_t coeff1)
 104 {
 105     v16i8 src0, src1;
 106     v8u16 res_r;
 107     v4i32 res;
 108     v16i8 mask;
 109     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 110     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 111     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 112
 113     mask = LD_SB(&chroma_mask_arr[0]);
 114
 115     LD_SB2(src, stride, src0, src1);
 116
 117     src0 = __msa_vshf_b(mask, src1, src0);
 118     res_r = __msa_dotp_u_h((v16u8) src0, coeff_vec);
 119     res_r <<= 3;
 120     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
 121     res_r = __msa_sat_u_h(res_r, 7);
 122     res = (v4i32) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 123
 124     ST4x2_UB(res, dst, stride);
 125 }
 126
 127 static void avc_chroma_hz_4x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 128                                   uint32_t coeff0, uint32_t coeff1)
 129 {
 130     v16u8 src0, src1, src2, src3, out;
 131     v8u16 res0_r, res1_r;
 132     v16i8 mask;
 133     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 134     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 135     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 136
 137     mask = LD_SB(&chroma_mask_arr[0]);
 138
 139     LD_UB4(src, stride, src0, src1, src2, src3);
 140     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
 141     DOTP_UB2_UH(src0, src2, coeff_vec, coeff_vec, res0_r, res1_r);
 142     res0_r <<= 3;
 143     res1_r <<= 3;
 144     SRARI_H2_UH(res0_r, res1_r, 6);
 145     SAT_UH2_UH(res0_r, res1_r, 7);
 146     out = (v16u8) __msa_pckev_b((v16i8) res1_r, (v16i8) res0_r);
 147     ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
 148 }
 149
 150 static void avc_chroma_hz_4x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 151                                   uint32_t coeff0, uint32_t coeff1)
 152 {
 153     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, out0, out1;
 154     v16i8 mask;
 155     v8u16 res0, res1, res2, res3;
 156     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 157     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 158     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 159
 160     mask = LD_SB(&chroma_mask_arr[0]);
 161
 162     LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
 163     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
 164     VSHF_B2_UB(src4, src5, src6, src7, mask, mask, src4, src6);
 165     DOTP_UB2_UH(src0, src2, coeff_vec, coeff_vec, res0, res1);
 166     DOTP_UB2_UH(src4, src6, coeff_vec, coeff_vec, res2, res3);
 167     SLLI_4V(res0, res1, res2, res3, 3);
 168     SRARI_H4_UH(res0, res1, res2, res3, 6);
 169     SAT_UH4_UH(res0, res1, res2, res3, 7);
 170     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
 171     ST4x8_UB(out0, out1, dst, stride);
 172 }
 173
 174 static void avc_chroma_hz_4w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 175                                  uint32_t coeff0, uint32_t coeff1,
 176                                  int32_t height)
 177 {
 178     if (2 == height) {
 179         avc_chroma_hz_4x2_msa(src, dst, stride, coeff0, coeff1);
 180     } else if (4 == height) {
 181         avc_chroma_hz_4x4_msa(src, dst, stride, coeff0, coeff1);
 182     } else if (8 == height) {
 183         avc_chroma_hz_4x8_msa(src, dst, stride, coeff0, coeff1);
 184     }
 185 }
 186
 187 static void avc_chroma_hz_8x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 188                                   uint32_t coeff0, uint32_t coeff1)
 189 {
 190     v16u8 src0, src1, src2, src3, out0, out1;
 191     v8u16 res0, res1, res2, res3;
 192     v16i8 mask;
 193     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 194     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 195     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 196
 197     mask = LD_SB(&chroma_mask_arr[32]);
 198     LD_UB4(src, stride, src0, src1, src2, src3);
 199     VSHF_B2_UB(src0, src0, src1, src1, mask, mask, src0, src1);
 200     VSHF_B2_UB(src2, src2, src3, src3, mask, mask, src2, src3);
 201     DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
 202                 coeff_vec, res0, res1, res2, res3);
 203     SLLI_4V(res0, res1, res2, res3, 3);
 204     SRARI_H4_UH(res0, res1, res2, res3, 6);
 205     SAT_UH4_UH(res0, res1, res2, res3, 7);
 206     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
 207     ST8x4_UB(out0, out1, dst, stride);
 208 }
 209
 210 static void avc_chroma_hz_8x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 211                                   uint32_t coeff0, uint32_t coeff1)
 212 {
 213     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
 214     v16u8 out0, out1, out2, out3;
 215     v8u16 res0, res1, res2, res3, res4, res5, res6, res7;
 216     v16i8 mask;
 217     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 218     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 219     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 220
 221     mask = LD_SB(&chroma_mask_arr[32]);
 222
 223     LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
 224     VSHF_B2_UB(src0, src0, src1, src1, mask, mask, src0, src1);
 225     VSHF_B2_UB(src2, src2, src3, src3, mask, mask, src2, src3);
 226     VSHF_B2_UB(src4, src4, src5, src5, mask, mask, src4, src5);
 227     VSHF_B2_UB(src6, src6, src7, src7, mask, mask, src6, src7);
 228     DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
 229                 coeff_vec, res0, res1, res2, res3);
 230     DOTP_UB4_UH(src4, src5, src6, src7, coeff_vec, coeff_vec, coeff_vec,
 231                 coeff_vec, res4, res5, res6, res7);
 232     SLLI_4V(res0, res1, res2, res3, 3);
 233     SLLI_4V(res4, res5, res6, res7, 3);
 234     SRARI_H4_UH(res0, res1, res2, res3, 6);
 235     SRARI_H4_UH(res4, res5, res6, res7, 6);
 236     SAT_UH4_UH(res0, res1, res2, res3, 7);
 237     SAT_UH4_UH(res4, res5, res6, res7, 7);
 238     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
 239     PCKEV_B2_UB(res5, res4, res7, res6, out2, out3);
 240     ST8x8_UB(out0, out1, out2, out3, dst, stride);
 241 }
 242
 243 static void avc_chroma_hz_nonmult_msa(uint8_t *src, uint8_t *dst,
 244                                       int32_t stride, uint32_t coeff0,
 245                                       uint32_t coeff1, int32_t height)
 246 {
 247     uint32_t row;
 248     v16u8 src0, src1, src2, src3, out0, out1;
 249     v8u16 res0, res1, res2, res3;
 250     v16i8 mask;
 251     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 252     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 253     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 254
 255     mask = LD_SB(&chroma_mask_arr[32]);
 256
 257     for (row = height >> 2; row--;) {
 258         LD_UB4(src, stride, src0, src1, src2, src3);
 259         src += (4 * stride);
 260
 261         VSHF_B2_UB(src0, src0, src1, src1, mask, mask, src0, src1);
 262         VSHF_B2_UB(src2, src2, src3, src3, mask, mask, src2, src3);
 263         DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
 264                     coeff_vec, res0, res1, res2, res3);
 265         SLLI_4V(res0, res1, res2, res3, 3);
 266         SRARI_H4_UH(res0, res1, res2, res3, 6);
 267         SAT_UH4_UH(res0, res1, res2, res3, 7);
 268         PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
 269         ST8x4_UB(out0, out1, dst, stride);
 270         dst += (4 * stride);
 271     }
 272
 273     if (0 != (height % 4)) {
 274         for (row = (height % 4); row--;) {
 275             src0 = LD_UB(src);
 276             src += stride;
 277
 278             src0 = (v16u8) __msa_vshf_b(mask, (v16i8) src0, (v16i8) src0);
 279
 280             res0 = __msa_dotp_u_h(src0, coeff_vec);
 281             res0 <<= 3;
 282             res0 = (v8u16) __msa_srari_h((v8i16) res0, 6);
 283             res0 = __msa_sat_u_h(res0, 7);
 284             res0 = (v8u16) __msa_pckev_b((v16i8) res0, (v16i8) res0);
 285
 286             ST8x1_UB(res0, dst);
 287             dst += stride;
 288         }
 289     }
 290 }
 291
 292 static void avc_chroma_hz_8w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 293                                  uint32_t coeff0, uint32_t coeff1,
 294                                  int32_t height)
 295 {
 296     if (4 == height) {
 297         avc_chroma_hz_8x4_msa(src, dst, stride, coeff0, coeff1);
 298     } else if (8 == height) {
 299         avc_chroma_hz_8x8_msa(src, dst, stride, coeff0, coeff1);
 300     } else {
 301         avc_chroma_hz_nonmult_msa(src, dst, stride, coeff0, coeff1, height);
 302     }
 303 }
 304
 305 static void avc_chroma_vt_2x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 306                                   uint32_t coeff0, uint32_t coeff1)
 307 {
 308     uint16_t out0, out1;
 309     v16i8 src0, src1, src2;
 310     v16u8 tmp0, tmp1;
 311     v8i16 res;
 312     v8u16 res_r;
 313     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 314     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 315     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 316
 317     LD_SB3(src, stride, src0, src1, src2);
 318
 319     ILVR_B2_UB(src1, src0, src2, src1, tmp0, tmp1);
 320
 321     tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp1, (v2i64) tmp0);
 322
 323     res_r = __msa_dotp_u_h(tmp0, coeff_vec);
 324     res_r <<= 3;
 325     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
 326     res_r = __msa_sat_u_h(res_r, 7);
 327     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 328
 329     out0 = __msa_copy_u_h(res, 0);
 330     out1 = __msa_copy_u_h(res, 2);
 331
 332     SH(out0, dst);
 333     dst += stride;
 334     SH(out1, dst);
 335 }
 336
 337 static void avc_chroma_vt_2x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 338                                   uint32_t coeff0, uint32_t coeff1)
 339 {
 340     v16u8 src0, src1, src2, src3, src4;
 341     v16u8 tmp0, tmp1, tmp2, tmp3;
 342     v8i16 res;
 343     v8u16 res_r;
 344     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 345     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 346     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 347
 348     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 349     ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
 350                tmp0, tmp1, tmp2, tmp3);
 351     ILVR_W2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
 352
 353     tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp2, (v2i64) tmp0);
 354
 355     res_r = __msa_dotp_u_h(tmp0, coeff_vec);
 356     res_r <<= 3;
 357     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
 358     res_r = __msa_sat_u_h(res_r, 7);
 359
 360     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 361
 362     ST2x4_UB(res, 0, dst, stride);
 363 }
 364
 365 static void avc_chroma_vt_2w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 366                                  uint32_t coeff0, uint32_t coeff1,
 367                                  int32_t height)
 368 {
 369     if (2 == height) {
 370         avc_chroma_vt_2x2_msa(src, dst, stride, coeff0, coeff1);
 371     } else if (4 == height) {
 372         avc_chroma_vt_2x4_msa(src, dst, stride, coeff0, coeff1);
 373     }
 374 }
 375
 376 static void avc_chroma_vt_4x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 377                                   uint32_t coeff0, uint32_t coeff1)
 378 {
 379     v16u8 src0, src1, src2;
 380     v16u8 tmp0, tmp1;
 381     v4i32 res;
 382     v8u16 res_r;
 383     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 384     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 385     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 386
 387     LD_UB3(src, stride, src0, src1, src2);
 388     ILVR_B2_UB(src1, src0, src2, src1, tmp0, tmp1);
 389
 390     tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp1, (v2i64) tmp0);
 391     res_r = __msa_dotp_u_h(tmp0, coeff_vec);
 392     res_r <<= 3;
 393     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
 394     res_r = __msa_sat_u_h(res_r, 7);
 395     res = (v4i32) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 396
 397     ST4x2_UB(res, dst, stride);
 398 }
 399
 400 static void avc_chroma_vt_4x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 401                                   uint32_t coeff0, uint32_t coeff1)
 402 {
 403     v16u8 src0, src1, src2, src3, src4;
 404     v16u8 tmp0, tmp1, tmp2, tmp3;
 405     v16u8 out;
 406     v8u16 res0_r, res1_r;
 407     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 408     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 409     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 410
 411     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 412     ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3, tmp0, tmp1, tmp2,
 413                tmp3);
 414     ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
 415     DOTP_UB2_UH(tmp0, tmp2, coeff_vec, coeff_vec, res0_r, res1_r);
 416     res0_r <<= 3;
 417     res1_r <<= 3;
 418     SRARI_H2_UH(res0_r, res1_r, 6);
 419     SAT_UH2_UH(res0_r, res1_r, 7);
 420     out = (v16u8) __msa_pckev_b((v16i8) res1_r, (v16i8) res0_r);
 421     ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
 422 }
 423
 424 static void avc_chroma_vt_4x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 425                                   uint32_t coeff0, uint32_t coeff1)
 426 {
 427     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
 428     v16u8 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, out0, out1;
 429     v8u16 res0, res1, res2, res3;
 430     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 431     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 432     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 433
 434     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 435     src += (5 * stride);
 436     LD_UB4(src, stride, src5, src6, src7, src8);
 437     ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3, tmp0, tmp1, tmp2,
 438                tmp3);
 439     ILVR_B4_UB(src5, src4, src6, src5, src7, src6, src8, src7, tmp4, tmp5, tmp6,
 440                tmp7);
 441     ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
 442     ILVR_D2_UB(tmp5, tmp4, tmp7, tmp6, tmp4, tmp6);
 443     DOTP_UB2_UH(tmp0, tmp2, coeff_vec, coeff_vec, res0, res1);
 444     DOTP_UB2_UH(tmp4, tmp6, coeff_vec, coeff_vec, res2, res3);
 445     SLLI_4V(res0, res1, res2, res3, 3);
 446     SRARI_H4_UH(res0, res1, res2, res3, 6);
 447     SAT_UH4_UH(res0, res1, res2, res3, 7);
 448     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
 449     ST4x8_UB(out0, out1, dst, stride);
 450 }
 451
 452 static void avc_chroma_vt_4w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 453                                  uint32_t coeff0, uint32_t coeff1,
 454                                  int32_t height)
 455 {
 456     if (2 == height) {
 457         avc_chroma_vt_4x2_msa(src, dst, stride, coeff0, coeff1);
 458     } else if (4 == height) {
 459         avc_chroma_vt_4x4_msa(src, dst, stride, coeff0, coeff1);
 460     } else if (8 == height) {
 461         avc_chroma_vt_4x8_msa(src, dst, stride, coeff0, coeff1);
 462     }
 463 }
 464
 465 static void avc_chroma_vt_8x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 466                                   uint32_t coeff0, uint32_t coeff1)
 467 {
 468     v16u8 src0, src1, src2, src3, src4, out0, out1;
 469     v8u16 res0, res1, res2, res3;
 470     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 471     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 472     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 473
 474     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 475     ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3, src0, src1, src2,
 476                src3);
 477     DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
 478                 coeff_vec, res0, res1, res2, res3);
 479     SLLI_4V(res0, res1, res2, res3, 3);
 480     SRARI_H4_UH(res0, res1, res2, res3, 6);
 481     SAT_UH4_UH(res0, res1, res2, res3, 7);
 482     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
 483     ST8x4_UB(out0, out1, dst, stride);
 484 }
 485
 486 static void avc_chroma_vt_8x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 487                                   uint32_t coeff0, uint32_t coeff1)
 488 {
 489     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
 490     v16u8 out0, out1, out2, out3;
 491     v8u16 res0, res1, res2, res3, res4, res5, res6, res7;
 492     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 493     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 494     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 495
 496     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 497     src += (5 * stride);
 498     LD_UB4(src, stride, src5, src6, src7, src8);
 499     ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3, src0, src1, src2,
 500                src3);
 501     ILVR_B4_UB(src5, src4, src6, src5, src7, src6, src8, src7, src4, src5, src6,
 502                src7);
 503     DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
 504                 coeff_vec, res0, res1, res2, res3);
 505     DOTP_UB4_UH(src4, src5, src6, src7, coeff_vec, coeff_vec, coeff_vec,
 506                 coeff_vec, res4, res5, res6, res7);
 507     SLLI_4V(res0, res1, res2, res3, 3);
 508     SLLI_4V(res4, res5, res6, res7, 3);
 509     SRARI_H4_UH(res0, res1, res2, res3, 6);
 510     SRARI_H4_UH(res4, res5, res6, res7, 6);
 511     SAT_UH4_UH(res0, res1, res2, res3, 7);
 512     SAT_UH4_UH(res0, res1, res2, res3, 7);
 513     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
 514     PCKEV_B2_UB(res5, res4, res7, res6, out2, out3);
 515     ST8x8_UB(out0, out1, out2, out3, dst, stride);
 516 }
 517
 518 static void avc_chroma_vt_8w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 519                                  uint32_t coeff0, uint32_t coeff1,
 520                                  int32_t height)
 521 {
 522     if (4 == height) {
 523         avc_chroma_vt_8x4_msa(src, dst, stride, coeff0, coeff1);
 524     } else if (8 == height) {
 525         avc_chroma_vt_8x8_msa(src, dst, stride, coeff0, coeff1);
 526     }
 527 }
 528
 529 static void avc_chroma_hv_2x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 530                                   uint32_t coef_hor0, uint32_t coef_hor1,
 531                                   uint32_t coef_ver0, uint32_t coef_ver1)
 532 {
 533     uint16_t out0, out1;
 534     v16u8 src0, src1, src2;
 535     v8u16 res_hz0, res_hz1, res_vt0, res_vt1;
 536     v8i16 res_vert;
 537     v16i8 mask;
 538     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
 539     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
 540     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
 541     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
 542     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 543
 544     mask = LD_SB(&chroma_mask_arr[48]);
 545
 546     LD_UB3(src, stride, src0, src1, src2);
 547     VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
 548     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
 549     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
 550
 551     res_vt0 += res_vt1;
 552     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
 553     res_vt0 = __msa_sat_u_h(res_vt0, 7);
 554     res_vert = (v8i16) __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
 555
 556     out0 = __msa_copy_u_h(res_vert, 0);
 557     out1 = __msa_copy_u_h(res_vert, 1);
 558
 559     SH(out0, dst);
 560     dst += stride;
 561     SH(out1, dst);
 562 }
 563
 564 static void avc_chroma_hv_2x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 565                                   uint32_t coef_hor0, uint32_t coef_hor1,
 566                                   uint32_t coef_ver0, uint32_t coef_ver1)
 567 {
 568     v16u8 src0, src1, src2, src3, src4;
 569     v16u8 tmp0, tmp1, tmp2, tmp3;
 570     v8u16 res_hz0, res_hz1, res_vt0, res_vt1;
 571     v8i16 res;
 572     v16i8 mask;
 573     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
 574     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
 575     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
 576     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
 577     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 578
 579     mask = LD_SB(&chroma_mask_arr[48]);
 580
 581     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 582
 583     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, tmp0, tmp1);
 584     VSHF_B2_UB(src1, src2, src3, src4, mask, mask, tmp2, tmp3);
 585     ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
 586     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
 587     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
 588
 589     res_vt0 += res_vt1;
 590     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
 591     res_vt0 = __msa_sat_u_h(res_vt0, 7);
 592
 593     res = (v8i16) __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
 594
 595     ST2x4_UB(res, 0, dst, stride);
 596 }
 597
 598 static void avc_chroma_hv_2w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 599                                  uint32_t coef_hor0, uint32_t coef_hor1,
 600                                  uint32_t coef_ver0, uint32_t coef_ver1,
 601                                  int32_t height)
 602 {
 603     if (2 == height) {
 604         avc_chroma_hv_2x2_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
 605                               coef_ver1);
 606     } else if (4 == height) {
 607         avc_chroma_hv_2x4_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
 608                               coef_ver1);
 609     }
 610 }
 611
 612 static void avc_chroma_hv_4x2_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 613                                   uint32_t coef_hor0, uint32_t coef_hor1,
 614                                   uint32_t coef_ver0, uint32_t coef_ver1)
 615 {
 616     v16u8 src0, src1, src2;
 617     v8u16 res_hz0, res_hz1, res_vt0, res_vt1;
 618     v16i8 mask;
 619     v4i32 res;
 620     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
 621     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
 622     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
 623     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
 624     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 625
 626     mask = LD_SB(&chroma_mask_arr[0]);
 627     LD_UB3(src, stride, src0, src1, src2);
 628     VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
 629     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
 630     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
 631
 632     res_vt0 += res_vt1;
 633     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
 634     res_vt0 = __msa_sat_u_h(res_vt0, 7);
 635     res = (v4i32) __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
 636
 637     ST4x2_UB(res, dst, stride);
 638 }
 639
 640 static void avc_chroma_hv_4x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 641                                   uint32_t coef_hor0, uint32_t coef_hor1,
 642                                   uint32_t coef_ver0, uint32_t coef_ver1)
 643 {
 644     v16u8 src0, src1, src2, src3, src4;
 645     v8u16 res_hz0, res_hz1, res_hz2, res_hz3;
 646     v8u16 res_vt0, res_vt1, res_vt2, res_vt3;
 647     v16i8 mask;
 648     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
 649     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
 650     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
 651     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
 652     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 653     v4i32 res0, res1;
 654
 655     mask = LD_SB(&chroma_mask_arr[0]);
 656
 657     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 658     VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
 659     VSHF_B2_UB(src2, src3, src3, src4, mask, mask, src2, src3);
 660     DOTP_UB4_UH(src0, src1, src2, src3, coeff_hz_vec, coeff_hz_vec,
 661                 coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1, res_hz2,
 662                 res_hz3);
 663     MUL4(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec1,
 664          res_hz3, coeff_vt_vec0, res_vt0, res_vt1, res_vt2, res_vt3);
 665     ADD2(res_vt0, res_vt1, res_vt2, res_vt3, res_vt0, res_vt1);
 666     SRARI_H2_UH(res_vt0, res_vt1, 6);
 667     SAT_UH2_UH(res_vt0, res_vt1, 7);
 668     PCKEV_B2_SW(res_vt0, res_vt0, res_vt1, res_vt1, res0, res1);
 669     ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, stride);
 670 }
 671
 672 static void avc_chroma_hv_4x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 673                                   uint32_t coef_hor0, uint32_t coef_hor1,
 674                                   uint32_t coef_ver0, uint32_t coef_ver1)
 675 {
 676     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8, res0, res1;
 677     v8u16 res_hz0, res_hz1, res_hz2, res_hz3, res_hz4, res_hz5, res_hz6, res_hz7;
 678     v8u16 res_vt0, res_vt1, res_vt2, res_vt3, res_vt4, res_vt5, res_vt6, res_vt7;
 679     v16i8 mask;
 680     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
 681     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
 682     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
 683     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
 684     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 685
 686     mask = LD_SB(&chroma_mask_arr[0]);
 687
 688     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 689     src += (5 * stride);
 690     LD_UB4(src, stride, src5, src6, src7, src8);
 691
 692     VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
 693     VSHF_B2_UB(src2, src3, src3, src4, mask, mask, src2, src3);
 694     VSHF_B2_UB(src4, src5, src5, src6, mask, mask, src4, src5);
 695     VSHF_B2_UB(src6, src7, src7, src8, mask, mask, src6, src7);
 696     DOTP_UB4_UH(src0, src1, src2, src3, coeff_hz_vec, coeff_hz_vec,
 697                 coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1, res_hz2, res_hz3);
 698     DOTP_UB4_UH(src4, src5, src6, src7, coeff_hz_vec, coeff_hz_vec,
 699                 coeff_hz_vec, coeff_hz_vec, res_hz4, res_hz5, res_hz6, res_hz7);
 700     MUL4(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec1,
 701          res_hz3, coeff_vt_vec0, res_vt0, res_vt1, res_vt2, res_vt3);
 702     MUL4(res_hz4, coeff_vt_vec1, res_hz5, coeff_vt_vec0, res_hz6, coeff_vt_vec1,
 703          res_hz7, coeff_vt_vec0, res_vt4, res_vt5, res_vt6, res_vt7);
 704     ADD2(res_vt0, res_vt1, res_vt2, res_vt3, res_vt0, res_vt1);
 705     ADD2(res_vt4, res_vt5, res_vt6, res_vt7, res_vt2, res_vt3);
 706     SRARI_H4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 6);
 707     SAT_UH4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 7);
 708     PCKEV_B2_UB(res_vt1, res_vt0, res_vt3, res_vt2, res0, res1);
 709     ST4x8_UB(res0, res1, dst, stride);
 710 }
 711
 712 static void avc_chroma_hv_4w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 713                                  uint32_t coef_hor0, uint32_t coef_hor1,
 714                                  uint32_t coef_ver0, uint32_t coef_ver1,
 715                                  int32_t height)
 716 {
 717     if (2 == height) {
 718         avc_chroma_hv_4x2_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
 719                               coef_ver1);
 720     } else if (4 == height) {
 721         avc_chroma_hv_4x4_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
 722                               coef_ver1);
 723     } else if (8 == height) {
 724         avc_chroma_hv_4x8_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
 725                               coef_ver1);
 726     }
 727 }
 728
 729 static void avc_chroma_hv_8x4_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 730                                   uint32_t coef_hor0, uint32_t coef_hor1,
 731                                   uint32_t coef_ver0, uint32_t coef_ver1)
 732 {
 733     v16u8 src0, src1, src2, src3, src4, out0, out1;
 734     v8u16 res_hz0, res_hz1, res_hz2, res_hz3, res_hz4;
 735     v8u16 res_vt0, res_vt1, res_vt2, res_vt3;
 736     v16i8 mask;
 737     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
 738     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
 739     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
 740     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
 741     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 742
 743     mask = LD_SB(&chroma_mask_arr[32]);
 744
 745     src0 = LD_UB(src);
 746     src += stride;
 747
 748     src0 = (v16u8) __msa_vshf_b(mask, (v16i8) src0, (v16i8) src0);
 749     res_hz0 = __msa_dotp_u_h(src0, coeff_hz_vec);
 750
 751     LD_UB4(src, stride, src1, src2, src3, src4);
 752     src += (4 * stride);
 753
 754     VSHF_B2_UB(src1, src1, src2, src2, mask, mask, src1, src2);
 755     VSHF_B2_UB(src3, src3, src4, src4, mask, mask, src3, src4);
 756     DOTP_UB4_UH(src1, src2, src3, src4, coeff_hz_vec, coeff_hz_vec,
 757                 coeff_hz_vec, coeff_hz_vec, res_hz1, res_hz2, res_hz3, res_hz4);
 758     MUL4(res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec0, res_hz3, coeff_vt_vec0,
 759          res_hz4, coeff_vt_vec0, res_vt0, res_vt1, res_vt2, res_vt3);
 760
 761     res_vt0 += (res_hz0 * coeff_vt_vec1);
 762     res_vt1 += (res_hz1 * coeff_vt_vec1);
 763     res_vt2 += (res_hz2 * coeff_vt_vec1);
 764     res_vt3 += (res_hz3 * coeff_vt_vec1);
 765
 766     SRARI_H4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 6);
 767     SAT_UH4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 7);
 768     PCKEV_B2_UB(res_vt1, res_vt0, res_vt3, res_vt2, out0, out1);
 769     ST8x4_UB(out0, out1, dst, stride);
 770 }
 771
 772 static void avc_chroma_hv_8x8_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 773                                   uint32_t coef_hor0, uint32_t coef_hor1,
 774                                   uint32_t coef_ver0, uint32_t coef_ver1)
 775 {
 776     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
 777     v16u8 out0, out1, out2, out3;
 778     v8u16 res_hz0, res_hz1, res_hz2, res_hz3, res_hz4;
 779     v8u16 res_hz5, res_hz6, res_hz7, res_hz8;
 780     v8u16 res_vt0, res_vt1, res_vt2, res_vt3;
 781     v8u16 res_vt4, res_vt5, res_vt6, res_vt7;
 782     v16i8 mask;
 783     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
 784     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
 785     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
 786     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
 787     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
 788
 789     mask = LD_SB(&chroma_mask_arr[32]);
 790
 791     LD_UB5(src, stride, src0, src1, src2, src3, src4);
 792     src += (5 * stride);
 793     LD_UB4(src, stride, src5, src6, src7, src8);
 794     src0 = (v16u8) __msa_vshf_b(mask, (v16i8) src0, (v16i8) src0);
 795     VSHF_B2_UB(src1, src1, src2, src2, mask, mask, src1, src2);
 796     VSHF_B2_UB(src3, src3, src4, src4, mask, mask, src3, src4);
 797     VSHF_B2_UB(src5, src5, src6, src6, mask, mask, src5, src6);
 798     VSHF_B2_UB(src7, src7, src8, src8, mask, mask, src7, src8);
 799     res_hz0 = __msa_dotp_u_h(src0, coeff_hz_vec);
 800     DOTP_UB4_UH(src1, src2, src3, src4, coeff_hz_vec, coeff_hz_vec,
 801                 coeff_hz_vec, coeff_hz_vec, res_hz1, res_hz2, res_hz3,
 802                 res_hz4);
 803     DOTP_UB4_UH(src5, src6, src7, src8, coeff_hz_vec, coeff_hz_vec,
 804                 coeff_hz_vec, coeff_hz_vec, res_hz5, res_hz6, res_hz7, res_hz8);
 805     MUL4(res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec0, res_hz3,
 806          coeff_vt_vec0, res_hz4, coeff_vt_vec0, res_vt0, res_vt1, res_vt2,
 807          res_vt3);
 808     MUL4(res_hz5, coeff_vt_vec0, res_hz6, coeff_vt_vec0, res_hz7,
 809          coeff_vt_vec0, res_hz8, coeff_vt_vec0, res_vt4, res_vt5, res_vt6,
 810          res_vt7);
 811     res_vt0 += (res_hz0 * coeff_vt_vec1);
 812     res_vt1 += (res_hz1 * coeff_vt_vec1);
 813     res_vt2 += (res_hz2 * coeff_vt_vec1);
 814     res_vt3 += (res_hz3 * coeff_vt_vec1);
 815     res_vt4 += (res_hz4 * coeff_vt_vec1);
 816     res_vt5 += (res_hz5 * coeff_vt_vec1);
 817     res_vt6 += (res_hz6 * coeff_vt_vec1);
 818     res_vt7 += (res_hz7 * coeff_vt_vec1);
 819     SRARI_H4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 6);
 820     SRARI_H4_UH(res_vt4, res_vt5, res_vt6, res_vt7, 6);
 821     SAT_UH4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 7);
 822     SAT_UH4_UH(res_vt4, res_vt5, res_vt6, res_vt7, 7);
 823     PCKEV_B2_UB(res_vt1, res_vt0, res_vt3, res_vt2, out0, out1);
 824     PCKEV_B2_UB(res_vt5, res_vt4, res_vt7, res_vt6, out2, out3);
 825     ST8x8_UB(out0, out1, out2, out3, dst, stride);
 826 }
 827
 828 static void avc_chroma_hv_8w_msa(uint8_t *src, uint8_t *dst, int32_t stride,
 829                                  uint32_t coef_hor0, uint32_t coef_hor1,
 830                                  uint32_t coef_ver0, uint32_t coef_ver1,
 831                                  int32_t height)
 832 {
 833     if (4 == height) {
 834         avc_chroma_hv_8x4_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
 835                               coef_ver1);
 836     } else if (8 == height) {
 837         avc_chroma_hv_8x8_msa(src, dst, stride, coef_hor0, coef_hor1, coef_ver0,
 838                               coef_ver1);
 839     }
 840 }
 841
 842 static void avc_chroma_hz_and_aver_dst_2x2_msa(uint8_t *src, uint8_t *dst,
 843                                                int32_t stride, uint32_t coeff0,
 844                                                uint32_t coeff1)
 845 {
 846     uint16_t out0, out1;
 847     v16i8 src0, src1;
 848     v16u8 dst_data = { 0 };
 849     v8u16 res_r;
 850     v16u8 res;
 851     v16i8 mask;
 852     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 853     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 854     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 855
 856     mask = LD_SB(&chroma_mask_arr[0]);
 857
 858     LD_SB2(src, stride, src0, src1);
 859
 860     out0 = LH(dst);
 861     out1 = LH(dst + stride);
 862
 863     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 0, out0);
 864     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 2, out1);
 865
 866     src0 = __msa_vshf_b(mask, src1, src0);
 867
 868     res_r = __msa_dotp_u_h((v16u8) src0, coeff_vec);
 869     res_r <<= 3;
 870     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
 871     res_r = __msa_sat_u_h(res_r, 7);
 872
 873     res = (v16u8) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 874     dst_data = __msa_aver_u_b(res, dst_data);
 875
 876     out0 = __msa_copy_u_h((v8i16) dst_data, 0);
 877     out1 = __msa_copy_u_h((v8i16) dst_data, 2);
 878
 879     SH(out0, dst);
 880     dst += stride;
 881     SH(out1, dst);
 882 }
 883
 884 static void avc_chroma_hz_and_aver_dst_2x4_msa(uint8_t *src, uint8_t *dst,
 885                                                int32_t stride, uint32_t coeff0,
 886                                                uint32_t coeff1)
 887 {
 888     uint16_t tp0, tp1, tp2, tp3;
 889     v16u8 src0, src1, src2, src3;
 890     v16u8 dst0, dst_data = { 0 };
 891     v8u16 res_r;
 892     v16i8 mask;
 893     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 894     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 895     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 896
 897     mask = LD_SB(&chroma_mask_arr[64]);
 898
 899     LD_UB4(src, stride, src0, src1, src2, src3);
 900     tp0 = LH(dst);
 901     tp1 = LH(dst + stride);
 902     tp2 = LH(dst + 2 * stride);
 903     tp3 = LH(dst + 3 * stride);
 904     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 0, tp0);
 905     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 1, tp1);
 906     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 2, tp2);
 907     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 3, tp3);
 908
 909     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
 910
 911     src0 = (v16u8) __msa_ilvr_d((v2i64) src2, (v2i64) src0);
 912
 913     res_r = __msa_dotp_u_h(src0, coeff_vec);
 914     res_r <<= 3;
 915     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
 916     res_r = __msa_sat_u_h(res_r, 7);
 917
 918     dst0 = (v16u8) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 919     dst0 = __msa_aver_u_b(dst0, dst_data);
 920
 921     ST2x4_UB(dst0, 0, dst, stride);
 922 }
 923
 924 static void avc_chroma_hz_and_aver_dst_2w_msa(uint8_t *src, uint8_t *dst,
 925                                               int32_t stride, uint32_t coeff0,
 926                                               uint32_t coeff1, int32_t height)
 927 {
 928     if (2 == height) {
 929         avc_chroma_hz_and_aver_dst_2x2_msa(src, dst, stride, coeff0, coeff1);
 930     } else if (4 == height) {
 931         avc_chroma_hz_and_aver_dst_2x4_msa(src, dst, stride, coeff0, coeff1);
 932     }
 933 }
 934
 935 static void avc_chroma_hz_and_aver_dst_4x2_msa(uint8_t *src, uint8_t *dst,
 936                                                int32_t stride, uint32_t coeff0,
 937                                                uint32_t coeff1)
 938 {
 939     uint32_t load0, load1;
 940     v16i8 src0, src1;
 941     v16u8 dst_data = { 0 };
 942     v8u16 res_r;
 943     v16i8 res, mask;
 944     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 945     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 946     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 947
 948     mask = LD_SB(&chroma_mask_arr[0]);
 949
 950     LD_SB2(src, stride, src0, src1);
 951
 952     LW2(dst, stride, load0, load1);
 953
 954     INSERT_W2_UB(load0, load1, dst_data);
 955
 956     src0 = __msa_vshf_b(mask, src1, src0);
 957
 958     res_r = __msa_dotp_u_h((v16u8) src0, coeff_vec);
 959     res_r <<= 3;
 960     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
 961     res_r = __msa_sat_u_h(res_r, 7);
 962     res = __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
 963     dst_data = __msa_aver_u_b((v16u8) res, dst_data);
 964
 965     ST4x2_UB(dst_data, dst, stride);
 966 }
 967
 968 static void avc_chroma_hz_and_aver_dst_4x4_msa(uint8_t *src, uint8_t *dst,
 969                                                int32_t stride, uint32_t coeff0,
 970                                                uint32_t coeff1)
 971 {
 972     uint32_t tp0, tp1, tp2, tp3;
 973     v16u8 src0, src1, src2, src3;
 974     v16u8 out, dst_data = { 0 };
 975     v16i8 mask;
 976     v8u16 res0_r, res1_r;
 977     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
 978     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
 979     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
 980
 981     mask = LD_SB(&chroma_mask_arr[0]);
 982
 983     LD_UB4(src, stride, src0, src1, src2, src3);
 984     LW4(dst, stride, tp0, tp1, tp2, tp3);
 985     INSERT_W4_UB(tp0, tp1, tp2, tp3, dst_data);
 986     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
 987     DOTP_UB2_UH(src0, src2, coeff_vec, coeff_vec, res0_r, res1_r);
 988     res0_r <<= 3;
 989     res1_r <<= 3;
 990     SRARI_H2_UH(res0_r, res1_r, 6);
 991     SAT_UH2_UH(res0_r, res1_r, 7);
 992     out = (v16u8) __msa_pckev_b((v16i8) res1_r, (v16i8) res0_r);
 993     out = __msa_aver_u_b(out, dst_data);
 994     ST4x4_UB(out, out, 0, 1, 2, 3, dst, stride);
 995 }
 996
 997 static void avc_chroma_hz_and_aver_dst_4x8_msa(uint8_t *src, uint8_t *dst,
 998                                                int32_t stride, uint32_t coeff0,
 999                                                uint32_t coeff1)
1000 {
1001     uint32_t tp0, tp1, tp2, tp3;
1002     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, out0, out1;
1003     v16u8 dst0 = { 0 }, dst1 = { 0 };
1004     v16i8 mask;
1005     v8u16 res0, res1, res2, res3;
1006     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1007     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1008     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1009
1010     mask = LD_SB(&chroma_mask_arr[0]);
1011
1012     LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
1013     LW4(dst, stride, tp0, tp1, tp2, tp3);
1014     INSERT_W4_UB(tp0, tp1, tp2, tp3, dst0);
1015     LW4(dst + 4 * stride, stride, tp0, tp1, tp2, tp3);
1016     INSERT_W4_UB(tp0, tp1, tp2, tp3, dst1);
1017     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, src0, src2);
1018     VSHF_B2_UB(src4, src5, src6, src7, mask, mask, src4, src6);
1019     DOTP_UB2_UH(src0, src2, coeff_vec, coeff_vec, res0, res1);
1020     DOTP_UB2_UH(src4, src6, coeff_vec, coeff_vec, res2, res3);
1021     SLLI_4V(res0, res1, res2, res3, 3);
1022     SRARI_H4_UH(res0, res1, res2, res3, 6);
1023     SAT_UH4_UH(res0, res1, res2, res3, 7);
1024     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
1025     AVER_UB2_UB(out0, dst0, out1, dst1, out0, out1);
1026     ST4x8_UB(out0, out1, dst, stride);
1027 }
1028
1029 static void avc_chroma_hz_and_aver_dst_4w_msa(uint8_t *src, uint8_t *dst,
1030                                               int32_t stride, uint32_t coeff0,
1031                                               uint32_t coeff1, int32_t height)
1032 {
1033     if (2 == height) {
1034         avc_chroma_hz_and_aver_dst_4x2_msa(src, dst, stride, coeff0, coeff1);
1035     } else if (4 == height) {
1036         avc_chroma_hz_and_aver_dst_4x4_msa(src, dst, stride, coeff0, coeff1);
1037     } else if (8 == height) {
1038         avc_chroma_hz_and_aver_dst_4x8_msa(src, dst, stride, coeff0, coeff1);
1039     }
1040 }
1041
1042 static void avc_chroma_hz_and_aver_dst_8x4_msa(uint8_t *src, uint8_t *dst,
1043                                                int32_t stride, uint32_t coeff0,
1044                                                uint32_t coeff1)
1045 {
1046     uint64_t tp0, tp1, tp2, tp3;
1047     v16u8 src0, src1, src2, src3, out0, out1;
1048     v16u8 dst0 = { 0 }, dst1 = { 0 };
1049     v8u16 res0, res1, res2, res3;
1050     v16i8 mask;
1051     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1052     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1053     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1054
1055     mask = LD_SB(&chroma_mask_arr[32]);
1056     LD_UB4(src, stride, src0, src1, src2, src3);
1057     LD4(dst, stride, tp0, tp1, tp2, tp3);
1058     INSERT_D2_UB(tp0, tp1, dst0);
1059     INSERT_D2_UB(tp2, tp3, dst1);
1060     VSHF_B2_UB(src0, src0, src1, src1, mask, mask, src0, src1);
1061     VSHF_B2_UB(src2, src2, src3, src3, mask, mask, src2, src3);
1062     DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
1063                 coeff_vec, res0, res1, res2, res3);
1064     SLLI_4V(res0, res1, res2, res3, 3);
1065     SRARI_H4_UH(res0, res1, res2, res3, 6);
1066     SAT_UH4_UH(res0, res1, res2, res3, 7);
1067     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
1068     AVER_UB2_UB(out0, dst0, out1, dst1, dst0, dst1);
1069     ST8x4_UB(dst0, dst1, dst, stride);
1070 }
1071
1072 static void avc_chroma_hz_and_aver_dst_8x8_msa(uint8_t *src, uint8_t *dst,
1073                                                int32_t stride, uint32_t coeff0,
1074                                                uint32_t coeff1)
1075 {
1076     uint64_t tp0, tp1, tp2, tp3;
1077     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
1078     v16u8 out0, out1, out2, out3;
1079     v16u8 dst0 = { 0 }, dst1 = { 0 }, dst2 = { 0 }, dst3 = { 0 };
1080     v8u16 res0, res1, res2, res3, res4, res5, res6, res7;
1081     v16i8 mask;
1082     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1083     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1084     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1085
1086     mask = LD_SB(&chroma_mask_arr[32]);
1087
1088     LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
1089     LD4(dst, stride, tp0, tp1, tp2, tp3);
1090     INSERT_D2_UB(tp0, tp1, dst0);
1091     INSERT_D2_UB(tp2, tp3, dst1);
1092     LD4(dst + 4 * stride, stride, tp0, tp1, tp2, tp3);
1093     INSERT_D2_UB(tp0, tp1, dst2);
1094     INSERT_D2_UB(tp2, tp3, dst3);
1095     VSHF_B2_UB(src0, src0, src1, src1, mask, mask, src0, src1);
1096     VSHF_B2_UB(src2, src2, src3, src3, mask, mask, src2, src3);
1097     VSHF_B2_UB(src4, src4, src5, src5, mask, mask, src4, src5);
1098     VSHF_B2_UB(src6, src6, src7, src7, mask, mask, src6, src7);
1099     DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
1100                 coeff_vec, res0, res1, res2, res3);
1101     DOTP_UB4_UH(src4, src5, src6, src7, coeff_vec, coeff_vec, coeff_vec,
1102                 coeff_vec, res4, res5, res6, res7);
1103     SLLI_4V(res0, res1, res2, res3, 3);
1104     SLLI_4V(res4, res5, res6, res7, 3);
1105     SRARI_H4_UH(res0, res1, res2, res3, 6);
1106     SRARI_H4_UH(res4, res5, res6, res7, 6);
1107     SAT_UH4_UH(res0, res1, res2, res3, 7);
1108     SAT_UH4_UH(res4, res5, res6, res7, 7);
1109     PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
1110     PCKEV_B2_UB(res5, res4, res7, res6, out2, out3);
1111     AVER_UB2_UB(out0, dst0, out1, dst1, out0, out1);
1112     AVER_UB2_UB(out2, dst2, out3, dst3, out2, out3);
1113     ST8x8_UB(out0, out1, out2, out3, dst, stride);
1114 }
1115
1116 static void avc_chroma_hz_and_aver_dst_8w_msa(uint8_t *src, uint8_t *dst,
1117                                               int32_t stride, uint32_t coeff0,
1118                                               uint32_t coeff1, int32_t height)
1119 {
1120     if (4 == height) {
1121         avc_chroma_hz_and_aver_dst_8x4_msa(src, dst, stride, coeff0, coeff1);
1122     } else if (8 == height) {
1123         avc_chroma_hz_and_aver_dst_8x8_msa(src, dst, stride, coeff0, coeff1);
1124     }
1125 }
1126
1127 static void avc_chroma_vt_and_aver_dst_2x2_msa(uint8_t *src, int32_t src_stride,
1128                                                uint8_t *dst, int32_t dst_stride,
1129                                                uint32_t coeff0, uint32_t coeff1)
1130 {
1131     uint16_t out0, out1;
1132     uint32_t load0, load1;
1133     v16i8 src0, src1, src2, tmp0, tmp1, res;
1134     v16u8 dst_data = { 0 };
1135     v8u16 res_r;
1136     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1137     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1138     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1139
1140     LD_SB3(src, src_stride, src0, src1, src2);
1141     load0 = LW(dst);
1142     load1 = LW(dst + dst_stride);
1143
1144     INSERT_W2_UB(load0, load1, dst_data);
1145
1146     ILVR_B2_SB(src1, src0, src2, src1, tmp0, tmp1);
1147
1148     tmp0 = (v16i8) __msa_ilvr_d((v2i64) tmp1, (v2i64) tmp0);
1149     res_r = __msa_dotp_u_h((v16u8) tmp0, coeff_vec);
1150     res_r <<= 3;
1151     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
1152     res_r = __msa_sat_u_h(res_r, 7);
1153     res = __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
1154     dst_data = __msa_aver_u_b((v16u8) res, dst_data);
1155     out0 = __msa_copy_u_h((v8i16) dst_data, 0);
1156     out1 = __msa_copy_u_h((v8i16) dst_data, 2);
1157
1158     SH(out0, dst);
1159     dst += dst_stride;
1160     SH(out1, dst);
1161 }
1162
1163 static void avc_chroma_vt_and_aver_dst_2x4_msa(uint8_t *src, int32_t src_stride,
1164                                                uint8_t *dst, int32_t dst_stride,
1165                                                uint32_t coeff0, uint32_t coeff1)
1166 {
1167     uint32_t load0, load1;
1168     v16i8 src0, src1, src2, src3, src4;
1169     v16u8 tmp0, tmp1, tmp2, tmp3;
1170     v8u16 res_r;
1171     v8i16 res;
1172     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1173     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1174     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1175     v16u8 dst_data = { 0 };
1176
1177     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
1178
1179     load0 = LW(dst);
1180     load1 = LW(dst + dst_stride);
1181
1182     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 0, load0);
1183     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 1, load1);
1184
1185     load0 = LW(dst + 2 * dst_stride);
1186     load1 = LW(dst + 3 * dst_stride);
1187
1188     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 2, load0);
1189     dst_data = (v16u8) __msa_insert_h((v8i16) dst_data, 3, load1);
1190
1191     ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
1192                tmp0, tmp1, tmp2, tmp3);
1193     ILVR_W2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
1194
1195     tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp2, (v2i64) tmp0);
1196
1197     res_r = __msa_dotp_u_h(tmp0, coeff_vec);
1198     res_r <<= 3;
1199     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
1200     res_r = __msa_sat_u_h(res_r, 7);
1201
1202     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
1203     res = (v8i16) __msa_aver_u_b((v16u8) res, dst_data);
1204
1205     ST2x4_UB(res, 0, dst, dst_stride);
1206     dst += (4 * dst_stride);
1207 }
1208
1209 static void avc_chroma_vt_and_aver_dst_2x8_msa(uint8_t *src, int32_t src_stride,
1210                                                uint8_t *dst, int32_t dst_stride,
1211                                                uint32_t coeff0, uint32_t coeff1)
1212 {
1213     uint32_t load0, load1, load2, load3;
1214     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
1215     v16u8 tmp0, tmp1, tmp2, tmp3;
1216     v8i16 res;
1217     v8u16 res_r;
1218     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1219     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1220     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1221     v16u8 dst_data0 = { 0 };
1222     v16u8 dst_data1 = { 0 };
1223
1224     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
1225     src += (5 * src_stride);
1226     LD_SB4(src, src_stride, src5, src6, src7, src8);
1227
1228     LW4(dst, dst_stride, load0, load1, load2, load3);
1229
1230     dst_data0 = (v16u8) __msa_insert_h((v8i16) dst_data0, 0, load0);
1231     dst_data0 = (v16u8) __msa_insert_h((v8i16) dst_data0, 1, load1);
1232     dst_data0 = (v16u8) __msa_insert_h((v8i16) dst_data0, 2, load2);
1233     dst_data0 = (v16u8) __msa_insert_h((v8i16) dst_data0, 3, load3);
1234
1235     LW4(dst + 4 * dst_stride, dst_stride, load0, load1, load2, load3);
1236
1237     dst_data1 = (v16u8) __msa_insert_h((v8i16) dst_data1, 0, load0);
1238     dst_data1 = (v16u8) __msa_insert_h((v8i16) dst_data1, 1, load1);
1239     dst_data1 = (v16u8) __msa_insert_h((v8i16) dst_data1, 2, load2);
1240     dst_data1 = (v16u8) __msa_insert_h((v8i16) dst_data1, 3, load3);
1241
1242     ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
1243                tmp0, tmp1, tmp2, tmp3);
1244
1245     ILVR_W2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
1246
1247     tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp2, (v2i64) tmp0);
1248
1249     res_r = __msa_dotp_u_h(tmp0, coeff_vec);
1250     res_r <<= 3;
1251     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
1252     res_r = __msa_sat_u_h(res_r, 7);
1253
1254     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
1255     res = (v8i16) __msa_aver_u_b((v16u8) res, dst_data0);
1256
1257     ST2x4_UB(res, 0, dst, dst_stride);
1258     dst += (4 * dst_stride);
1259
1260     ILVR_B4_UB(src5, src4, src6, src5, src7, src6, src8, src7,
1261                tmp0, tmp1, tmp2, tmp3);
1262
1263     ILVR_W2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
1264
1265     tmp0 = (v16u8) __msa_ilvr_d((v2i64) tmp2, (v2i64) tmp0);
1266
1267     res_r = __msa_dotp_u_h(tmp0, coeff_vec);
1268     res_r <<= 3;
1269     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
1270     res_r = __msa_sat_u_h(res_r, 7);
1271
1272     res = (v8i16) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
1273     res = (v8i16) __msa_aver_u_b((v16u8) res, dst_data1);
1274
1275     ST2x4_UB(res, 0, dst, dst_stride);
1276 }
1277
1278 static void avc_chroma_vt_and_aver_dst_2w_msa(uint8_t *src, int32_t src_stride,
1279                                               uint8_t *dst, int32_t dst_stride,
1280                                               uint32_t coeff0, uint32_t coeff1,
1281                                               int32_t height)
1282 {
1283     if (2 == height) {
1284         avc_chroma_vt_and_aver_dst_2x2_msa(src, src_stride, dst, dst_stride,
1285                                            coeff0, coeff1);
1286     } else if (4 == height) {
1287         avc_chroma_vt_and_aver_dst_2x4_msa(src, src_stride, dst, dst_stride,
1288                                            coeff0, coeff1);
1289     } else if (8 == height) {
1290         avc_chroma_vt_and_aver_dst_2x8_msa(src, src_stride, dst, dst_stride,
1291                                            coeff0, coeff1);
1292     }
1293 }
1294
1295 static void avc_chroma_vt_and_aver_dst_4x2_msa(uint8_t *src, int32_t src_stride,
1296                                                uint8_t *dst, int32_t dst_stride,
1297                                                uint32_t coeff0, uint32_t coeff1)
1298 {
1299     uint32_t load0, load1;
1300     v16i8 src0, src1, src2, tmp0, tmp1;
1301     v16u8 dst_data = { 0 };
1302     v8u16 res_r;
1303     v16u8 res;
1304     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1305     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1306     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1307
1308     LD_SB3(src, src_stride, src0, src1, src2);
1309
1310     load0 = LW(dst);
1311     load1 = LW(dst + dst_stride);
1312
1313     INSERT_W2_UB(load0, load1, dst_data);
1314     ILVR_B2_SB(src1, src0, src2, src1, tmp0, tmp1);
1315
1316     tmp0 = (v16i8) __msa_ilvr_d((v2i64) tmp1, (v2i64) tmp0);
1317
1318     res_r = __msa_dotp_u_h((v16u8) tmp0, coeff_vec);
1319     res_r <<= 3;
1320     res_r = (v8u16) __msa_srari_h((v8i16) res_r, 6);
1321     res_r = __msa_sat_u_h(res_r, 7);
1322     res = (v16u8) __msa_pckev_b((v16i8) res_r, (v16i8) res_r);
1323     res = __msa_aver_u_b(res, dst_data);
1324
1325     ST4x2_UB(res, dst, dst_stride);
1326 }
1327
1328 static void avc_chroma_vt_and_aver_dst_4x4mul_msa(uint8_t *src,
1329                                                   int32_t src_stride,
1330                                                   uint8_t *dst,
1331                                                   int32_t dst_stride,
1332                                                   uint32_t coeff0,
1333                                                   uint32_t coeff1,
1334                                                   int32_t height)
1335 {
1336     uint32_t load0, load1, row;
1337     v16i8 src0, src1, src2, src3, src4;
1338     v16u8 tmp0, tmp1, tmp2, tmp3;
1339     v16u8 dst0 = { 0 };
1340     v16u8 dst1 = { 0 };
1341     v8u16 res0_r, res1_r;
1342     v16u8 res0, res1;
1343     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1344     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1345     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1346
1347     src0 = LD_SB(src);
1348     src += src_stride;
1349
1350     for (row = (height >> 2); row--;) {
1351         LD_SB4(src, src_stride, src1, src2, src3, src4);
1352         src += (4 * src_stride);
1353
1354         load0 = LW(dst);
1355         load1 = LW(dst + dst_stride);
1356
1357         INSERT_W2_UB(load0, load1, dst0);
1358         load0 = LW(dst + 2 * dst_stride);
1359         load1 = LW(dst + 3 * dst_stride);
1360         INSERT_W2_UB(load0, load1, dst1);
1361
1362         ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
1363                    tmp0, tmp1, tmp2, tmp3);
1364         ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, tmp0, tmp2);
1365         DOTP_UB2_UH(tmp0, tmp2, coeff_vec, coeff_vec, res0_r, res1_r);
1366
1367         res0_r <<= 3;
1368         res1_r <<= 3;
1369
1370         SRARI_H2_UH(res0_r, res1_r, 6);
1371         SAT_UH2_UH(res0_r, res1_r, 7);
1372         PCKEV_B2_UB(res0_r, res0_r, res1_r, res1_r, res0, res1);
1373         AVER_UB2_UB(res0, dst0, res1, dst1, res0, res1);
1374
1375         ST4x4_UB(res0, res1, 0, 1, 0, 1, dst, dst_stride);
1376         dst += (4 * dst_stride);
1377         src0 = src4;
1378     }
1379 }
1380
1381 static void avc_chroma_vt_and_aver_dst_4w_msa(uint8_t *src, int32_t src_stride,
1382                                               uint8_t *dst, int32_t dst_stride,
1383                                               uint32_t coeff0, uint32_t coeff1,
1384                                               int32_t height)
1385 {
1386     if (2 == height) {
1387         avc_chroma_vt_and_aver_dst_4x2_msa(src, src_stride, dst, dst_stride,
1388                                            coeff0, coeff1);
1389     } else {
1390         avc_chroma_vt_and_aver_dst_4x4mul_msa(src, src_stride, dst, dst_stride,
1391                                               coeff0, coeff1, height);
1392     }
1393 }
1394
1395 static void avc_chroma_vt_and_aver_dst_8w_msa(uint8_t *src, int32_t src_stride,
1396                                               uint8_t *dst, int32_t dst_stride,
1397                                               uint32_t coeff0, uint32_t coeff1,
1398                                               int32_t height)
1399 {
1400     uint32_t row;
1401     v16u8 src0, src1, src2, src3, src4;
1402     v16u8 out0, out1;
1403     v8u16 res0, res1, res2, res3;
1404     v16u8 dst0, dst1, dst2, dst3;
1405     v16i8 coeff_vec0 = __msa_fill_b(coeff0);
1406     v16i8 coeff_vec1 = __msa_fill_b(coeff1);
1407     v16u8 coeff_vec = (v16u8) __msa_ilvr_b(coeff_vec0, coeff_vec1);
1408
1409     src0 = LD_UB(src);
1410     src += src_stride;
1411
1412     for (row = height >> 2; row--;) {
1413         LD_UB4(src, src_stride, src1, src2, src3, src4);
1414         src += (4 * src_stride);
1415         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1416         ILVR_B4_UB(src1, src0, src2, src1, src3, src2, src4, src3,
1417                    src0, src1, src2, src3);
1418         DOTP_UB4_UH(src0, src1, src2, src3, coeff_vec, coeff_vec, coeff_vec,
1419                     coeff_vec, res0, res1, res2, res3);
1420         SLLI_4V(res0, res1, res2, res3, 3);
1421         SRARI_H4_UH(res0, res1, res2, res3, 6);
1422         SAT_UH4_UH(res0, res1, res2, res3, 7);
1423         PCKEV_B2_UB(res1, res0, res3, res2, out0, out1);
1424         PCKEV_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
1425         AVER_UB2_UB(out0, dst0, out1, dst1, out0, out1);
1426         ST8x4_UB(out0, out1, dst, dst_stride);
1427
1428         dst += (4 * dst_stride);
1429         src0 = src4;
1430     }
1431 }
1432
1433 static void avc_chroma_hv_and_aver_dst_2x2_msa(uint8_t *src, int32_t src_stride,
1434                                                uint8_t *dst, int32_t dst_stride,
1435                                                uint32_t coef_hor0,
1436                                                uint32_t coef_hor1,
1437                                                uint32_t coef_ver0,
1438                                                uint32_t coef_ver1)
1439 {
1440     uint16_t out0, out1;
1441     v16u8 dst0, dst1;
1442     v16u8 src0, src1, src2;
1443     v8u16 res_hz0, res_hz1, res_vt0, res_vt1;
1444     v16i8 res, mask;
1445     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
1446     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
1447     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
1448     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
1449     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
1450
1451     mask = LD_SB(&chroma_mask_arr[48]);
1452
1453     LD_UB3(src, src_stride, src0, src1, src2);
1454     LD_UB2(dst, dst_stride, dst0, dst1);
1455     VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
1456     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
1457     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
1458
1459     res_vt0 += res_vt1;
1460     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
1461     res_vt0 = __msa_sat_u_h(res_vt0, 7);
1462     res = __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
1463     dst0 = (v16u8) __msa_insve_h((v8i16) dst0, 1, (v8i16) dst1);
1464     dst0 = __msa_aver_u_b((v16u8) res, dst0);
1465     out0 = __msa_copy_u_h((v8i16) dst0, 0);
1466     out1 = __msa_copy_u_h((v8i16) dst0, 1);
1467
1468     SH(out0, dst);
1469     dst += dst_stride;
1470     SH(out1, dst);
1471 }
1472
1473 static void avc_chroma_hv_and_aver_dst_2x4_msa(uint8_t *src, int32_t src_stride,
1474                                                uint8_t *dst, int32_t dst_stride,
1475                                                uint32_t coef_hor0,
1476                                                uint32_t coef_hor1,
1477                                                uint32_t coef_ver0,
1478                                                uint32_t coef_ver1)
1479 {
1480     v16u8 src0, src1, src2, src3, src4;
1481     v16u8 tmp0, tmp1, tmp2, tmp3;
1482     v16u8 dst0, dst1, dst2, dst3;
1483     v8u16 res_hz0, res_hz1, res_vt0, res_vt1;
1484     v16i8 res, mask;
1485     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
1486     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
1487     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
1488     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
1489     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
1490
1491     mask = LD_SB(&chroma_mask_arr[48]);
1492
1493     LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
1494     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1495     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, tmp0, tmp1);
1496     VSHF_B2_UB(src1, src2, src3, src4, mask, mask, tmp2, tmp3);
1497     ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
1498     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
1499     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
1500
1501     res_vt0 += res_vt1;
1502     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
1503     res_vt0 = __msa_sat_u_h(res_vt0, 7);
1504     res = __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
1505
1506     dst0 = (v16u8) __msa_insve_h((v8i16) dst0, 1, (v8i16) dst1);
1507     dst0 = (v16u8) __msa_insve_h((v8i16) dst0, 2, (v8i16) dst2);
1508     dst0 = (v16u8) __msa_insve_h((v8i16) dst0, 3, (v8i16) dst3);
1509     dst0 = __msa_aver_u_b((v16u8) res, dst0);
1510
1511     ST2x4_UB(dst0, 0, dst, dst_stride);
1512 }
1513
1514 static void avc_chroma_hv_and_aver_dst_2x8_msa(uint8_t *src, int32_t src_stride,
1515                                                uint8_t *dst, int32_t dst_stride,
1516                                                uint32_t coef_hor0,
1517                                                uint32_t coef_hor1,
1518                                                uint32_t coef_ver0,
1519                                                uint32_t coef_ver1)
1520 {
1521     v16u8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
1522     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
1523     v16u8 tmp0, tmp1, tmp2, tmp3;
1524     v8u16 res_hz0, res_hz1, res_vt0, res_vt1;
1525     v16i8 res, mask;
1526     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
1527     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
1528     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
1529     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
1530     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
1531
1532     mask = LD_SB(&chroma_mask_arr[48]);
1533
1534     LD_UB5(src, src_stride, src0, src1, src2, src3, src4);
1535     src += (5 * src_stride);
1536     LD_UB4(src, src_stride, src5, src6, src7, src8);
1537
1538     LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
1539
1540     dst0 = (v16u8) __msa_insve_h((v8i16) dst0, 1, (v8i16) dst1);
1541     dst0 = (v16u8) __msa_insve_h((v8i16) dst0, 2, (v8i16) dst2);
1542     dst0 = (v16u8) __msa_insve_h((v8i16) dst0, 3, (v8i16) dst3);
1543
1544     dst4 = (v16u8) __msa_insve_h((v8i16) dst4, 1, (v8i16) dst5);
1545     dst4 = (v16u8) __msa_insve_h((v8i16) dst4, 2, (v8i16) dst6);
1546     dst4 = (v16u8) __msa_insve_h((v8i16) dst4, 3, (v8i16) dst7);
1547
1548     VSHF_B2_UB(src0, src1, src2, src3, mask, mask, tmp0, tmp1);
1549     VSHF_B2_UB(src1, src2, src3, src4, mask, mask, tmp2, tmp3);
1550     ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
1551     VSHF_B2_UB(src4, src5, src6, src7, mask, mask, tmp0, tmp1);
1552     VSHF_B2_UB(src5, src6, src7, src8, mask, mask, tmp2, tmp3);
1553     ILVR_D2_UB(tmp1, tmp0, tmp3, tmp2, src4, src5);
1554     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
1555     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
1556
1557     res_vt0 += res_vt1;
1558     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
1559     res_vt0 = __msa_sat_u_h(res_vt0, 7);
1560     res = __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
1561     dst0 = __msa_aver_u_b((v16u8) res, dst0);
1562
1563     ST2x4_UB(dst0, 0, dst, dst_stride);
1564     dst += (4 * dst_stride);
1565
1566     DOTP_UB2_UH(src4, src5, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
1567     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
1568
1569     res_vt0 += res_vt1;
1570     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
1571     res_vt0 = __msa_sat_u_h(res_vt0, 7);
1572     res = __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
1573     dst4 = __msa_aver_u_b((v16u8) res, dst4);
1574
1575     ST2x4_UB(dst4, 0, dst, dst_stride);
1576 }
1577
1578 static void avc_chroma_hv_and_aver_dst_2w_msa(uint8_t *src, int32_t src_stride,
1579                                               uint8_t *dst, int32_t dst_stride,
1580                                               uint32_t coef_hor0,
1581                                               uint32_t coef_hor1,
1582                                               uint32_t coef_ver0,
1583                                               uint32_t coef_ver1,
1584                                               int32_t height)
1585 {
1586     if (2 == height) {
1587         avc_chroma_hv_and_aver_dst_2x2_msa(src, src_stride, dst, dst_stride,
1588                                            coef_hor0, coef_hor1,
1589                                            coef_ver0, coef_ver1);
1590     } else if (4 == height) {
1591         avc_chroma_hv_and_aver_dst_2x4_msa(src, src_stride, dst, dst_stride,
1592                                            coef_hor0, coef_hor1,
1593                                            coef_ver0, coef_ver1);
1594     } else if (8 == height) {
1595         avc_chroma_hv_and_aver_dst_2x8_msa(src, src_stride, dst, dst_stride,
1596                                            coef_hor0, coef_hor1,
1597                                            coef_ver0, coef_ver1);
1598     }
1599 }
1600
1601 static void avc_chroma_hv_and_aver_dst_4x2_msa(uint8_t *src, int32_t src_stride,
1602                                                uint8_t *dst, int32_t dst_stride,
1603                                                uint32_t coef_hor0,
1604                                                uint32_t coef_hor1,
1605                                                uint32_t coef_ver0,
1606                                                uint32_t coef_ver1)
1607 {
1608     v16u8 src0, src1, src2;
1609     v16u8 dst0, dst1;
1610     v8u16 res_hz0, res_hz1, res_vt0, res_vt1;
1611     v16i8 res, mask;
1612     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
1613     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
1614     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
1615     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
1616     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
1617
1618     mask = LD_SB(&chroma_mask_arr[0]);
1619
1620     LD_UB3(src, src_stride, src0, src1, src2);
1621     LD_UB2(dst, dst_stride, dst0, dst1);
1622     VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
1623     DOTP_UB2_UH(src0, src1, coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1);
1624     MUL2(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_vt0, res_vt1);
1625
1626     res_vt0 += res_vt1;
1627     res_vt0 = (v8u16) __msa_srari_h((v8i16) res_vt0, 6);
1628     res_vt0 = __msa_sat_u_h(res_vt0, 7);
1629     res = __msa_pckev_b((v16i8) res_vt0, (v16i8) res_vt0);
1630     dst0 = (v16u8) __msa_insve_w((v4i32) dst0, 1, (v4i32) dst1);
1631     dst0 = __msa_aver_u_b((v16u8) res, dst0);
1632
1633     ST4x2_UB(dst0, dst, dst_stride);
1634 }
1635
1636 static void avc_chroma_hv_and_aver_dst_4x4mul_msa(uint8_t *src,
1637                                                   int32_t src_stride,
1638                                                   uint8_t *dst,
1639                                                   int32_t dst_stride,
1640                                                   uint32_t coef_hor0,
1641                                                   uint32_t coef_hor1,
1642                                                   uint32_t coef_ver0,
1643                                                   uint32_t coef_ver1,
1644                                                   int32_t height)
1645 {
1646     uint32_t row;
1647     v16u8 src0, src1, src2, src3, src4;
1648     v16u8 dst0, dst1, dst2, dst3;
1649     v8u16 res_hz0, res_hz1, res_hz2, res_hz3;
1650     v8u16 res_vt0, res_vt1, res_vt2, res_vt3;
1651     v16i8 mask;
1652     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
1653     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
1654     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
1655     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
1656     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
1657     v16u8 res0, res1;
1658
1659     mask = LD_SB(&chroma_mask_arr[0]);
1660
1661     src0 = LD_UB(src);
1662     src += src_stride;
1663
1664     for (row = (height >> 2); row--;) {
1665         LD_UB4(src, src_stride, src1, src2, src3, src4);
1666         src += (4 * src_stride);
1667
1668         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1669
1670         VSHF_B2_UB(src0, src1, src1, src2, mask, mask, src0, src1);
1671         VSHF_B2_UB(src2, src3, src3, src4, mask, mask, src2, src3);
1672         DOTP_UB4_UH(src0, src1, src2, src3, coeff_hz_vec, coeff_hz_vec,
1673                     coeff_hz_vec, coeff_hz_vec, res_hz0, res_hz1, res_hz2,
1674                     res_hz3);
1675         MUL4(res_hz0, coeff_vt_vec1, res_hz1, coeff_vt_vec0, res_hz2,
1676              coeff_vt_vec1, res_hz3, coeff_vt_vec0, res_vt0, res_vt1, res_vt2,
1677              res_vt3);
1678         ADD2(res_vt0, res_vt1, res_vt2, res_vt3, res_vt0, res_vt1);
1679         SRARI_H2_UH(res_vt0, res_vt1, 6);
1680         SAT_UH2_UH(res_vt0, res_vt1, 7);
1681         PCKEV_B2_UB(res_vt0, res_vt0, res_vt1, res_vt1, res0, res1);
1682
1683         dst0 = (v16u8) __msa_insve_w((v4i32) dst0, 1, (v4i32) dst1);
1684         dst1 = (v16u8) __msa_insve_w((v4i32) dst2, 1, (v4i32) dst3);
1685
1686         AVER_UB2_UB(res0, dst0, res1, dst1, dst0, dst1);
1687
1688         ST4x4_UB(dst0, dst1, 0, 1, 0, 1, dst, dst_stride);
1689         dst += (4 * dst_stride);
1690         src0 = src4;
1691     }
1692 }
1693
1694 static void avc_chroma_hv_and_aver_dst_4w_msa(uint8_t *src, int32_t src_stride,
1695                                               uint8_t *dst, int32_t dst_stride,
1696                                               uint32_t coef_hor0,
1697                                               uint32_t coef_hor1,
1698                                               uint32_t coef_ver0,
1699                                               uint32_t coef_ver1,
1700                                               int32_t height)
1701 {
1702     if (2 == height) {
1703         avc_chroma_hv_and_aver_dst_4x2_msa(src, src_stride, dst, dst_stride,
1704                                            coef_hor0, coef_hor1,
1705                                            coef_ver0, coef_ver1);
1706     } else {
1707         avc_chroma_hv_and_aver_dst_4x4mul_msa(src, src_stride, dst, dst_stride,
1708                                               coef_hor0, coef_hor1,
1709                                               coef_ver0, coef_ver1, height);
1710     }
1711 }
1712
1713 static void avc_chroma_hv_and_aver_dst_8w_msa(uint8_t *src, int32_t src_stride,
1714                                               uint8_t *dst, int32_t dst_stride,
1715                                               uint32_t coef_hor0,
1716                                               uint32_t coef_hor1,
1717                                               uint32_t coef_ver0,
1718                                               uint32_t coef_ver1,
1719                                               int32_t height)
1720 {
1721     uint32_t row;
1722     v16u8 src0, src1, src2, src3, src4, out0, out1;
1723     v8u16 res_hz0, res_hz1, res_hz2;
1724     v8u16 res_hz3, res_hz4;
1725     v8u16 res_vt0, res_vt1, res_vt2, res_vt3;
1726     v16u8 dst0, dst1, dst2, dst3;
1727     v16i8 mask;
1728     v16i8 coeff_hz_vec0 = __msa_fill_b(coef_hor0);
1729     v16i8 coeff_hz_vec1 = __msa_fill_b(coef_hor1);
1730     v16u8 coeff_hz_vec = (v16u8) __msa_ilvr_b(coeff_hz_vec0, coeff_hz_vec1);
1731     v8u16 coeff_vt_vec0 = (v8u16) __msa_fill_h(coef_ver0);
1732     v8u16 coeff_vt_vec1 = (v8u16) __msa_fill_h(coef_ver1);
1733
1734     mask = LD_SB(&chroma_mask_arr[32]);
1735
1736     src0 = LD_UB(src);
1737     src += src_stride;
1738
1739     src0 = (v16u8) __msa_vshf_b(mask, (v16i8) src0, (v16i8) src0);
1740     res_hz0 = __msa_dotp_u_h(src0, coeff_hz_vec);
1741
1742     for (row = (height >> 2); row--;) {
1743         LD_UB4(src, src_stride, src1, src2, src3, src4);
1744         src += (4 * src_stride);
1745
1746         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1747         VSHF_B2_UB(src1, src1, src2, src2, mask, mask, src1, src2);
1748         VSHF_B2_UB(src3, src3, src4, src4, mask, mask, src3, src4);
1749         DOTP_UB4_UH(src1, src2, src3, src4, coeff_hz_vec, coeff_hz_vec,
1750                     coeff_hz_vec, coeff_hz_vec, res_hz1, res_hz2, res_hz3,
1751                     res_hz4);
1752         MUL4(res_hz1, coeff_vt_vec0, res_hz2, coeff_vt_vec0, res_hz3,
1753              coeff_vt_vec0, res_hz4, coeff_vt_vec0, res_vt0, res_vt1, res_vt2,
1754              res_vt3);
1755
1756         res_vt0 += (res_hz0 * coeff_vt_vec1);
1757         res_vt1 += (res_hz1 * coeff_vt_vec1);
1758         res_vt2 += (res_hz2 * coeff_vt_vec1);
1759         res_vt3 += (res_hz3 * coeff_vt_vec1);
1760
1761         SRARI_H4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 6);
1762         SAT_UH4_UH(res_vt0, res_vt1, res_vt2, res_vt3, 7);
1763
1764         PCKEV_B2_UB(res_vt1, res_vt0, res_vt3, res_vt2, out0, out1);
1765         PCKEV_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
1766         AVER_UB2_UB(out0, dst0, out1, dst1, out0, out1);
1767         ST8x4_UB(out0, out1, dst, dst_stride);
1768         dst += (4 * dst_stride);
1769
1770         res_hz0 = res_hz4;
1771     }
1772 }
1773
1774 static void copy_width8_msa(uint8_t *src, int32_t src_stride,
1775                             uint8_t *dst, int32_t dst_stride,
1776                             int32_t height)
1777 {
1778     int32_t cnt;
1779     uint64_t out0, out1, out2, out3, out4, out5, out6, out7;
1780     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
1781
1782     if (0 == height % 12) {
1783         for (cnt = (height / 12); cnt--;) {
1784             LD_UB8(src, src_stride,
1785                    src0, src1, src2, src3, src4, src5, src6, src7);
1786             src += (8 * src_stride);
1787
1788             out0 = __msa_copy_u_d((v2i64) src0, 0);
1789             out1 = __msa_copy_u_d((v2i64) src1, 0);
1790             out2 = __msa_copy_u_d((v2i64) src2, 0);
1791             out3 = __msa_copy_u_d((v2i64) src3, 0);
1792             out4 = __msa_copy_u_d((v2i64) src4, 0);
1793             out5 = __msa_copy_u_d((v2i64) src5, 0);
1794             out6 = __msa_copy_u_d((v2i64) src6, 0);
1795             out7 = __msa_copy_u_d((v2i64) src7, 0);
1796
1797             SD4(out0, out1, out2, out3, dst, dst_stride);
1798             dst += (4 * dst_stride);
1799             SD4(out4, out5, out6, out7, dst, dst_stride);
1800             dst += (4 * dst_stride);
1801
1802             LD_UB4(src, src_stride, src0, src1, src2, src3);
1803             src += (4 * src_stride);
1804
1805             out0 = __msa_copy_u_d((v2i64) src0, 0);
1806             out1 = __msa_copy_u_d((v2i64) src1, 0);
1807             out2 = __msa_copy_u_d((v2i64) src2, 0);
1808             out3 = __msa_copy_u_d((v2i64) src3, 0);
1809
1810             SD4(out0, out1, out2, out3, dst, dst_stride);
1811             dst += (4 * dst_stride);
1812         }
1813     } else if (0 == height % 8) {
1814         for (cnt = height >> 3; cnt--;) {
1815             LD_UB8(src, src_stride,
1816                    src0, src1, src2, src3, src4, src5, src6, src7);
1817             src += (8 * src_stride);
1818
1819             out0 = __msa_copy_u_d((v2i64) src0, 0);
1820             out1 = __msa_copy_u_d((v2i64) src1, 0);
1821             out2 = __msa_copy_u_d((v2i64) src2, 0);
1822             out3 = __msa_copy_u_d((v2i64) src3, 0);
1823             out4 = __msa_copy_u_d((v2i64) src4, 0);
1824             out5 = __msa_copy_u_d((v2i64) src5, 0);
1825             out6 = __msa_copy_u_d((v2i64) src6, 0);
1826             out7 = __msa_copy_u_d((v2i64) src7, 0);
1827
1828             SD4(out0, out1, out2, out3, dst, dst_stride);
1829             dst += (4 * dst_stride);
1830             SD4(out4, out5, out6, out7, dst, dst_stride);
1831             dst += (4 * dst_stride);
1832         }
1833     } else if (0 == height % 4) {
1834         for (cnt = (height / 4); cnt--;) {
1835             LD_UB4(src, src_stride, src0, src1, src2, src3);
1836             src += (4 * src_stride);
1837             out0 = __msa_copy_u_d((v2i64) src0, 0);
1838             out1 = __msa_copy_u_d((v2i64) src1, 0);
1839             out2 = __msa_copy_u_d((v2i64) src2, 0);
1840             out3 = __msa_copy_u_d((v2i64) src3, 0);
1841
1842             SD4(out0, out1, out2, out3, dst, dst_stride);
1843             dst += (4 * dst_stride);
1844         }
1845     } else if (0 == height % 2) {
1846         for (cnt = (height / 2); cnt--;) {
1847             LD_UB2(src, src_stride, src0, src1);
1848             src += (2 * src_stride);
1849             out0 = __msa_copy_u_d((v2i64) src0, 0);
1850             out1 = __msa_copy_u_d((v2i64) src1, 0);
1851
1852             SD(out0, dst);
1853             dst += dst_stride;
1854             SD(out1, dst);
1855             dst += dst_stride;
1856         }
1857     }
1858 }
1859
1860 static void avg_width4_msa(uint8_t *src, int32_t src_stride,
1861                            uint8_t *dst, int32_t dst_stride,
1862                            int32_t height)
1863 {
1864     int32_t cnt;
1865     uint32_t out0, out1, out2, out3;
1866     v16u8 src0, src1, src2, src3;
1867     v16u8 dst0, dst1, dst2, dst3;
1868
1869     if (0 == (height % 4)) {
1870         for (cnt = (height / 4); cnt--;) {
1871             LD_UB4(src, src_stride, src0, src1, src2, src3);
1872             src += (4 * src_stride);
1873
1874             LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1875
1876             AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
1877                         dst0, dst1, dst2, dst3);
1878
1879             out0 = __msa_copy_u_w((v4i32) dst0, 0);
1880             out1 = __msa_copy_u_w((v4i32) dst1, 0);
1881             out2 = __msa_copy_u_w((v4i32) dst2, 0);
1882             out3 = __msa_copy_u_w((v4i32) dst3, 0);
1883             SW4(out0, out1, out2, out3, dst, dst_stride);
1884             dst += (4 * dst_stride);
1885         }
1886     } else if (0 == (height % 2)) {
1887         for (cnt = (height / 2); cnt--;) {
1888             LD_UB2(src, src_stride, src0, src1);
1889             src += (2 * src_stride);
1890
1891             LD_UB2(dst, dst_stride, dst0, dst1);
1892
1893             AVER_UB2_UB(src0, dst0, src1, dst1, dst0, dst1);
1894
1895             out0 = __msa_copy_u_w((v4i32) dst0, 0);
1896             out1 = __msa_copy_u_w((v4i32) dst1, 0);
1897             SW(out0, dst);
1898             dst += dst_stride;
1899             SW(out1, dst);
1900             dst += dst_stride;
1901         }
1902     }
1903 }
1904
1905 static void avg_width8_msa(uint8_t *src, int32_t src_stride,
1906                            uint8_t *dst, int32_t dst_stride,
1907                            int32_t height)
1908 {
1909     int32_t cnt;
1910     uint64_t out0, out1, out2, out3;
1911     v16u8 src0, src1, src2, src3;
1912     v16u8 dst0, dst1, dst2, dst3;
1913
1914     for (cnt = (height / 4); cnt--;) {
1915         LD_UB4(src, src_stride, src0, src1, src2, src3);
1916         src += (4 * src_stride);
1917         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
1918
1919         AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
1920                     dst0, dst1, dst2, dst3);
1921
1922         out0 = __msa_copy_u_d((v2i64) dst0, 0);
1923         out1 = __msa_copy_u_d((v2i64) dst1, 0);
1924         out2 = __msa_copy_u_d((v2i64) dst2, 0);
1925         out3 = __msa_copy_u_d((v2i64) dst3, 0);
1926         SD4(out0, out1, out2, out3, dst, dst_stride);
1927         dst += (4 * dst_stride);
1928     }
1929 }
1930
1931 void ff_put_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
1932                                 ptrdiff_t stride, int height, int x, int y)
1933 {
1934     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
1935
1936     if (x && y) {
1937         avc_chroma_hv_8w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
1938     } else if (x) {
1939         avc_chroma_hz_8w_msa(src, dst, stride, x, (8 - x), height);
1940     } else if (y) {
1941         avc_chroma_vt_8w_msa(src, dst, stride, y, (8 - y), height);
1942     } else {
1943         copy_width8_msa(src, stride, dst, stride, height);
1944     }
1945 }
1946
1947 void ff_put_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src,
1948                                 ptrdiff_t stride, int height, int x, int y)
1949 {
1950     int32_t cnt;
1951
1952     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
1953
1954     if (x && y) {
1955         avc_chroma_hv_4w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
1956     } else if (x) {
1957         avc_chroma_hz_4w_msa(src, dst, stride, x, (8 - x), height);
1958     } else if (y) {
1959         avc_chroma_vt_4w_msa(src, dst, stride, y, (8 - y), height);
1960     } else {
1961         for (cnt = height; cnt--;) {
1962             *((uint32_t *) dst) = *((uint32_t *) src);
1963
1964             src += stride;
1965             dst += stride;
1966         }
1967     }
1968 }
1969
1970 void ff_put_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src,
1971                                 ptrdiff_t stride, int height, int x, int y)
1972 {
1973     int32_t cnt;
1974
1975     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
1976
1977     if (x && y) {
1978         avc_chroma_hv_2w_msa(src, dst, stride, x, (8 - x), y, (8 - y), height);
1979     } else if (x) {
1980         avc_chroma_hz_2w_msa(src, dst, stride, x, (8 - x), height);
1981     } else if (y) {
1982         avc_chroma_vt_2w_msa(src, dst, stride, y, (8 - y), height);
1983     } else {
1984         for (cnt = height; cnt--;) {
1985             *((uint16_t *) dst) = *((uint16_t *) src);
1986
1987             src += stride;
1988             dst += stride;
1989         }
1990     }
1991 }
1992
1993 void ff_avg_h264_chroma_mc8_msa(uint8_t *dst, uint8_t *src,
1994                                 ptrdiff_t stride, int height, int x, int y)
1995 {
1996     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
1997
1998
1999     if (x && y) {
2000         avc_chroma_hv_and_aver_dst_8w_msa(src, stride, dst,
2001                                           stride, x, (8 - x), y,
2002                                           (8 - y), height);
2003     } else if (x) {
2004         avc_chroma_hz_and_aver_dst_8w_msa(src, dst, stride, x, (8 - x), height);
2005     } else if (y) {
2006         avc_chroma_vt_and_aver_dst_8w_msa(src, stride, dst,
2007                                           stride, y, (8 - y), height);
2008     } else {
2009         avg_width8_msa(src, stride, dst, stride, height);
2010     }
2011 }
2012
2013 void ff_avg_h264_chroma_mc4_msa(uint8_t *dst, uint8_t *src,
2014                                 ptrdiff_t stride, int height, int x, int y)
2015 {
2016     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
2017
2018     if (x && y) {
2019         avc_chroma_hv_and_aver_dst_4w_msa(src, stride, dst,
2020                                           stride, x, (8 - x), y,
2021                                           (8 - y), height);
2022     } else if (x) {
2023         avc_chroma_hz_and_aver_dst_4w_msa(src, dst, stride, x, (8 - x), height);
2024     } else if (y) {
2025         avc_chroma_vt_and_aver_dst_4w_msa(src, stride, dst,
2026                                           stride, y, (8 - y), height);
2027     } else {
2028         avg_width4_msa(src, stride, dst, stride, height);
2029     }
2030 }
2031
2032 void ff_avg_h264_chroma_mc2_msa(uint8_t *dst, uint8_t *src,
2033                                 ptrdiff_t stride, int height, int x, int y)
2034 {
2035     int32_t cnt;
2036
2037     av_assert2(x < 8 && y < 8 && x >= 0 && y >= 0);
2038
2039     if (x && y) {
2040         avc_chroma_hv_and_aver_dst_2w_msa(src, stride, dst,
2041                                           stride, x, (8 - x), y,
2042                                           (8 - y), height);
2043     } else if (x) {
2044         avc_chroma_hz_and_aver_dst_2w_msa(src, dst, stride, x, (8 - x), height);
2045     } else if (y) {
2046         avc_chroma_vt_and_aver_dst_2w_msa(src, stride, dst,
2047                                           stride, y, (8 - y), height);
2048     } else {
2049         for (cnt = height; cnt--;) {
2050             dst[0] = (dst[0] + src[0] + 1) >> 1;
2051             dst[1] = (dst[1] + src[1] + 1) >> 1;
2052
2053             src += stride;
2054             dst += stride;
2055         }
2056     }
2057 }