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

   1 /*
   2  * Copyright (c) 2015 - 2017 Parag Salasakar (Parag.Salasakar@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 "h264dsp_mips.h"
  23
  24 static void avc_wgt_4x2_msa(uint8_t *data, int32_t stride,
  25                             int32_t log2_denom, int32_t src_weight,
  26                             int32_t offset_in)
  27 {
  28     uint32_t tp0, tp1, offset_val;
  29     v16u8 zero = { 0 };
  30     v16u8 src0 = { 0 };
  31     v8i16 src0_r, tmp0, wgt, denom, offset;
  32
  33     offset_val = (unsigned) offset_in << log2_denom;
  34
  35     wgt = __msa_fill_h(src_weight);
  36     offset = __msa_fill_h(offset_val);
  37     denom = __msa_fill_h(log2_denom);
  38
  39     LW2(data, stride, tp0, tp1);
  40     INSERT_W2_UB(tp0, tp1, src0);
  41     src0_r = (v8i16) __msa_ilvr_b((v16i8) zero, (v16i8) src0);
  42     tmp0 = wgt * src0_r;
  43     tmp0 = __msa_adds_s_h(tmp0, offset);
  44     tmp0 = __msa_maxi_s_h(tmp0, 0);
  45     tmp0 = __msa_srlr_h(tmp0, denom);
  46     tmp0 = (v8i16) __msa_sat_u_h((v8u16) tmp0, 7);
  47     src0 = (v16u8) __msa_pckev_b((v16i8) tmp0, (v16i8) tmp0);
  48     ST4x2_UB(src0, data, stride);
  49 }
  50
  51 static void avc_wgt_4x4_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
  52                             int32_t src_weight, int32_t offset_in)
  53 {
  54     uint32_t tp0, tp1, tp2, tp3, offset_val;
  55     v16u8 src0 = { 0 };
  56     v8i16 src0_r, src1_r, tmp0, tmp1, wgt, denom, offset;
  57
  58     offset_val = (unsigned) offset_in << log2_denom;
  59
  60     wgt = __msa_fill_h(src_weight);
  61     offset = __msa_fill_h(offset_val);
  62     denom = __msa_fill_h(log2_denom);
  63
  64     LW4(data, stride, tp0, tp1, tp2, tp3);
  65     INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
  66     UNPCK_UB_SH(src0, src0_r, src1_r);
  67     MUL2(wgt, src0_r, wgt, src1_r, tmp0, tmp1);
  68     ADDS_SH2_SH(tmp0, offset, tmp1, offset, tmp0, tmp1);
  69     MAXI_SH2_SH(tmp0, tmp1, 0);
  70     tmp0 = __msa_srlr_h(tmp0, denom);
  71     tmp1 = __msa_srlr_h(tmp1, denom);
  72     SAT_UH2_SH(tmp0, tmp1, 7);
  73     src0 = (v16u8) __msa_pckev_b((v16i8) tmp1, (v16i8) tmp0);
  74     ST4x4_UB(src0, src0, 0, 1, 2, 3, data, stride);
  75 }
  76
  77 static void avc_wgt_4x8_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
  78                             int32_t src_weight, int32_t offset_in)
  79 {
  80     uint32_t tp0, tp1, tp2, tp3, offset_val;
  81     v16u8 src0 = { 0 }, src1 = { 0 };
  82     v8i16 src0_r, src1_r, src2_r, src3_r, tmp0, tmp1, tmp2, tmp3;
  83     v8i16 wgt, denom, offset;
  84
  85     offset_val = (unsigned) offset_in << log2_denom;
  86
  87     wgt = __msa_fill_h(src_weight);
  88     offset = __msa_fill_h(offset_val);
  89     denom = __msa_fill_h(log2_denom);
  90
  91     LW4(data, stride, tp0, tp1, tp2, tp3);
  92     INSERT_W4_UB(tp0, tp1, tp2, tp3, src0);
  93     LW4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
  94     INSERT_W4_UB(tp0, tp1, tp2, tp3, src1);
  95     UNPCK_UB_SH(src0, src0_r, src1_r);
  96     UNPCK_UB_SH(src1, src2_r, src3_r);
  97     MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
  98          tmp3);
  99     ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
 100                 tmp1, tmp2, tmp3);
 101     MAXI_SH4_SH(tmp0, tmp1, tmp2, tmp3, 0);
 102     SRLR_H4_SH(tmp0, tmp1, tmp2, tmp3, denom);
 103     SAT_UH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
 104     PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
 105     ST4x8_UB(src0, src1, data, stride);
 106 }
 107
 108 static void avc_wgt_8x4_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
 109                             int32_t src_weight, int32_t offset_in)
 110 {
 111     uint32_t offset_val;
 112     uint64_t tp0, tp1, tp2, tp3;
 113     v16u8 src0 = { 0 }, src1 = { 0 };
 114     v8i16 src0_r, src1_r, src2_r, src3_r, tmp0, tmp1, tmp2, tmp3;
 115     v8i16 wgt, denom, offset;
 116
 117     offset_val = (unsigned) offset_in << log2_denom;
 118
 119     wgt = __msa_fill_h(src_weight);
 120     offset = __msa_fill_h(offset_val);
 121     denom = __msa_fill_h(log2_denom);
 122
 123     LD4(data, stride, tp0, tp1, tp2, tp3);
 124     INSERT_D2_UB(tp0, tp1, src0);
 125     INSERT_D2_UB(tp2, tp3, src1);
 126     UNPCK_UB_SH(src0, src0_r, src1_r);
 127     UNPCK_UB_SH(src1, src2_r, src3_r);
 128     MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
 129          tmp3);
 130     ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
 131                 tmp1, tmp2, tmp3);
 132     MAXI_SH4_SH(tmp0, tmp1, tmp2, tmp3, 0);
 133     SRLR_H4_SH(tmp0, tmp1, tmp2, tmp3, denom);
 134     SAT_UH4_SH(tmp0, tmp1, tmp2, tmp3, 7);
 135     PCKEV_B2_UB(tmp1, tmp0, tmp3, tmp2, src0, src1);
 136     ST8x4_UB(src0, src1, data, stride);
 137 }
 138
 139 static void avc_wgt_8x8_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
 140                             int32_t src_weight, int32_t offset_in)
 141 {
 142     uint32_t offset_val;
 143     uint64_t tp0, tp1, tp2, tp3;
 144     v16u8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
 145     v8i16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
 146     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 147     v8i16 wgt, denom, offset;
 148
 149     offset_val = (unsigned) offset_in << log2_denom;
 150
 151     wgt = __msa_fill_h(src_weight);
 152     offset = __msa_fill_h(offset_val);
 153     denom = __msa_fill_h(log2_denom);
 154
 155     LD4(data, stride, tp0, tp1, tp2, tp3);
 156     INSERT_D2_UB(tp0, tp1, src0);
 157     INSERT_D2_UB(tp2, tp3, src1);
 158     LD4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
 159     INSERT_D2_UB(tp0, tp1, src2);
 160     INSERT_D2_UB(tp2, tp3, src3);
 161     UNPCK_UB_SH(src0, src0_r, src1_r);
 162     UNPCK_UB_SH(src1, src2_r, src3_r);
 163     UNPCK_UB_SH(src2, src4_r, src5_r);
 164     UNPCK_UB_SH(src3, src6_r, src7_r);
 165     MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1, tmp2,
 166          tmp3);
 167     MUL4(wgt, src4_r, wgt, src5_r, wgt, src6_r, wgt, src7_r, tmp4, tmp5, tmp6,
 168          tmp7);
 169     ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
 170                 tmp1, tmp2, tmp3);
 171     ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset, tmp4,
 172                 tmp5, tmp6, tmp7);
 173     MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
 174     SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
 175     SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
 176     PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, src0, src1,
 177                 src2, src3);
 178     ST8x8_UB(src0, src1, src2, src3, data, stride);
 179 }
 180
 181 static void avc_wgt_8x16_msa(uint8_t *data, int32_t stride, int32_t log2_denom,
 182                              int32_t src_weight, int32_t offset_in)
 183 {
 184     uint32_t offset_val, cnt;
 185     uint64_t tp0, tp1, tp2, tp3;
 186     v16u8 src0 = { 0 }, src1 = { 0 }, src2 = { 0 }, src3 = { 0 };
 187     v8i16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
 188     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 189     v8i16 wgt, denom, offset;
 190
 191     offset_val = (unsigned) offset_in << log2_denom;
 192
 193     wgt = __msa_fill_h(src_weight);
 194     offset = __msa_fill_h(offset_val);
 195     denom = __msa_fill_h(log2_denom);
 196
 197     for (cnt = 2; cnt--;) {
 198         LD4(data, stride, tp0, tp1, tp2, tp3);
 199         INSERT_D2_UB(tp0, tp1, src0);
 200         INSERT_D2_UB(tp2, tp3, src1);
 201         LD4(data + 4 * stride, stride, tp0, tp1, tp2, tp3);
 202         INSERT_D2_UB(tp0, tp1, src2);
 203         INSERT_D2_UB(tp2, tp3, src3);
 204         UNPCK_UB_SH(src0, src0_r, src1_r);
 205         UNPCK_UB_SH(src1, src2_r, src3_r);
 206         UNPCK_UB_SH(src2, src4_r, src5_r);
 207         UNPCK_UB_SH(src3, src6_r, src7_r);
 208         MUL4(wgt, src0_r, wgt, src1_r, wgt, src2_r, wgt, src3_r, tmp0, tmp1,
 209              tmp2, tmp3);
 210         MUL4(wgt, src4_r, wgt, src5_r, wgt, src6_r, wgt, src7_r, tmp4, tmp5,
 211              tmp6, tmp7);
 212         ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset,
 213                     tmp0, tmp1, tmp2, tmp3);
 214         ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset,
 215                     tmp4, tmp5, tmp6, tmp7);
 216         MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
 217         SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
 218         SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
 219         PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, src0, src1,
 220                     src2, src3);
 221         ST8x8_UB(src0, src1, src2, src3, data, stride);
 222         data += 8 * stride;
 223     }
 224 }
 225
 226 static void avc_biwgt_4x2_msa(uint8_t *src, int32_t src_stride,
 227                               uint8_t *dst, int32_t dst_stride,
 228                               int32_t log2_denom, int32_t src_weight,
 229                               int32_t dst_weight, int32_t offset_in)
 230 {
 231     uint32_t load0, load1, out0, out1;
 232     v16i8 src_wgt, dst_wgt, wgt;
 233     v16i8 src0, src1, dst0, dst1;
 234     v8i16 temp0, temp1, denom, offset, add_val;
 235     int32_t val = 128 * (src_weight + dst_weight);
 236
 237     offset_in = ((offset_in + 1) | 1) << log2_denom;
 238
 239     src_wgt = __msa_fill_b(src_weight);
 240     dst_wgt = __msa_fill_b(dst_weight);
 241     offset = __msa_fill_h(offset_in);
 242     denom = __msa_fill_h(log2_denom + 1);
 243     add_val = __msa_fill_h(val);
 244     offset += add_val;
 245
 246     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 247
 248     load0 = LW(src);
 249     src += src_stride;
 250     load1 = LW(src);
 251
 252     src0 = (v16i8) __msa_fill_w(load0);
 253     src1 = (v16i8) __msa_fill_w(load1);
 254
 255     load0 = LW(dst);
 256     load1 = LW(dst + dst_stride);
 257
 258     dst0 = (v16i8) __msa_fill_w(load0);
 259     dst1 = (v16i8) __msa_fill_w(load1);
 260
 261     XORI_B4_128_SB(src0, src1, dst0, dst1);
 262     ILVR_B2_SH(dst0, src0, dst1, src1, temp0, temp1);
 263
 264     temp0 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp0);
 265     temp1 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp1);
 266
 267     temp0 >>= denom;
 268     temp1 >>= denom;
 269
 270     CLIP_SH2_0_255(temp0, temp1);
 271     PCKEV_B2_SB(temp0, temp0, temp1, temp1, dst0, dst1);
 272
 273     out0 = __msa_copy_u_w((v4i32) dst0, 0);
 274     out1 = __msa_copy_u_w((v4i32) dst1, 0);
 275     SW(out0, dst);
 276     dst += dst_stride;
 277     SW(out1, dst);
 278 }
 279
 280 static void avc_biwgt_4x4multiple_msa(uint8_t *src, int32_t src_stride,
 281                                       uint8_t *dst, int32_t dst_stride,
 282                                       int32_t height, int32_t log2_denom,
 283                                       int32_t src_weight, int32_t dst_weight,
 284                                       int32_t offset_in)
 285 {
 286     uint8_t cnt;
 287     uint32_t load0, load1, load2, load3;
 288     v16i8 src_wgt, dst_wgt, wgt;
 289     v16i8 src0, src1, src2, src3;
 290     v16i8 dst0, dst1, dst2, dst3;
 291     v8i16 temp0, temp1, temp2, temp3;
 292     v8i16 denom, offset, add_val;
 293     int32_t val = 128 * (src_weight + dst_weight);
 294
 295     offset_in = ((offset_in + 1) | 1) << log2_denom;
 296
 297     src_wgt = __msa_fill_b(src_weight);
 298     dst_wgt = __msa_fill_b(dst_weight);
 299     offset = __msa_fill_h(offset_in);
 300     denom = __msa_fill_h(log2_denom + 1);
 301     add_val = __msa_fill_h(val);
 302     offset += add_val;
 303
 304     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 305
 306     for (cnt = height / 4; cnt--;) {
 307         LW4(src, src_stride, load0, load1, load2, load3);
 308         src += (4 * src_stride);
 309
 310         src0 = (v16i8) __msa_fill_w(load0);
 311         src1 = (v16i8) __msa_fill_w(load1);
 312         src2 = (v16i8) __msa_fill_w(load2);
 313         src3 = (v16i8) __msa_fill_w(load3);
 314
 315         LW4(dst, dst_stride, load0, load1, load2, load3);
 316
 317         dst0 = (v16i8) __msa_fill_w(load0);
 318         dst1 = (v16i8) __msa_fill_w(load1);
 319         dst2 = (v16i8) __msa_fill_w(load2);
 320         dst3 = (v16i8) __msa_fill_w(load3);
 321
 322         XORI_B4_128_SB(src0, src1, src2, src3);
 323         XORI_B4_128_SB(dst0, dst1, dst2, dst3);
 324         ILVR_B4_SH(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
 325                    temp0, temp1, temp2, temp3);
 326
 327         temp0 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp0);
 328         temp1 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp1);
 329         temp2 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp2);
 330         temp3 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp3);
 331
 332         SRA_4V(temp0, temp1, temp2, temp3, denom);
 333         CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
 334         PCKEV_ST4x4_UB(temp0, temp1, temp2, temp3, dst, dst_stride);
 335         dst += (4 * dst_stride);
 336     }
 337 }
 338
 339 static void avc_biwgt_4width_msa(uint8_t *src, int32_t src_stride,
 340                                  uint8_t *dst, int32_t dst_stride,
 341                                  int32_t height, int32_t log2_denom,
 342                                  int32_t src_weight, int32_t dst_weight,
 343                                  int32_t offset_in)
 344 {
 345     if (2 == height) {
 346         avc_biwgt_4x2_msa(src, src_stride, dst, dst_stride, log2_denom,
 347                           src_weight, dst_weight, offset_in);
 348     } else {
 349         avc_biwgt_4x4multiple_msa(src, src_stride, dst, dst_stride, height,
 350                                   log2_denom, src_weight, dst_weight,
 351                                   offset_in);
 352     }
 353 }
 354
 355 static void avc_biwgt_8width_msa(uint8_t *src, int32_t src_stride,
 356                                  uint8_t *dst, int32_t dst_stride,
 357                                  int32_t height, int32_t log2_denom,
 358                                  int32_t src_weight, int32_t dst_weight,
 359                                  int32_t offset_in)
 360 {
 361     uint8_t cnt;
 362     v16i8 src_wgt, dst_wgt, wgt;
 363     v16i8 src0, src1, src2, src3;
 364     v16i8 dst0, dst1, dst2, dst3;
 365     v16i8 out0, out1;
 366     v8i16 temp0, temp1, temp2, temp3;
 367     v8i16 denom, offset, add_val;
 368     int32_t val = 128 * (src_weight + dst_weight);
 369
 370     offset_in = ((offset_in + 1) | 1) << log2_denom;
 371
 372     src_wgt = __msa_fill_b(src_weight);
 373     dst_wgt = __msa_fill_b(dst_weight);
 374     offset = __msa_fill_h(offset_in);
 375     denom = __msa_fill_h(log2_denom + 1);
 376     add_val = __msa_fill_h(val);
 377     offset += add_val;
 378
 379     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 380
 381     for (cnt = height / 4; cnt--;) {
 382         LD_SB4(src, src_stride, src0, src1, src2, src3);
 383         src += (4 * src_stride);
 384
 385         LD_SB4(dst, dst_stride, dst0, dst1, dst2, dst3);
 386         XORI_B4_128_SB(src0, src1, src2, src3);
 387         XORI_B4_128_SB(dst0, dst1, dst2, dst3);
 388         ILVR_B4_SH(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
 389                    temp0, temp1, temp2, temp3);
 390
 391         temp0 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp0);
 392         temp1 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp1);
 393         temp2 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp2);
 394         temp3 = __msa_dpadd_s_h(offset, wgt, (v16i8) temp3);
 395
 396         SRA_4V(temp0, temp1, temp2, temp3, denom);
 397         CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
 398         PCKEV_B2_SB(temp1, temp0, temp3, temp2, out0, out1);
 399         ST8x4_UB(out0, out1, dst, dst_stride);
 400         dst += 4 * dst_stride;
 401     }
 402 }
 403
 404 static void avc_biwgt_16width_msa(uint8_t *src, int32_t src_stride,
 405                                   uint8_t *dst, int32_t dst_stride,
 406                                   int32_t height, int32_t log2_denom,
 407                                   int32_t src_weight, int32_t dst_weight,
 408                                   int32_t offset_in)
 409 {
 410     uint8_t cnt;
 411     v16i8 src_wgt, dst_wgt, wgt;
 412     v16i8 src0, src1, src2, src3;
 413     v16i8 dst0, dst1, dst2, dst3;
 414     v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7;
 415     v8i16 temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
 416     v8i16 denom, offset, add_val;
 417     int32_t val = 128 * (src_weight + dst_weight);
 418
 419     offset_in = ((offset_in + 1) | 1) << log2_denom;
 420
 421     src_wgt = __msa_fill_b(src_weight);
 422     dst_wgt = __msa_fill_b(dst_weight);
 423     offset = __msa_fill_h(offset_in);
 424     denom = __msa_fill_h(log2_denom + 1);
 425     add_val = __msa_fill_h(val);
 426     offset += add_val;
 427
 428     wgt = __msa_ilvev_b(dst_wgt, src_wgt);
 429
 430     for (cnt = height / 4; cnt--;) {
 431         LD_SB4(src, src_stride, src0, src1, src2, src3);
 432         src += (4 * src_stride);
 433
 434         LD_SB4(dst, dst_stride, dst0, dst1, dst2, dst3);
 435         XORI_B4_128_SB(src0, src1, src2, src3);
 436         XORI_B4_128_SB(dst0, dst1, dst2, dst3);
 437         ILVR_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
 438                    vec0, vec2, vec4, vec6);
 439         ILVL_B4_SB(dst0, src0, dst1, src1, dst2, src2, dst3, src3,
 440                    vec1, vec3, vec5, vec7);
 441
 442         temp0 = __msa_dpadd_s_h(offset, wgt, vec0);
 443         temp1 = __msa_dpadd_s_h(offset, wgt, vec1);
 444         temp2 = __msa_dpadd_s_h(offset, wgt, vec2);
 445         temp3 = __msa_dpadd_s_h(offset, wgt, vec3);
 446         temp4 = __msa_dpadd_s_h(offset, wgt, vec4);
 447         temp5 = __msa_dpadd_s_h(offset, wgt, vec5);
 448         temp6 = __msa_dpadd_s_h(offset, wgt, vec6);
 449         temp7 = __msa_dpadd_s_h(offset, wgt, vec7);
 450
 451         SRA_4V(temp0, temp1, temp2, temp3, denom);
 452         SRA_4V(temp4, temp5, temp6, temp7, denom);
 453         CLIP_SH4_0_255(temp0, temp1, temp2, temp3);
 454         CLIP_SH4_0_255(temp4, temp5, temp6, temp7);
 455         PCKEV_B4_SB(temp1, temp0, temp3, temp2, temp5, temp4, temp7, temp6,
 456                     dst0, dst1, dst2, dst3);
 457         ST_SB4(dst0, dst1, dst2, dst3, dst, dst_stride);
 458         dst += 4 * dst_stride;
 459     }
 460 }
 461
 462 #define AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_or_q3_org_in, p0_or_q0_org_in,          \
 463                                  q3_or_p3_org_in, p1_or_q1_org_in,          \
 464                                  p2_or_q2_org_in, q1_or_p1_org_in,          \
 465                                  p0_or_q0_out, p1_or_q1_out, p2_or_q2_out)  \
 466 {                                                                           \
 467     v8i16 threshold;                                                        \
 468     v8i16 const3 = __msa_ldi_h(3);                                          \
 469                                                                             \
 470     threshold = (p0_or_q0_org_in) + (q3_or_p3_org_in);                      \
 471     threshold += (p1_or_q1_org_in);                                         \
 472                                                                             \
 473     (p0_or_q0_out) = threshold << 1;                                        \
 474     (p0_or_q0_out) += (p2_or_q2_org_in);                                    \
 475     (p0_or_q0_out) += (q1_or_p1_org_in);                                    \
 476     (p0_or_q0_out) = __msa_srari_h((p0_or_q0_out), 3);                      \
 477                                                                             \
 478     (p1_or_q1_out) = (p2_or_q2_org_in) + threshold;                         \
 479     (p1_or_q1_out) = __msa_srari_h((p1_or_q1_out), 2);                      \
 480                                                                             \
 481     (p2_or_q2_out) = (p2_or_q2_org_in) * const3;                            \
 482     (p2_or_q2_out) += (p3_or_q3_org_in);                                    \
 483     (p2_or_q2_out) += (p3_or_q3_org_in);                                    \
 484     (p2_or_q2_out) += threshold;                                            \
 485     (p2_or_q2_out) = __msa_srari_h((p2_or_q2_out), 3);                      \
 486 }
 487
 488 /* data[-u32_img_width] = (uint8_t)((2 * p1 + p0 + q1 + 2) >> 2); */
 489 #define AVC_LPF_P0_OR_Q0(p0_or_q0_org_in, q1_or_p1_org_in,   \
 490                          p1_or_q1_org_in, p0_or_q0_out)      \
 491 {                                                            \
 492     (p0_or_q0_out) = (p0_or_q0_org_in) + (q1_or_p1_org_in);  \
 493     (p0_or_q0_out) += (p1_or_q1_org_in);                     \
 494     (p0_or_q0_out) += (p1_or_q1_org_in);                     \
 495     (p0_or_q0_out) = __msa_srari_h((p0_or_q0_out), 2);       \
 496 }
 497
 498 #define AVC_LPF_P1_OR_Q1(p0_or_q0_org_in, q0_or_p0_org_in,    \
 499                          p1_or_q1_org_in, p2_or_q2_org_in,    \
 500                          negate_tc_in, tc_in, p1_or_q1_out)   \
 501 {                                                             \
 502     v8i16 clip3, temp;                                        \
 503                                                               \
 504     clip3 = (v8i16) __msa_aver_u_h((v8u16) p0_or_q0_org_in,   \
 505                                    (v8u16) q0_or_p0_org_in);  \
 506     temp = p1_or_q1_org_in << 1;                              \
 507     clip3 = clip3 - temp;                                     \
 508     clip3 = __msa_ave_s_h(p2_or_q2_org_in, clip3);            \
 509     clip3 = CLIP_SH(clip3, negate_tc_in, tc_in);              \
 510     p1_or_q1_out = p1_or_q1_org_in + clip3;                   \
 511 }
 512
 513 #define AVC_LPF_P0Q0(q0_or_p0_org_in, p0_or_q0_org_in,          \
 514                      p1_or_q1_org_in, q1_or_p1_org_in,          \
 515                      negate_threshold_in, threshold_in,         \
 516                      p0_or_q0_out, q0_or_p0_out)                \
 517 {                                                               \
 518     v8i16 q0_sub_p0, p1_sub_q1, delta;                          \
 519                                                                 \
 520     q0_sub_p0 = q0_or_p0_org_in - p0_or_q0_org_in;              \
 521     p1_sub_q1 = p1_or_q1_org_in - q1_or_p1_org_in;              \
 522     q0_sub_p0 <<= 2;                                            \
 523     p1_sub_q1 += 4;                                             \
 524     delta = q0_sub_p0 + p1_sub_q1;                              \
 525     delta >>= 3;                                                \
 526                                                                 \
 527     delta = CLIP_SH(delta, negate_threshold_in, threshold_in);  \
 528                                                                 \
 529     p0_or_q0_out = p0_or_q0_org_in + delta;                     \
 530     q0_or_p0_out = q0_or_p0_org_in - delta;                     \
 531                                                                 \
 532     CLIP_SH2_0_255(p0_or_q0_out, q0_or_p0_out);                 \
 533 }
 534
 535 #define AVC_LPF_H_CHROMA_422(src, stride, tc_val, alpha, beta, res)      \
 536 {                                                                        \
 537     uint32_t load0, load1, load2, load3;                                 \
 538     v16u8 src0 = { 0 };                                                  \
 539     v16u8 src1 = { 0 };                                                  \
 540     v16u8 src2 = { 0 };                                                  \
 541     v16u8 src3 = { 0 };                                                  \
 542     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;                            \
 543     v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;           \
 544     v8i16 tc, q0_sub_p0, p1_sub_q1, delta;                               \
 545     v8i16 res0_r, res1_r;                                                \
 546     v16i8 zeros = { 0 };                                                 \
 547     v16u8 res0, res1;                                                    \
 548                                                                          \
 549     LW4((src - 2), stride, load0, load1, load2, load3);                  \
 550     src0 = (v16u8) __msa_insert_w((v4i32) src0, 0, load0);               \
 551     src1 = (v16u8) __msa_insert_w((v4i32) src1, 0, load1);               \
 552     src2 = (v16u8) __msa_insert_w((v4i32) src2, 0, load2);               \
 553     src3 = (v16u8) __msa_insert_w((v4i32) src3, 0, load3);               \
 554                                                                          \
 555     TRANSPOSE4x4_UB_UB(src0, src1, src2, src3, src0, src1, src2, src3);  \
 556                                                                          \
 557     p0_asub_q0 = __msa_asub_u_b(src2, src1);                             \
 558     p1_asub_p0 = __msa_asub_u_b(src1, src0);                             \
 559     q1_asub_q0 = __msa_asub_u_b(src2, src3);                             \
 560                                                                          \
 561     tc = __msa_fill_h(tc_val);                                           \
 562                                                                          \
 563     is_less_than_alpha = (p0_asub_q0 < alpha);                           \
 564     is_less_than_beta = (p1_asub_p0 < beta);                             \
 565     is_less_than = is_less_than_alpha & is_less_than_beta;               \
 566     is_less_than_beta = (q1_asub_q0 < beta);                             \
 567     is_less_than = is_less_than_beta & is_less_than;                     \
 568                                                                          \
 569     ILVR_B2_SH(src2, src1, src0, src3, q0_sub_p0, p1_sub_q1);            \
 570     HSUB_UB2_SH(q0_sub_p0, p1_sub_q1, q0_sub_p0, p1_sub_q1);             \
 571                                                                          \
 572     q0_sub_p0 <<= 2;                                                     \
 573     delta = q0_sub_p0 + p1_sub_q1;                                       \
 574     delta = __msa_srari_h(delta, 3);                                     \
 575                                                                          \
 576     delta = CLIP_SH(delta, -tc, tc);                                     \
 577                                                                          \
 578     ILVR_B2_SH(zeros, src1, zeros, src2, res0_r, res1_r);                \
 579                                                                          \
 580     res0_r += delta;                                                     \
 581     res1_r -= delta;                                                     \
 582                                                                          \
 583     CLIP_SH2_0_255(res0_r, res1_r);                                      \
 584     PCKEV_B2_UB(res0_r, res0_r, res1_r, res1_r, res0, res1);             \
 585                                                                          \
 586     res0 = __msa_bmnz_v(src1, res0, is_less_than);                       \
 587     res1 = __msa_bmnz_v(src2, res1, is_less_than);                       \
 588                                                                          \
 589     res = (v16u8) __msa_ilvr_b((v16i8) res1, (v16i8) res0);              \
 590 }
 591
 592 #define TRANSPOSE2x4_B_UB(in0, in1, out0, out1, out2, out3)  \
 593 {                                                            \
 594     v16i8 zero_m = { 0 };                                    \
 595                                                              \
 596     out0 = (v16u8) __msa_ilvr_b((v16i8) in1, (v16i8) in0);   \
 597     out1 = (v16u8) __msa_sldi_b(zero_m, (v16i8) out0, 2);    \
 598     SLDI_B2_0_UB(out1, out2, out2, out3, 2);                 \
 599 }
 600
 601 #define AVC_LPF_H_2BYTE_CHROMA_422(src, stride, tc_val, alpha, beta, res)  \
 602 {                                                                          \
 603     uint32_t load0, load1;                                                 \
 604     v16u8 src0 = { 0 };                                                    \
 605     v16u8 src1 = { 0 };                                                    \
 606     v16u8 src2 = { 0 };                                                    \
 607     v16u8 src3 = { 0 };                                                    \
 608     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;                              \
 609     v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;             \
 610     v8i16 tc, q0_sub_p0, p1_sub_q1, delta, res0_r, res1_r;                 \
 611     v16i8 zeros = { 0 };                                                   \
 612     v16u8 res0, res1;                                                      \
 613                                                                            \
 614     load0 = LW(src - 2);                                                   \
 615     load1 = LW(src - 2 + stride);                                          \
 616                                                                            \
 617     src0 = (v16u8) __msa_insert_w((v4i32) src0, 0, load0);                 \
 618     src1 = (v16u8) __msa_insert_w((v4i32) src1, 0, load1);                 \
 619                                                                            \
 620     TRANSPOSE2x4_B_UB(src0, src1, src0, src1, src2, src3);                 \
 621                                                                            \
 622     p0_asub_q0 = __msa_asub_u_b(src2, src1);                               \
 623     p1_asub_p0 = __msa_asub_u_b(src1, src0);                               \
 624     q1_asub_q0 = __msa_asub_u_b(src2, src3);                               \
 625                                                                            \
 626     tc = __msa_fill_h(tc_val);                                             \
 627                                                                            \
 628     is_less_than_alpha = (p0_asub_q0 < alpha);                             \
 629     is_less_than_beta = (p1_asub_p0 < beta);                               \
 630     is_less_than = is_less_than_alpha & is_less_than_beta;                 \
 631     is_less_than_beta = (q1_asub_q0 < beta);                               \
 632     is_less_than = is_less_than_beta & is_less_than;                       \
 633                                                                            \
 634     ILVR_B2_SH(src2, src1, src0, src3, q0_sub_p0, p1_sub_q1);              \
 635     HSUB_UB2_SH(q0_sub_p0, p1_sub_q1, q0_sub_p0, p1_sub_q1);               \
 636                                                                            \
 637     q0_sub_p0 <<= 2;                                                       \
 638     delta = q0_sub_p0 + p1_sub_q1;                                         \
 639     delta = __msa_srari_h(delta, 3);                                       \
 640     delta = CLIP_SH(delta, -tc, tc);                                       \
 641                                                                            \
 642     ILVR_B2_SH(zeros, src1, zeros, src2, res0_r, res1_r);                  \
 643                                                                            \
 644     res0_r += delta;                                                       \
 645     res1_r -= delta;                                                       \
 646                                                                            \
 647     CLIP_SH2_0_255(res0_r, res1_r);                                        \
 648     PCKEV_B2_UB(res0_r, res0_r, res1_r, res1_r, res0, res1);               \
 649                                                                            \
 650     res0 = __msa_bmnz_v(src1, res0, is_less_than);                         \
 651     res1 = __msa_bmnz_v(src2, res1, is_less_than);                         \
 652                                                                            \
 653     res = (v16u8) __msa_ilvr_b((v16i8) res1, (v16i8) res0);                \
 654 }
 655
 656 static void avc_loopfilter_luma_intra_edge_hor_msa(uint8_t *data,
 657                                                    uint8_t alpha_in,
 658                                                    uint8_t beta_in,
 659                                                    uint32_t img_width)
 660 {
 661     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
 662     v16u8 is_less_than, is_less_than_beta, is_less_than_alpha;
 663     v16u8 p1_org, p0_org, q0_org, q1_org;
 664
 665     LD_UB4(data - (img_width << 1), img_width, p1_org, p0_org, q0_org, q1_org);
 666
 667     p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
 668     p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
 669     q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
 670
 671     is_less_than_alpha = (p0_asub_q0 < alpha_in);
 672     is_less_than_beta = (p1_asub_p0 < beta_in);
 673     is_less_than = is_less_than_beta & is_less_than_alpha;
 674     is_less_than_beta = (q1_asub_q0 < beta_in);
 675     is_less_than = is_less_than_beta & is_less_than;
 676
 677     if (!__msa_test_bz_v(is_less_than)) {
 678         v16u8 p2_asub_p0, q2_asub_q0, p0, q0, negate_is_less_than_beta;
 679         v8i16 p0_r = { 0 };
 680         v8i16 q0_r = { 0 };
 681         v8i16 p0_l = { 0 };
 682         v8i16 q0_l = { 0 };
 683         v16i8 zero = { 0 };
 684         v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
 685         v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
 686         v16u8 q2_org = LD_UB(data + (2 * img_width));
 687         v16u8 p2_org = LD_UB(data - (3 * img_width));
 688         v16u8 tmp_flag = (v16u8)__msa_fill_b((alpha_in >> 2) + 2);
 689
 690         UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
 691         UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
 692         UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
 693
 694         tmp_flag = (p0_asub_q0 < tmp_flag);
 695
 696         p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
 697         is_less_than_beta = (p2_asub_p0 < beta_in);
 698         is_less_than_beta = is_less_than_beta & tmp_flag;
 699         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
 700         is_less_than_beta = is_less_than_beta & is_less_than;
 701         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
 702
 703         q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
 704         q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
 705
 706         /* combine and store */
 707         if (!__msa_test_bz_v(is_less_than_beta)) {
 708             v8i16 p3_org_l, p3_org_r;
 709             v16u8 p3_org = LD_UB(data - (img_width << 2));
 710             v16u8 p2, p1;
 711             v8i16 p2_r = { 0 };
 712             v8i16 p2_l = { 0 };
 713             v8i16 p1_r = { 0 };
 714             v8i16 p1_l = { 0 };
 715
 716             ILVR_B2_SH(zero, p3_org, zero, p2_org, p3_org_r, p2_r);
 717             AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_r, p0_org_r, q0_org_r, p1_org_r,
 718                                      p2_r, q1_org_r, p0_r, p1_r, p2_r);
 719
 720             ILVL_B2_SH(zero, p3_org, zero, p2_org, p3_org_l, p2_l);
 721             AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_l, p0_org_l, q0_org_l, p1_org_l,
 722                                      p2_l, q1_org_l, p0_l, p1_l, p2_l);
 723
 724             PCKEV_B3_UB(p0_l, p0_r, p1_l, p1_r, p2_l, p2_r, p0, p1, p2);
 725
 726             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than_beta);
 727             p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
 728             p2_org = __msa_bmnz_v(p2_org, p2, is_less_than_beta);
 729
 730             ST_UB(p1_org, data - (2 * img_width));
 731             ST_UB(p2_org, data - (3 * img_width));
 732         }
 733
 734         AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_r);
 735         AVC_LPF_P0_OR_Q0(p0_org_l, q1_org_l, p1_org_l, p0_l);
 736
 737         /* combine */
 738         p0 = (v16u8) __msa_pckev_b((v16i8) p0_l, (v16i8) p0_r);
 739         p0_org = __msa_bmnz_v(p0_org, p0, negate_is_less_than_beta);
 740
 741         ST_UB(p0_org, data - img_width);
 742
 743         /* if (tmpFlag && (unsigned)ABS(q2-q0) < thresholds->beta_in) */
 744         q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
 745         is_less_than_beta = (q2_asub_q0 < beta_in);
 746         is_less_than_beta = is_less_than_beta & tmp_flag;
 747         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
 748         is_less_than_beta = is_less_than_beta & is_less_than;
 749         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
 750
 751         /* combine and store */
 752         if (!__msa_test_bz_v(is_less_than_beta)) {
 753             v8i16 q3_org_r, q3_org_l;
 754             v16u8 q3_org = LD_UB(data + (3 * img_width));
 755             v16u8 q1, q2;
 756             v8i16 q2_r = { 0 };
 757             v8i16 q2_l = { 0 };
 758             v8i16 q1_r = { 0 };
 759             v8i16 q1_l = { 0 };
 760
 761             ILVR_B2_SH(zero, q3_org, zero, q2_org, q3_org_r, q2_r);
 762             AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_r, q0_org_r, p0_org_r, q1_org_r,
 763                                      q2_r, p1_org_r, q0_r, q1_r, q2_r);
 764
 765             ILVL_B2_SH(zero, q3_org, zero, q2_org, q3_org_l, q2_l);
 766             AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_l, q0_org_l, p0_org_l, q1_org_l,
 767                                      q2_l, p1_org_l, q0_l, q1_l, q2_l);
 768
 769             PCKEV_B3_UB(q0_l, q0_r, q1_l, q1_r, q2_l, q2_r, q0, q1, q2);
 770             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than_beta);
 771             q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
 772             q2_org = __msa_bmnz_v(q2_org, q2, is_less_than_beta);
 773
 774             ST_UB(q1_org, data + img_width);
 775             ST_UB(q2_org, data + 2 * img_width);
 776         }
 777
 778         AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_r);
 779         AVC_LPF_P0_OR_Q0(q0_org_l, p1_org_l, q1_org_l, q0_l);
 780
 781         /* combine */
 782         q0 = (v16u8) __msa_pckev_b((v16i8) q0_l, (v16i8) q0_r);
 783         q0_org = __msa_bmnz_v(q0_org, q0, negate_is_less_than_beta);
 784
 785         ST_UB(q0_org, data);
 786     }
 787 }
 788
 789 static void avc_loopfilter_luma_intra_edge_ver_msa(uint8_t *data,
 790                                                    uint8_t alpha_in,
 791                                                    uint8_t beta_in,
 792                                                    uint32_t img_width)
 793 {
 794     uint8_t *src = data - 4;
 795     v16u8 alpha, beta, p0_asub_q0;
 796     v16u8 is_less_than_alpha, is_less_than, is_less_than_beta;
 797     v16u8 p3_org, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org, q3_org;
 798     v16u8 p1_asub_p0, q1_asub_q0;
 799
 800
 801     {
 802         v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
 803         v16u8 row8, row9, row10, row11, row12, row13, row14, row15;
 804
 805         LD_UB8(src, img_width, row0, row1, row2, row3, row4, row5, row6, row7);
 806         LD_UB8(src + (8 * img_width), img_width,
 807                row8, row9, row10, row11, row12, row13, row14, row15);
 808
 809         TRANSPOSE16x8_UB_UB(row0, row1, row2, row3,
 810                             row4, row5, row6, row7,
 811                             row8, row9, row10, row11,
 812                             row12, row13, row14, row15,
 813                             p3_org, p2_org, p1_org, p0_org,
 814                             q0_org, q1_org, q2_org, q3_org);
 815     }
 816
 817     p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
 818     p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
 819     q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
 820
 821     alpha = (v16u8) __msa_fill_b(alpha_in);
 822     beta = (v16u8) __msa_fill_b(beta_in);
 823
 824     is_less_than_alpha = (p0_asub_q0 < alpha);
 825     is_less_than_beta = (p1_asub_p0 < beta);
 826     is_less_than = is_less_than_beta & is_less_than_alpha;
 827     is_less_than_beta = (q1_asub_q0 < beta);
 828     is_less_than = is_less_than_beta & is_less_than;
 829
 830     if (!__msa_test_bz_v(is_less_than)) {
 831         v8i16 p0_r = { 0 };
 832         v8i16 q0_r = { 0 };
 833         v8i16 p0_l = { 0 };
 834         v8i16 q0_l = { 0 };
 835         v16i8 zero = { 0 };
 836         v16u8 tmp_flag, p0, q0, p2_asub_p0, q2_asub_q0;
 837         v16u8 negate_is_less_than_beta;
 838         v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
 839         v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
 840
 841         UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
 842         UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
 843         UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
 844         UNPCK_UB_SH(q1_org, q1_org_r, q1_org_l);
 845
 846         tmp_flag = alpha >> 2;
 847         tmp_flag = tmp_flag + 2;
 848         tmp_flag = (p0_asub_q0 < tmp_flag);
 849
 850         p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
 851         is_less_than_beta = (p2_asub_p0 < beta);
 852         is_less_than_beta = tmp_flag & is_less_than_beta;
 853         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
 854         is_less_than_beta = is_less_than_beta & is_less_than;
 855         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
 856
 857         if (!__msa_test_bz_v(is_less_than_beta)) {
 858             v16u8 p2, p1;
 859             v8i16 p3_org_r, p3_org_l;
 860             v8i16 p2_l = { 0 };
 861             v8i16 p2_r = { 0 };
 862             v8i16 p1_l = { 0 };
 863             v8i16 p1_r = { 0 };
 864
 865             ILVR_B2_SH(zero, p3_org, zero, p2_org, p3_org_r, p2_r);
 866             AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_r, p0_org_r, q0_org_r, p1_org_r,
 867                                      p2_r, q1_org_r, p0_r, p1_r, p2_r);
 868
 869             ILVL_B2_SH(zero, p3_org, zero, p2_org, p3_org_l, p2_l);
 870             AVC_LPF_P0P1P2_OR_Q0Q1Q2(p3_org_l, p0_org_l, q0_org_l, p1_org_l,
 871                                          p2_l, q1_org_l, p0_l, p1_l, p2_l);
 872
 873             PCKEV_B3_UB(p0_l, p0_r, p1_l, p1_r, p2_l, p2_r, p0, p1, p2);
 874             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than_beta);
 875             p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
 876             p2_org = __msa_bmnz_v(p2_org, p2, is_less_than_beta);
 877         }
 878
 879         AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_r);
 880         AVC_LPF_P0_OR_Q0(p0_org_l, q1_org_l, p1_org_l, p0_l);
 881
 882         p0 = (v16u8) __msa_pckev_b((v16i8) p0_l, (v16i8) p0_r);
 883         p0_org = __msa_bmnz_v(p0_org, p0, negate_is_less_than_beta);
 884
 885         q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
 886         is_less_than_beta = (q2_asub_q0 < beta);
 887
 888         is_less_than_beta = is_less_than_beta & tmp_flag;
 889         negate_is_less_than_beta = __msa_xori_b(is_less_than_beta, 0xff);
 890
 891         is_less_than_beta = is_less_than_beta & is_less_than;
 892         negate_is_less_than_beta = negate_is_less_than_beta & is_less_than;
 893
 894         if (!__msa_test_bz_v(is_less_than_beta)) {
 895             v16u8 q1, q2;
 896             v8i16 q3_org_r, q3_org_l;
 897             v8i16 q1_l = { 0 };
 898             v8i16 q1_r = { 0 };
 899             v8i16 q2_l = { 0 };
 900             v8i16 q2_r = { 0 };
 901
 902             ILVR_B2_SH(zero, q3_org, zero, q2_org, q3_org_r, q2_r);
 903             AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_r, q0_org_r, p0_org_r, q1_org_r,
 904                                      q2_r, p1_org_r, q0_r, q1_r, q2_r);
 905
 906             ILVL_B2_SH(zero, q3_org, zero, q2_org, q3_org_l, q2_l);
 907             AVC_LPF_P0P1P2_OR_Q0Q1Q2(q3_org_l, q0_org_l, p0_org_l, q1_org_l,
 908                                      q2_l, p1_org_l, q0_l, q1_l, q2_l);
 909
 910             PCKEV_B3_UB(q0_l, q0_r, q1_l, q1_r, q2_l, q2_r, q0, q1, q2);
 911             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than_beta);
 912             q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
 913             q2_org = __msa_bmnz_v(q2_org, q2, is_less_than_beta);
 914         }
 915
 916         AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_r);
 917         AVC_LPF_P0_OR_Q0(q0_org_l, p1_org_l, q1_org_l, q0_l);
 918
 919         q0 = (v16u8) __msa_pckev_b((v16i8) q0_l, (v16i8) q0_r);
 920         q0_org = __msa_bmnz_v(q0_org, q0, negate_is_less_than_beta);
 921
 922     {
 923         v8i16 tp0, tp1, tp2, tp3, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
 924
 925         ILVRL_B2_SH(p1_org, p2_org, tp0, tp2);
 926         ILVRL_B2_SH(q0_org, p0_org, tp1, tp3);
 927         ILVRL_B2_SH(q2_org, q1_org, tmp2, tmp5);
 928
 929         ILVRL_H2_SH(tp1, tp0, tmp3, tmp4);
 930         ILVRL_H2_SH(tp3, tp2, tmp6, tmp7);
 931
 932         src = data - 3;
 933         ST4x4_UB(tmp3, tmp3, 0, 1, 2, 3, src, img_width);
 934         ST2x4_UB(tmp2, 0, src + 4, img_width);
 935         src += 4 * img_width;
 936         ST4x4_UB(tmp4, tmp4, 0, 1, 2, 3, src, img_width);
 937         ST2x4_UB(tmp2, 4, src + 4, img_width);
 938         src += 4 * img_width;
 939
 940         ST4x4_UB(tmp6, tmp6, 0, 1, 2, 3, src, img_width);
 941         ST2x4_UB(tmp5, 0, src + 4, img_width);
 942         src += 4 * img_width;
 943         ST4x4_UB(tmp7, tmp7, 0, 1, 2, 3, src, img_width);
 944         ST2x4_UB(tmp5, 4, src + 4, img_width);
 945     }
 946     }
 947 }
 948
 949 static void avc_h_loop_filter_luma_mbaff_intra_msa(uint8_t *src, int32_t stride,
 950                                                    int32_t alpha_in,
 951                                                    int32_t beta_in)
 952 {
 953     uint64_t load0, load1;
 954     uint32_t out0, out2;
 955     uint16_t out1, out3;
 956     v8u16 src0_r, src1_r, src2_r, src3_r, src4_r, src5_r, src6_r, src7_r;
 957     v8u16 dst0_r, dst1_r, dst4_r, dst5_r;
 958     v8u16 dst2_x_r, dst2_y_r, dst3_x_r, dst3_y_r;
 959     v16u8 dst0, dst1, dst4, dst5, dst2_x, dst2_y, dst3_x, dst3_y;
 960     v8i16 tmp0, tmp1, tmp2, tmp3;
 961     v16u8 alpha, beta;
 962     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, p2_asub_p0, q2_asub_q0;
 963     v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;
 964     v16u8 is_less_than_beta1, is_less_than_beta2;
 965     v16i8 src0 = { 0 };
 966     v16i8 src1 = { 0 };
 967     v16i8 src2 = { 0 };
 968     v16i8 src3 = { 0 };
 969     v16i8 src4 = { 0 };
 970     v16i8 src5 = { 0 };
 971     v16i8 src6 = { 0 };
 972     v16i8 src7 = { 0 };
 973     v16i8 zeros = { 0 };
 974
 975     load0 = LD(src - 4);
 976     load1 = LD(src + stride - 4);
 977     src0 = (v16i8) __msa_insert_d((v2i64) src0, 0, load0);
 978     src1 = (v16i8) __msa_insert_d((v2i64) src1, 0, load1);
 979
 980     load0 = LD(src + (2 * stride) - 4);
 981     load1 = LD(src + (3 * stride) - 4);
 982     src2 = (v16i8) __msa_insert_d((v2i64) src2, 0, load0);
 983     src3 = (v16i8) __msa_insert_d((v2i64) src3, 0, load1);
 984
 985     load0 = LD(src + (4 * stride) - 4);
 986     load1 = LD(src + (5 * stride) - 4);
 987     src4 = (v16i8) __msa_insert_d((v2i64) src4, 0, load0);
 988     src5 = (v16i8) __msa_insert_d((v2i64) src5, 0, load1);
 989
 990     load0 = LD(src + (6 * stride) - 4);
 991     load1 = LD(src + (7 * stride) - 4);
 992     src6 = (v16i8) __msa_insert_d((v2i64) src6, 0, load0);
 993     src7 = (v16i8) __msa_insert_d((v2i64) src7, 0, load1);
 994
 995     ILVR_B4_SB(src1, src0, src3, src2, src5, src4, src7, src6,
 996                src0, src1, src2, src3);
 997
 998     ILVR_H2_SH(src1, src0, src3, src2, tmp0, tmp2);
 999     ILVL_H2_SH(src1, src0, src3, src2, tmp1, tmp3);
1000
1001     ILVR_W2_SB(tmp2, tmp0, tmp3, tmp1, src6, src3);
1002     ILVL_W2_SB(tmp2, tmp0, tmp3, tmp1, src1, src5);
1003     SLDI_B4_0_SB(src6, src1, src3, src5, src0, src2, src4, src7, 8);
1004
1005     p0_asub_q0 = __msa_asub_u_b((v16u8) src2, (v16u8) src3);
1006     p1_asub_p0 = __msa_asub_u_b((v16u8) src1, (v16u8) src2);
1007     q1_asub_q0 = __msa_asub_u_b((v16u8) src4, (v16u8) src3);
1008
1009     alpha = (v16u8) __msa_fill_b(alpha_in);
1010     beta = (v16u8) __msa_fill_b(beta_in);
1011
1012     is_less_than_alpha = (p0_asub_q0 < alpha);
1013     is_less_than_beta = (p1_asub_p0 < beta);
1014     is_less_than = is_less_than_alpha & is_less_than_beta;
1015     is_less_than_beta = (q1_asub_q0 < beta);
1016     is_less_than = is_less_than & is_less_than_beta;
1017
1018     alpha >>= 2;
1019     alpha += 2;
1020
1021     is_less_than_alpha = (p0_asub_q0 < alpha);
1022
1023     p2_asub_p0 = __msa_asub_u_b((v16u8) src0, (v16u8) src2);
1024     is_less_than_beta1 = (p2_asub_p0 < beta);
1025     q2_asub_q0 = __msa_asub_u_b((v16u8) src5, (v16u8) src3);
1026     is_less_than_beta2 = (q2_asub_q0 < beta);
1027
1028     ILVR_B4_UH(zeros, src0, zeros, src1, zeros, src2, zeros, src3,
1029                src0_r, src1_r, src2_r, src3_r);
1030     ILVR_B4_UH(zeros, src4, zeros, src5, zeros, src6, zeros, src7,
1031                src4_r, src5_r, src6_r, src7_r);
1032
1033     dst2_x_r = src1_r + src2_r + src3_r;
1034     dst2_x_r = src0_r + (2 * (dst2_x_r)) + src4_r;
1035     dst2_x_r = (v8u16) __msa_srari_h((v8i16) dst2_x_r, 3);
1036     dst1_r = src0_r + src1_r + src2_r + src3_r;
1037     dst1_r = (v8u16) __msa_srari_h((v8i16) dst1_r, 2);
1038
1039     dst0_r = (2 * src6_r) + (3 * src0_r);
1040     dst0_r += src1_r + src2_r + src3_r;
1041     dst0_r = (v8u16) __msa_srari_h((v8i16) dst0_r, 3);
1042     dst2_y_r = (2 * src1_r) + src2_r + src4_r;
1043     dst2_y_r = (v8u16) __msa_srari_h((v8i16) dst2_y_r, 2);
1044
1045     PCKEV_B2_UB(dst2_x_r, dst2_x_r, dst2_y_r, dst2_y_r, dst2_x, dst2_y);
1046     dst2_x = __msa_bmnz_v(dst2_y, dst2_x, is_less_than_beta1);
1047
1048     dst3_x_r = src2_r + src3_r + src4_r;
1049     dst3_x_r = src1_r + (2 * dst3_x_r) + src5_r;
1050     dst3_x_r = (v8u16) __msa_srari_h((v8i16) dst3_x_r, 3);
1051     dst4_r = src2_r + src3_r + src4_r + src5_r;
1052     dst4_r = (v8u16) __msa_srari_h((v8i16) dst4_r, 2);
1053
1054     dst5_r = (2 * src7_r) + (3 * src5_r);
1055     dst5_r += src4_r + src3_r + src2_r;
1056     dst5_r = (v8u16) __msa_srari_h((v8i16) dst5_r, 3);
1057     dst3_y_r = (2 * src4_r) + src3_r + src1_r;
1058     dst3_y_r = (v8u16) __msa_srari_h((v8i16) dst3_y_r, 2);
1059
1060     PCKEV_B2_UB(dst3_x_r, dst3_x_r, dst3_y_r, dst3_y_r, dst3_x, dst3_y);
1061     dst3_x = __msa_bmnz_v(dst3_y, dst3_x, is_less_than_beta2);
1062
1063     dst2_y_r = (2 * src1_r) + src2_r + src4_r;
1064     dst2_y_r = (v8u16) __msa_srari_h((v8i16) dst2_y_r, 2);
1065     dst3_y_r = (2 * src4_r) + src3_r + src1_r;
1066     dst3_y_r = (v8u16) __msa_srari_h((v8i16) dst3_y_r, 2);
1067
1068     PCKEV_B2_UB(dst2_y_r, dst2_y_r, dst3_y_r, dst3_y_r, dst2_y, dst3_y);
1069
1070     dst2_x = __msa_bmnz_v(dst2_y, dst2_x, is_less_than_alpha);
1071     dst3_x = __msa_bmnz_v(dst3_y, dst3_x, is_less_than_alpha);
1072     dst2_x = __msa_bmnz_v((v16u8) src2, dst2_x, is_less_than);
1073     dst3_x = __msa_bmnz_v((v16u8) src3, dst3_x, is_less_than);
1074
1075     is_less_than = is_less_than_alpha & is_less_than;
1076     dst1 = (v16u8) __msa_pckev_b((v16i8) dst1_r, (v16i8) dst1_r);
1077     is_less_than_beta1 = is_less_than_beta1 & is_less_than;
1078     dst1 = __msa_bmnz_v((v16u8) src1, dst1, is_less_than_beta1);
1079
1080     dst0 = (v16u8) __msa_pckev_b((v16i8) dst0_r, (v16i8) dst0_r);
1081     dst0 = __msa_bmnz_v((v16u8) src0, dst0, is_less_than_beta1);
1082     dst4 = (v16u8) __msa_pckev_b((v16i8) dst4_r, (v16i8) dst4_r);
1083     is_less_than_beta2 = is_less_than_beta2 & is_less_than;
1084     dst4 = __msa_bmnz_v((v16u8) src4, dst4, is_less_than_beta2);
1085     dst5 = (v16u8) __msa_pckev_b((v16i8) dst5_r, (v16i8) dst5_r);
1086     dst5 = __msa_bmnz_v((v16u8) src5, dst5, is_less_than_beta2);
1087
1088     ILVR_B2_UB(dst1, dst0, dst3_x, dst2_x, dst0, dst1);
1089     dst2_x = (v16u8) __msa_ilvr_b((v16i8) dst5, (v16i8) dst4);
1090     ILVRL_H2_SH(dst1, dst0, tmp0, tmp1);
1091     ILVRL_H2_SH(zeros, dst2_x, tmp2, tmp3);
1092
1093     ILVR_W2_UB(tmp2, tmp0, tmp3, tmp1, dst0, dst4);
1094     SLDI_B2_0_UB(dst0, dst4, dst1, dst5, 8);
1095     dst2_x = (v16u8) __msa_ilvl_w((v4i32) tmp2, (v4i32) tmp0);
1096     dst2_y = (v16u8) __msa_ilvl_w((v4i32) tmp3, (v4i32) tmp1);
1097     SLDI_B2_0_UB(dst2_x, dst2_y, dst3_x, dst3_y, 8);
1098
1099     out0 = __msa_copy_u_w((v4i32) dst0, 0);
1100     out1 = __msa_copy_u_h((v8i16) dst0, 2);
1101     out2 = __msa_copy_u_w((v4i32) dst1, 0);
1102     out3 = __msa_copy_u_h((v8i16) dst1, 2);
1103
1104     SW(out0, (src - 3));
1105     SH(out1, (src + 1));
1106     src += stride;
1107     SW(out2, (src - 3));
1108     SH(out3, (src + 1));
1109     src += stride;
1110
1111     out0 = __msa_copy_u_w((v4i32) dst2_x, 0);
1112     out1 = __msa_copy_u_h((v8i16) dst2_x, 2);
1113     out2 = __msa_copy_u_w((v4i32) dst3_x, 0);
1114     out3 = __msa_copy_u_h((v8i16) dst3_x, 2);
1115
1116     SW(out0, (src - 3));
1117     SH(out1, (src + 1));
1118     src += stride;
1119     SW(out2, (src - 3));
1120     SH(out3, (src + 1));
1121     src += stride;
1122
1123     out0 = __msa_copy_u_w((v4i32) dst4, 0);
1124     out1 = __msa_copy_u_h((v8i16) dst4, 2);
1125     out2 = __msa_copy_u_w((v4i32) dst5, 0);
1126     out3 = __msa_copy_u_h((v8i16) dst5, 2);
1127
1128     SW(out0, (src - 3));
1129     SH(out1, (src + 1));
1130     src += stride;
1131     SW(out2, (src - 3));
1132     SH(out3, (src + 1));
1133     src += stride;
1134
1135     out0 = __msa_copy_u_w((v4i32) dst2_y, 0);
1136     out1 = __msa_copy_u_h((v8i16) dst2_y, 2);
1137     out2 = __msa_copy_u_w((v4i32) dst3_y, 0);
1138     out3 = __msa_copy_u_h((v8i16) dst3_y, 2);
1139
1140     SW(out0, (src - 3));
1141     SH(out1, (src + 1));
1142     src += stride;
1143     SW(out2, (src - 3));
1144     SH(out3, (src + 1));
1145 }
1146
1147 static void avc_loopfilter_cb_or_cr_intra_edge_hor_msa(uint8_t *data_cb_or_cr,
1148                                                        uint8_t alpha_in,
1149                                                        uint8_t beta_in,
1150                                                        uint32_t img_width)
1151 {
1152     v16u8 alpha, beta;
1153     v16u8 is_less_than;
1154     v8i16 p0_or_q0, q0_or_p0;
1155     v16u8 p1_or_q1_org, p0_or_q0_org, q0_or_p0_org, q1_or_p1_org;
1156     v16i8 zero = { 0 };
1157     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
1158     v16u8 is_less_than_alpha, is_less_than_beta;
1159     v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1160
1161     alpha = (v16u8) __msa_fill_b(alpha_in);
1162     beta = (v16u8) __msa_fill_b(beta_in);
1163
1164     LD_UB4(data_cb_or_cr - (img_width << 1), img_width,
1165            p1_or_q1_org, p0_or_q0_org, q0_or_p0_org, q1_or_p1_org);
1166
1167     p0_asub_q0 = __msa_asub_u_b(p0_or_q0_org, q0_or_p0_org);
1168     p1_asub_p0 = __msa_asub_u_b(p1_or_q1_org, p0_or_q0_org);
1169     q1_asub_q0 = __msa_asub_u_b(q1_or_p1_org, q0_or_p0_org);
1170
1171     is_less_than_alpha = (p0_asub_q0 < alpha);
1172     is_less_than_beta = (p1_asub_p0 < beta);
1173     is_less_than = is_less_than_beta & is_less_than_alpha;
1174     is_less_than_beta = (q1_asub_q0 < beta);
1175     is_less_than = is_less_than_beta & is_less_than;
1176
1177     is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);
1178
1179     if (!__msa_test_bz_v(is_less_than)) {
1180         ILVR_B4_SH(zero, p1_or_q1_org, zero, p0_or_q0_org, zero, q0_or_p0_org,
1181                    zero, q1_or_p1_org, p1_org_r, p0_org_r, q0_org_r, q1_org_r);
1182         AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_or_q0);
1183         AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_or_p0);
1184         PCKEV_B2_SH(zero, p0_or_q0, zero, q0_or_p0, p0_or_q0, q0_or_p0);
1185
1186         p0_or_q0_org =
1187             __msa_bmnz_v(p0_or_q0_org, (v16u8) p0_or_q0, is_less_than);
1188         q0_or_p0_org =
1189             __msa_bmnz_v(q0_or_p0_org, (v16u8) q0_or_p0, is_less_than);
1190
1191         ST_UB(q0_or_p0_org, data_cb_or_cr);
1192         ST_UB(p0_or_q0_org, data_cb_or_cr - img_width);
1193     }
1194 }
1195
1196 static void avc_loopfilter_cb_or_cr_intra_edge_ver_msa(uint8_t *data_cb_or_cr,
1197                                                        uint8_t alpha_in,
1198                                                        uint8_t beta_in,
1199                                                        uint32_t img_width)
1200 {
1201     v8i16 tmp1;
1202     v16u8 alpha, beta, is_less_than;
1203     v8i16 p0_or_q0, q0_or_p0;
1204     v16u8 p1_or_q1_org, p0_or_q0_org, q0_or_p0_org, q1_or_p1_org;
1205     v16i8 zero = { 0 };
1206     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
1207     v16u8 is_less_than_alpha, is_less_than_beta;
1208     v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1209
1210     {
1211         v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
1212
1213         LD_UB8((data_cb_or_cr - 2), img_width,
1214                row0, row1, row2, row3, row4, row5, row6, row7);
1215
1216         TRANSPOSE8x4_UB_UB(row0, row1, row2, row3, row4, row5, row6, row7,
1217                            p1_or_q1_org, p0_or_q0_org,
1218                            q0_or_p0_org, q1_or_p1_org);
1219     }
1220
1221     alpha = (v16u8) __msa_fill_b(alpha_in);
1222     beta = (v16u8) __msa_fill_b(beta_in);
1223
1224     p0_asub_q0 = __msa_asub_u_b(p0_or_q0_org, q0_or_p0_org);
1225     p1_asub_p0 = __msa_asub_u_b(p1_or_q1_org, p0_or_q0_org);
1226     q1_asub_q0 = __msa_asub_u_b(q1_or_p1_org, q0_or_p0_org);
1227
1228     is_less_than_alpha = (p0_asub_q0 < alpha);
1229     is_less_than_beta = (p1_asub_p0 < beta);
1230     is_less_than = is_less_than_beta & is_less_than_alpha;
1231     is_less_than_beta = (q1_asub_q0 < beta);
1232     is_less_than = is_less_than_beta & is_less_than;
1233     is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);
1234
1235     if (!__msa_test_bz_v(is_less_than)) {
1236         ILVR_B4_SH(zero, p1_or_q1_org, zero, p0_or_q0_org, zero, q0_or_p0_org,
1237                    zero, q1_or_p1_org, p1_org_r, p0_org_r, q0_org_r, q1_org_r);
1238
1239         AVC_LPF_P0_OR_Q0(p0_org_r, q1_org_r, p1_org_r, p0_or_q0);
1240         AVC_LPF_P0_OR_Q0(q0_org_r, p1_org_r, q1_org_r, q0_or_p0);
1241
1242         /* convert 16 bit output into 8 bit output */
1243         PCKEV_B2_SH(zero, p0_or_q0, zero, q0_or_p0, p0_or_q0, q0_or_p0);
1244
1245         p0_or_q0_org =
1246             __msa_bmnz_v(p0_or_q0_org, (v16u8) p0_or_q0, is_less_than);
1247         q0_or_p0_org =
1248             __msa_bmnz_v(q0_or_p0_org, (v16u8) q0_or_p0, is_less_than);
1249         tmp1 = (v8i16) __msa_ilvr_b((v16i8) q0_or_p0_org, (v16i8) p0_or_q0_org);
1250
1251         data_cb_or_cr -= 1;
1252         ST2x4_UB(tmp1, 0, data_cb_or_cr, img_width);
1253         data_cb_or_cr += 4 * img_width;
1254         ST2x4_UB(tmp1, 4, data_cb_or_cr, img_width);
1255     }
1256 }
1257
1258 static void avc_loopfilter_luma_inter_edge_ver_msa(uint8_t *data,
1259                                                    uint8_t bs0, uint8_t bs1,
1260                                                    uint8_t bs2, uint8_t bs3,
1261                                                    uint8_t tc0, uint8_t tc1,
1262                                                    uint8_t tc2, uint8_t tc3,
1263                                                    uint8_t alpha_in,
1264                                                    uint8_t beta_in,
1265                                                    uint32_t img_width)
1266 {
1267     v16u8 tmp_vec, bs = { 0 };
1268
1269     tmp_vec = (v16u8) __msa_fill_b(bs0);
1270     bs = (v16u8) __msa_insve_w((v4i32) bs, 0, (v4i32) tmp_vec);
1271     tmp_vec = (v16u8) __msa_fill_b(bs1);
1272     bs = (v16u8) __msa_insve_w((v4i32) bs, 1, (v4i32) tmp_vec);
1273     tmp_vec = (v16u8) __msa_fill_b(bs2);
1274     bs = (v16u8) __msa_insve_w((v4i32) bs, 2, (v4i32) tmp_vec);
1275     tmp_vec = (v16u8) __msa_fill_b(bs3);
1276     bs = (v16u8) __msa_insve_w((v4i32) bs, 3, (v4i32) tmp_vec);
1277
1278     if (!__msa_test_bz_v(bs)) {
1279         uint8_t *src = data - 4;
1280         v16u8 p3_org, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org, q3_org;
1281         v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, alpha, beta;
1282         v16u8 is_less_than, is_less_than_beta, is_less_than_alpha;
1283         v16u8 is_bs_greater_than0;
1284         v16u8 tc = { 0 };
1285         v16i8 zero = { 0 };
1286
1287         tmp_vec = (v16u8) __msa_fill_b(tc0);
1288         tc = (v16u8) __msa_insve_w((v4i32) tc, 0, (v4i32) tmp_vec);
1289         tmp_vec = (v16u8) __msa_fill_b(tc1);
1290         tc = (v16u8) __msa_insve_w((v4i32) tc, 1, (v4i32) tmp_vec);
1291         tmp_vec = (v16u8) __msa_fill_b(tc2);
1292         tc = (v16u8) __msa_insve_w((v4i32) tc, 2, (v4i32) tmp_vec);
1293         tmp_vec = (v16u8) __msa_fill_b(tc3);
1294         tc = (v16u8) __msa_insve_w((v4i32) tc, 3, (v4i32) tmp_vec);
1295
1296         is_bs_greater_than0 = (zero < bs);
1297
1298         {
1299             v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
1300             v16u8 row8, row9, row10, row11, row12, row13, row14, row15;
1301
1302             LD_UB8(src, img_width,
1303                    row0, row1, row2, row3, row4, row5, row6, row7);
1304             src += (8 * img_width);
1305             LD_UB8(src, img_width,
1306                    row8, row9, row10, row11, row12, row13, row14, row15);
1307
1308             TRANSPOSE16x8_UB_UB(row0, row1, row2, row3, row4, row5, row6, row7,
1309                                 row8, row9, row10, row11,
1310                                 row12, row13, row14, row15,
1311                                 p3_org, p2_org, p1_org, p0_org,
1312                                 q0_org, q1_org, q2_org, q3_org);
1313         }
1314
1315         p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
1316         p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
1317         q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
1318
1319         alpha = (v16u8) __msa_fill_b(alpha_in);
1320         beta = (v16u8) __msa_fill_b(beta_in);
1321
1322         is_less_than_alpha = (p0_asub_q0 < alpha);
1323         is_less_than_beta = (p1_asub_p0 < beta);
1324         is_less_than = is_less_than_beta & is_less_than_alpha;
1325         is_less_than_beta = (q1_asub_q0 < beta);
1326         is_less_than = is_less_than_beta & is_less_than;
1327         is_less_than = is_less_than & is_bs_greater_than0;
1328
1329         if (!__msa_test_bz_v(is_less_than)) {
1330             v16i8 negate_tc, sign_negate_tc;
1331             v16u8 p0, q0, p2_asub_p0, q2_asub_q0;
1332             v8i16 tc_r, tc_l, negate_tc_r, i16_negatetc_l;
1333             v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1334             v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
1335             v8i16 p0_r, q0_r, p0_l, q0_l;
1336
1337             negate_tc = zero - (v16i8) tc;
1338             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
1339
1340             ILVRL_B2_SH(sign_negate_tc, negate_tc, negate_tc_r, i16_negatetc_l);
1341
1342             UNPCK_UB_SH(tc, tc_r, tc_l);
1343             UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
1344             UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
1345             UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
1346
1347             p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
1348             is_less_than_beta = (p2_asub_p0 < beta);
1349             is_less_than_beta = is_less_than_beta & is_less_than;
1350
1351             if (!__msa_test_bz_v(is_less_than_beta)) {
1352                 v16u8 p1;
1353                 v8i16 p1_r = { 0 };
1354                 v8i16 p1_l = { 0 };
1355                 v8i16 p2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p2_org);
1356                 v8i16 p2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) p2_org);
1357
1358                 AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, p1_org_r, p2_org_r,
1359                                  negate_tc_r, tc_r, p1_r);
1360                 AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, p1_org_l, p2_org_l,
1361                                  i16_negatetc_l, tc_l, p1_l);
1362
1363                 p1 = (v16u8) __msa_pckev_b((v16i8) p1_l, (v16i8) p1_r);
1364                 p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
1365
1366                 is_less_than_beta = __msa_andi_b(is_less_than_beta, 1);
1367                 tc = tc + is_less_than_beta;
1368             }
1369
1370             q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
1371             is_less_than_beta = (q2_asub_q0 < beta);
1372             is_less_than_beta = is_less_than_beta & is_less_than;
1373
1374             q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
1375             q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
1376
1377             if (!__msa_test_bz_v(is_less_than_beta)) {
1378                 v16u8 q1;
1379                 v8i16 q1_r = { 0 };
1380                 v8i16 q1_l = { 0 };
1381                 v8i16 q2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q2_org);
1382                 v8i16 q2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q2_org);
1383
1384                 AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, q1_org_r, q2_org_r,
1385                                  negate_tc_r, tc_r, q1_r);
1386                 AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, q1_org_l, q2_org_l,
1387                                  i16_negatetc_l, tc_l, q1_l);
1388
1389                 q1 = (v16u8) __msa_pckev_b((v16i8) q1_l, (v16i8) q1_r);
1390                 q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
1391
1392                 is_less_than_beta = __msa_andi_b(is_less_than_beta, 1);
1393                 tc = tc + is_less_than_beta;
1394             }
1395
1396             {
1397                 v8i16 threshold_r, negate_thresh_r;
1398                 v8i16 threshold_l, negate_thresh_l;
1399                 v16i8 negate_thresh, sign_negate_thresh;
1400
1401                 negate_thresh = zero - (v16i8) tc;
1402                 sign_negate_thresh = __msa_clti_s_b(negate_thresh, 0);
1403
1404                 ILVR_B2_SH(zero, tc, sign_negate_thresh, negate_thresh,
1405                            threshold_r, negate_thresh_r);
1406
1407                 AVC_LPF_P0Q0(q0_org_r, p0_org_r, p1_org_r, q1_org_r,
1408                              negate_thresh_r, threshold_r, p0_r, q0_r);
1409
1410                 threshold_l = (v8i16) __msa_ilvl_b(zero, (v16i8) tc);
1411                 negate_thresh_l = (v8i16) __msa_ilvl_b(sign_negate_thresh,
1412                                                        negate_thresh);
1413
1414                 AVC_LPF_P0Q0(q0_org_l, p0_org_l, p1_org_l, q1_org_l,
1415                              negate_thresh_l, threshold_l, p0_l, q0_l);
1416             }
1417
1418             PCKEV_B2_UB(p0_l, p0_r, q0_l, q0_r, p0, q0);
1419
1420             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
1421             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
1422
1423         {
1424             v16i8 tp0, tp1, tp2, tp3;
1425             v8i16 tmp2, tmp5;
1426             v4i32 tmp3, tmp4, tmp6, tmp7;
1427             uint32_t out0, out2;
1428             uint16_t out1, out3;
1429
1430             src = data - 3;
1431
1432             ILVRL_B2_SB(p1_org, p2_org, tp0, tp2);
1433             ILVRL_B2_SB(q0_org, p0_org, tp1, tp3);
1434             ILVRL_B2_SH(q2_org, q1_org, tmp2, tmp5);
1435
1436             ILVRL_H2_SW(tp1, tp0, tmp3, tmp4);
1437             ILVRL_H2_SW(tp3, tp2, tmp6, tmp7);
1438
1439             out0 = __msa_copy_u_w(tmp3, 0);
1440             out1 = __msa_copy_u_h(tmp2, 0);
1441             out2 = __msa_copy_u_w(tmp3, 1);
1442             out3 = __msa_copy_u_h(tmp2, 1);
1443
1444             SW(out0, src);
1445             SH(out1, (src + 4));
1446             src += img_width;
1447             SW(out2, src);
1448             SH(out3, (src + 4));
1449
1450             out0 = __msa_copy_u_w(tmp3, 2);
1451             out1 = __msa_copy_u_h(tmp2, 2);
1452             out2 = __msa_copy_u_w(tmp3, 3);
1453             out3 = __msa_copy_u_h(tmp2, 3);
1454
1455             src += img_width;
1456             SW(out0, src);
1457             SH(out1, (src + 4));
1458             src += img_width;
1459             SW(out2, src);
1460             SH(out3, (src + 4));
1461
1462             out0 = __msa_copy_u_w(tmp4, 0);
1463             out1 = __msa_copy_u_h(tmp2, 4);
1464             out2 = __msa_copy_u_w(tmp4, 1);
1465             out3 = __msa_copy_u_h(tmp2, 5);
1466
1467             src += img_width;
1468             SW(out0, src);
1469             SH(out1, (src + 4));
1470             src += img_width;
1471             SW(out2, src);
1472             SH(out3, (src + 4));
1473
1474             out0 = __msa_copy_u_w(tmp4, 2);
1475             out1 = __msa_copy_u_h(tmp2, 6);
1476             out2 = __msa_copy_u_w(tmp4, 3);
1477             out3 = __msa_copy_u_h(tmp2, 7);
1478
1479             src += img_width;
1480             SW(out0, src);
1481             SH(out1, (src + 4));
1482             src += img_width;
1483             SW(out2, src);
1484             SH(out3, (src + 4));
1485
1486             out0 = __msa_copy_u_w(tmp6, 0);
1487             out1 = __msa_copy_u_h(tmp5, 0);
1488             out2 = __msa_copy_u_w(tmp6, 1);
1489             out3 = __msa_copy_u_h(tmp5, 1);
1490
1491             src += img_width;
1492             SW(out0, src);
1493             SH(out1, (src + 4));
1494             src += img_width;
1495             SW(out2, src);
1496             SH(out3, (src + 4));
1497
1498             out0 = __msa_copy_u_w(tmp6, 2);
1499             out1 = __msa_copy_u_h(tmp5, 2);
1500             out2 = __msa_copy_u_w(tmp6, 3);
1501             out3 = __msa_copy_u_h(tmp5, 3);
1502
1503             src += img_width;
1504             SW(out0, src);
1505             SH(out1, (src + 4));
1506             src += img_width;
1507             SW(out2, src);
1508             SH(out3, (src + 4));
1509
1510             out0 = __msa_copy_u_w(tmp7, 0);
1511             out1 = __msa_copy_u_h(tmp5, 4);
1512             out2 = __msa_copy_u_w(tmp7, 1);
1513             out3 = __msa_copy_u_h(tmp5, 5);
1514
1515             src += img_width;
1516             SW(out0, src);
1517             SH(out1, (src + 4));
1518             src += img_width;
1519             SW(out2, src);
1520             SH(out3, (src + 4));
1521
1522             out0 = __msa_copy_u_w(tmp7, 2);
1523             out1 = __msa_copy_u_h(tmp5, 6);
1524             out2 = __msa_copy_u_w(tmp7, 3);
1525             out3 = __msa_copy_u_h(tmp5, 7);
1526
1527             src += img_width;
1528             SW(out0, src);
1529             SH(out1, (src + 4));
1530             src += img_width;
1531             SW(out2, src);
1532             SH(out3, (src + 4));
1533         }
1534         }
1535     }
1536 }
1537
1538 static void avc_loopfilter_luma_inter_edge_hor_msa(uint8_t *data,
1539                                                    uint8_t bs0, uint8_t bs1,
1540                                                    uint8_t bs2, uint8_t bs3,
1541                                                    uint8_t tc0, uint8_t tc1,
1542                                                    uint8_t tc2, uint8_t tc3,
1543                                                    uint8_t alpha_in,
1544                                                    uint8_t beta_in,
1545                                                    uint32_t image_width)
1546 {
1547     v16u8 tmp_vec;
1548     v16u8 bs = { 0 };
1549
1550     tmp_vec = (v16u8) __msa_fill_b(bs0);
1551     bs = (v16u8) __msa_insve_w((v4i32) bs, 0, (v4i32) tmp_vec);
1552     tmp_vec = (v16u8) __msa_fill_b(bs1);
1553     bs = (v16u8) __msa_insve_w((v4i32) bs, 1, (v4i32) tmp_vec);
1554     tmp_vec = (v16u8) __msa_fill_b(bs2);
1555     bs = (v16u8) __msa_insve_w((v4i32) bs, 2, (v4i32) tmp_vec);
1556     tmp_vec = (v16u8) __msa_fill_b(bs3);
1557     bs = (v16u8) __msa_insve_w((v4i32) bs, 3, (v4i32) tmp_vec);
1558
1559     if (!__msa_test_bz_v(bs)) {
1560         v16u8 alpha, beta, is_less_than, is_less_than_beta;
1561         v16u8 p0, q0, p2_org, p1_org, p0_org, q0_org, q1_org, q2_org;
1562         v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
1563         v16u8 is_less_than_alpha, is_bs_greater_than0;
1564         v8i16 p0_r, q0_r, p0_l, q0_l;
1565         v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1566         v8i16 p1_org_l, p0_org_l, q0_org_l, q1_org_l;
1567         v16i8 zero = { 0 };
1568         v16i8 tc = { 0 };
1569
1570         tmp_vec = (v16u8) __msa_fill_b(tc0);
1571         tc = (v16i8) __msa_insve_w((v4i32) tc, 0, (v4i32) tmp_vec);
1572         tmp_vec = (v16u8) __msa_fill_b(tc1);
1573         tc = (v16i8) __msa_insve_w((v4i32) tc, 1, (v4i32) tmp_vec);
1574         tmp_vec = (v16u8) __msa_fill_b(tc2);
1575         tc = (v16i8) __msa_insve_w((v4i32) tc, 2, (v4i32) tmp_vec);
1576         tmp_vec = (v16u8) __msa_fill_b(tc3);
1577         tc = (v16i8) __msa_insve_w((v4i32) tc, 3, (v4i32) tmp_vec);
1578
1579         alpha = (v16u8) __msa_fill_b(alpha_in);
1580         beta = (v16u8) __msa_fill_b(beta_in);
1581
1582         LD_UB5(data - (3 * image_width), image_width,
1583                p2_org, p1_org, p0_org, q0_org, q1_org);
1584
1585         is_bs_greater_than0 = ((v16u8) zero < bs);
1586         p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
1587         p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
1588         q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
1589
1590         is_less_than_alpha = (p0_asub_q0 < alpha);
1591         is_less_than_beta = (p1_asub_p0 < beta);
1592         is_less_than = is_less_than_beta & is_less_than_alpha;
1593         is_less_than_beta = (q1_asub_q0 < beta);
1594         is_less_than = is_less_than_beta & is_less_than;
1595         is_less_than = is_less_than & is_bs_greater_than0;
1596
1597         if (!__msa_test_bz_v(is_less_than)) {
1598             v16i8 sign_negate_tc, negate_tc;
1599             v8i16 negate_tc_r, i16_negatetc_l, tc_l, tc_r;
1600             v16u8 p2_asub_p0, q2_asub_q0;
1601
1602             q2_org = LD_UB(data + (2 * image_width));
1603             negate_tc = zero - tc;
1604             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
1605
1606             ILVRL_B2_SH(sign_negate_tc, negate_tc, negate_tc_r, i16_negatetc_l);
1607
1608             UNPCK_UB_SH(tc, tc_r, tc_l);
1609             UNPCK_UB_SH(p1_org, p1_org_r, p1_org_l);
1610             UNPCK_UB_SH(p0_org, p0_org_r, p0_org_l);
1611             UNPCK_UB_SH(q0_org, q0_org_r, q0_org_l);
1612
1613             p2_asub_p0 = __msa_asub_u_b(p2_org, p0_org);
1614             is_less_than_beta = (p2_asub_p0 < beta);
1615             is_less_than_beta = is_less_than_beta & is_less_than;
1616
1617             if (!__msa_test_bz_v(is_less_than_beta)) {
1618                 v16u8 p1;
1619                 v8i16 p1_r = { 0 };
1620                 v8i16 p1_l = { 0 };
1621                 v8i16 p2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) p2_org);
1622                 v8i16 p2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) p2_org);
1623
1624                 AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, p1_org_r, p2_org_r,
1625                                  negate_tc_r, tc_r, p1_r);
1626                 AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, p1_org_l, p2_org_l,
1627                                  i16_negatetc_l, tc_l, p1_l);
1628
1629                 p1 = (v16u8) __msa_pckev_b((v16i8) p1_l, (v16i8) p1_r);
1630                 p1_org = __msa_bmnz_v(p1_org, p1, is_less_than_beta);
1631                 ST_UB(p1_org, data - (2 * image_width));
1632
1633                 is_less_than_beta = __msa_andi_b(is_less_than_beta, 1);
1634                 tc = tc + (v16i8) is_less_than_beta;
1635             }
1636
1637             q2_asub_q0 = __msa_asub_u_b(q2_org, q0_org);
1638             is_less_than_beta = (q2_asub_q0 < beta);
1639             is_less_than_beta = is_less_than_beta & is_less_than;
1640
1641             q1_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q1_org);
1642             q1_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q1_org);
1643
1644             if (!__msa_test_bz_v(is_less_than_beta)) {
1645                 v16u8 q1;
1646                 v8i16 q1_r = { 0 };
1647                 v8i16 q1_l = { 0 };
1648                 v8i16 q2_org_r = (v8i16) __msa_ilvr_b(zero, (v16i8) q2_org);
1649                 v8i16 q2_org_l = (v8i16) __msa_ilvl_b(zero, (v16i8) q2_org);
1650
1651                 AVC_LPF_P1_OR_Q1(p0_org_r, q0_org_r, q1_org_r, q2_org_r,
1652                                  negate_tc_r, tc_r, q1_r);
1653                 AVC_LPF_P1_OR_Q1(p0_org_l, q0_org_l, q1_org_l, q2_org_l,
1654                                  i16_negatetc_l, tc_l, q1_l);
1655
1656                 q1 = (v16u8) __msa_pckev_b((v16i8) q1_l, (v16i8) q1_r);
1657                 q1_org = __msa_bmnz_v(q1_org, q1, is_less_than_beta);
1658                 ST_UB(q1_org, data + image_width);
1659
1660                 is_less_than_beta = __msa_andi_b(is_less_than_beta, 1);
1661                 tc = tc + (v16i8) is_less_than_beta;
1662             }
1663             {
1664                 v16i8 negate_thresh, sign_negate_thresh;
1665                 v8i16 threshold_r, threshold_l;
1666                 v8i16 negate_thresh_l, negate_thresh_r;
1667
1668                 negate_thresh = zero - tc;
1669                 sign_negate_thresh = __msa_clti_s_b(negate_thresh, 0);
1670
1671                 ILVR_B2_SH(zero, tc, sign_negate_thresh, negate_thresh,
1672                            threshold_r, negate_thresh_r);
1673                 AVC_LPF_P0Q0(q0_org_r, p0_org_r, p1_org_r, q1_org_r,
1674                              negate_thresh_r, threshold_r, p0_r, q0_r);
1675
1676                 threshold_l = (v8i16) __msa_ilvl_b(zero, tc);
1677                 negate_thresh_l = (v8i16) __msa_ilvl_b(sign_negate_thresh,
1678                                                        negate_thresh);
1679                 AVC_LPF_P0Q0(q0_org_l, p0_org_l, p1_org_l, q1_org_l,
1680                              negate_thresh_l, threshold_l, p0_l, q0_l);
1681             }
1682
1683             PCKEV_B2_UB(p0_l, p0_r, q0_l, q0_r, p0, q0);
1684
1685             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
1686             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
1687
1688             ST_UB(p0_org, (data - image_width));
1689             ST_UB(q0_org, data);
1690         }
1691     }
1692 }
1693
1694 static void avc_h_loop_filter_luma_mbaff_msa(uint8_t *in, int32_t stride,
1695                                              int32_t alpha_in, int32_t beta_in,
1696                                              int8_t *tc0)
1697 {
1698     uint8_t *data = in;
1699     uint32_t out0, out1, out2, out3;
1700     uint64_t load;
1701     uint32_t tc_val;
1702     v16u8 alpha, beta;
1703     v16i8 inp0 = { 0 };
1704     v16i8 inp1 = { 0 };
1705     v16i8 inp2 = { 0 };
1706     v16i8 inp3 = { 0 };
1707     v16i8 inp4 = { 0 };
1708     v16i8 inp5 = { 0 };
1709     v16i8 inp6 = { 0 };
1710     v16i8 inp7 = { 0 };
1711     v16i8 src0, src1, src2, src3;
1712     v8i16 src4, src5, src6, src7;
1713     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0, p2_asub_p0, q2_asub_q0;
1714     v16u8 is_less_than, is_less_than_alpha, is_less_than_beta;
1715     v16u8 is_less_than_beta1, is_less_than_beta2;
1716     v8i16 tc, tc_orig_r, tc_plus1;
1717     v16u8 is_tc_orig1, is_tc_orig2, tc_orig = { 0 };
1718     v8i16 p0_ilvr_q0, p0_add_q0, q0_sub_p0, p1_sub_q1;
1719     v8u16 src2_r, src3_r;
1720     v8i16 p2_r, p1_r, q2_r, q1_r;
1721     v16u8 p2, q2, p0, q0;
1722     v4i32 dst0, dst1;
1723     v16i8 zeros = { 0 };
1724
1725     alpha = (v16u8) __msa_fill_b(alpha_in);
1726     beta = (v16u8) __msa_fill_b(beta_in);
1727
1728     if (tc0[0] < 0) {
1729         data += (2 * stride);
1730     } else {
1731         load = LD(data - 3);
1732         inp0 = (v16i8) __msa_insert_d((v2i64) inp0, 0, load);
1733         load = LD(data - 3 + stride);
1734         inp1 = (v16i8) __msa_insert_d((v2i64) inp1, 0, load);
1735         data += (2 * stride);
1736     }
1737
1738     if (tc0[1] < 0) {
1739         data += (2 * stride);
1740     } else {
1741         load = LD(data - 3);
1742         inp2 = (v16i8) __msa_insert_d((v2i64) inp2, 0, load);
1743         load = LD(data - 3 + stride);
1744         inp3 = (v16i8) __msa_insert_d((v2i64) inp3, 0, load);
1745         data += (2 * stride);
1746     }
1747
1748     if (tc0[2] < 0) {
1749         data += (2 * stride);
1750     } else {
1751         load = LD(data - 3);
1752         inp4 = (v16i8) __msa_insert_d((v2i64) inp4, 0, load);
1753         load = LD(data - 3 + stride);
1754         inp5 = (v16i8) __msa_insert_d((v2i64) inp5, 0, load);
1755         data += (2 * stride);
1756     }
1757
1758     if (tc0[3] < 0) {
1759         data += (2 * stride);
1760     } else {
1761         load = LD(data - 3);
1762         inp6 = (v16i8) __msa_insert_d((v2i64) inp6, 0, load);
1763         load = LD(data - 3 + stride);
1764         inp7 = (v16i8) __msa_insert_d((v2i64) inp7, 0, load);
1765         data += (2 * stride);
1766     }
1767
1768     ILVR_B4_SB(inp1, inp0, inp3, inp2, inp5, inp4, inp7, inp6,
1769                src0, src1, src2, src3);
1770
1771     ILVR_H2_SH(src1, src0, src3, src2, src4, src6);
1772     ILVL_H2_SH(src1, src0, src3, src2, src5, src7);
1773
1774     src0 = (v16i8) __msa_ilvr_w((v4i32) src6, (v4i32) src4);
1775     src1 = __msa_sldi_b(zeros, (v16i8) src0, 8);
1776     src2 = (v16i8) __msa_ilvl_w((v4i32) src6, (v4i32) src4);
1777     src3 = __msa_sldi_b(zeros, (v16i8) src2, 8);
1778     src4 = (v8i16) __msa_ilvr_w((v4i32) src7, (v4i32) src5);
1779     src5 = (v8i16) __msa_sldi_b(zeros, (v16i8) src4, 8);
1780
1781     p0_asub_q0 = __msa_asub_u_b((v16u8) src2, (v16u8) src3);
1782     p1_asub_p0 = __msa_asub_u_b((v16u8) src1, (v16u8) src2);
1783     q1_asub_q0 = __msa_asub_u_b((v16u8) src4, (v16u8) src3);
1784     p2_asub_p0 = __msa_asub_u_b((v16u8) src0, (v16u8) src2);
1785     q2_asub_q0 = __msa_asub_u_b((v16u8) src5, (v16u8) src3);
1786
1787     is_less_than_alpha = (p0_asub_q0 < alpha);
1788     is_less_than_beta = (p1_asub_p0 < beta);
1789     is_less_than = is_less_than_alpha & is_less_than_beta;
1790     is_less_than_beta = (q1_asub_q0 < beta);
1791     is_less_than = is_less_than_beta & is_less_than;
1792
1793     is_less_than_beta1 = (p2_asub_p0 < beta);
1794     is_less_than_beta2 = (q2_asub_q0 < beta);
1795
1796     p0_ilvr_q0 = (v8i16) __msa_ilvr_b((v16i8) src3, (v16i8) src2);
1797     p0_add_q0 = (v8i16) __msa_hadd_u_h((v16u8) p0_ilvr_q0, (v16u8) p0_ilvr_q0);
1798     p0_add_q0 = __msa_srari_h(p0_add_q0, 1);
1799
1800     ILVR_B2_SH(zeros, src0, zeros, src1, p2_r, p1_r);
1801     p2_r += p0_add_q0;
1802     p2_r >>= 1;
1803     p2_r -= p1_r;
1804     ILVR_B2_SH(zeros, src5, zeros, src4, q2_r, q1_r);
1805     q2_r += p0_add_q0;
1806     q2_r >>= 1;
1807     q2_r -= q1_r;
1808
1809     tc_val = LW(tc0);
1810     tc_orig = (v16u8) __msa_insert_w((v4i32) tc_orig, 0, tc_val);
1811     tc_orig = (v16u8) __msa_ilvr_b((v16i8) tc_orig, (v16i8) tc_orig);
1812     is_tc_orig1 = tc_orig;
1813     is_tc_orig2 = tc_orig;
1814     tc_orig_r = (v8i16) __msa_ilvr_b(zeros, (v16i8) tc_orig);
1815     tc = tc_orig_r;
1816
1817     p2_r = CLIP_SH(p2_r, -tc_orig_r, tc_orig_r);
1818     q2_r = CLIP_SH(q2_r, -tc_orig_r, tc_orig_r);
1819
1820     p2_r += p1_r;
1821     q2_r += q1_r;
1822
1823     PCKEV_B2_UB(p2_r, p2_r, q2_r, q2_r, p2, q2);
1824
1825     is_tc_orig1 = (zeros < is_tc_orig1);
1826     is_tc_orig2 = is_tc_orig1;
1827     is_tc_orig1 = is_less_than_beta1 & is_tc_orig1;
1828     is_tc_orig2 = is_less_than_beta2 & is_tc_orig2;
1829     is_tc_orig1 = is_less_than & is_tc_orig1;
1830     is_tc_orig2 = is_less_than & is_tc_orig2;
1831
1832     p2 = __msa_bmnz_v((v16u8) src1, p2, is_tc_orig1);
1833     q2 = __msa_bmnz_v((v16u8) src4, q2, is_tc_orig2);
1834
1835     q0_sub_p0 = __msa_hsub_u_h((v16u8) p0_ilvr_q0, (v16u8) p0_ilvr_q0);
1836     q0_sub_p0 <<= 2;
1837     p1_sub_q1 = p1_r - q1_r;
1838     q0_sub_p0 += p1_sub_q1;
1839     q0_sub_p0 = __msa_srari_h(q0_sub_p0, 3);
1840
1841     tc_plus1 = tc + 1;
1842     is_less_than_beta1 = (v16u8) __msa_ilvr_b((v16i8) is_less_than_beta1,
1843                                               (v16i8) is_less_than_beta1);
1844     tc = (v8i16) __msa_bmnz_v((v16u8) tc, (v16u8) tc_plus1, is_less_than_beta1);
1845     tc_plus1 = tc + 1;
1846     is_less_than_beta2 = (v16u8) __msa_ilvr_b((v16i8) is_less_than_beta2,
1847                                               (v16i8) is_less_than_beta2);
1848     tc = (v8i16) __msa_bmnz_v((v16u8) tc, (v16u8) tc_plus1, is_less_than_beta2);
1849
1850     q0_sub_p0 = CLIP_SH(q0_sub_p0, -tc, tc);
1851
1852     ILVR_B2_UH(zeros, src2, zeros, src3, src2_r, src3_r);
1853     src2_r += q0_sub_p0;
1854     src3_r -= q0_sub_p0;
1855
1856     src2_r = (v8u16) CLIP_SH_0_255(src2_r);
1857     src3_r = (v8u16) CLIP_SH_0_255(src3_r);
1858
1859     PCKEV_B2_UB(src2_r, src2_r, src3_r, src3_r, p0, q0);
1860
1861     p0 = __msa_bmnz_v((v16u8) src2, p0, is_less_than);
1862     q0 = __msa_bmnz_v((v16u8) src3, q0, is_less_than);
1863
1864     ILVR_B2_UB(p0, p2, q2, q0, p2, q2);
1865
1866     ILVRL_H2_SW(q2, p2, dst0, dst1);
1867
1868     data = in;
1869
1870     out0 = __msa_copy_u_w(dst0, 0);
1871     out1 = __msa_copy_u_w(dst0, 1);
1872     out2 = __msa_copy_u_w(dst0, 2);
1873     out3 = __msa_copy_u_w(dst0, 3);
1874
1875     if (tc0[0] < 0) {
1876         data += (2 * stride);
1877     } else {
1878         SW(out0, (data - 2));
1879         data += stride;
1880         SW(out1, (data - 2));
1881         data += stride;
1882     }
1883
1884     if (tc0[1] < 0) {
1885         data += (2 * stride);
1886     } else {
1887         SW(out2, (data - 2));
1888         data += stride;
1889         SW(out3, (data - 2));
1890         data += stride;
1891     }
1892
1893     out0 = __msa_copy_u_w(dst1, 0);
1894     out1 = __msa_copy_u_w(dst1, 1);
1895     out2 = __msa_copy_u_w(dst1, 2);
1896     out3 = __msa_copy_u_w(dst1, 3);
1897
1898     if (tc0[2] < 0) {
1899         data += (2 * stride);
1900     } else {
1901         SW(out0, (data - 2));
1902         data += stride;
1903         SW(out1, (data - 2));
1904         data += stride;
1905     }
1906
1907     if (tc0[3] >= 0) {
1908         SW(out2, (data - 2));
1909         data += stride;
1910         SW(out3, (data - 2));
1911     }
1912 }
1913
1914 static void avc_loopfilter_cb_or_cr_inter_edge_hor_msa(uint8_t *data,
1915                                                        uint8_t bs0, uint8_t bs1,
1916                                                        uint8_t bs2, uint8_t bs3,
1917                                                        uint8_t tc0, uint8_t tc1,
1918                                                        uint8_t tc2, uint8_t tc3,
1919                                                        uint8_t alpha_in,
1920                                                        uint8_t beta_in,
1921                                                        uint32_t img_width)
1922 {
1923     v16u8 alpha, beta;
1924     v8i16 tmp_vec;
1925     v8i16 bs = { 0 };
1926     v8i16 tc = { 0 };
1927     v16u8 p0, q0, p0_asub_q0, p1_asub_p0, q1_asub_q0;
1928     v16u8 is_less_than;
1929     v16u8 is_less_than_beta, is_less_than_alpha, is_bs_greater_than0;
1930     v8i16 p0_r, q0_r;
1931     v16u8 p1_org, p0_org, q0_org, q1_org;
1932     v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
1933     v16i8 negate_tc, sign_negate_tc;
1934     v8i16 tc_r, negate_tc_r;
1935     v16i8 zero = { 0 };
1936
1937     tmp_vec = (v8i16) __msa_fill_b(bs0);
1938     bs = __msa_insve_h(bs, 0, tmp_vec);
1939     tmp_vec = (v8i16) __msa_fill_b(bs1);
1940     bs = __msa_insve_h(bs, 1, tmp_vec);
1941     tmp_vec = (v8i16) __msa_fill_b(bs2);
1942     bs = __msa_insve_h(bs, 2, tmp_vec);
1943     tmp_vec = (v8i16) __msa_fill_b(bs3);
1944     bs = __msa_insve_h(bs, 3, tmp_vec);
1945
1946     if (!__msa_test_bz_v((v16u8) bs)) {
1947         tmp_vec = (v8i16) __msa_fill_b(tc0);
1948         tc = __msa_insve_h(tc, 0, tmp_vec);
1949         tmp_vec = (v8i16) __msa_fill_b(tc1);
1950         tc = __msa_insve_h(tc, 1, tmp_vec);
1951         tmp_vec = (v8i16) __msa_fill_b(tc2);
1952         tc = __msa_insve_h(tc, 2, tmp_vec);
1953         tmp_vec = (v8i16) __msa_fill_b(tc3);
1954         tc = __msa_insve_h(tc, 3, tmp_vec);
1955
1956         is_bs_greater_than0 = (v16u8) (zero < (v16i8) bs);
1957
1958         alpha = (v16u8) __msa_fill_b(alpha_in);
1959         beta = (v16u8) __msa_fill_b(beta_in);
1960
1961         LD_UB4(data - (img_width << 1), img_width,
1962                p1_org, p0_org, q0_org, q1_org);
1963
1964         p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
1965         p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
1966         q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
1967
1968         is_less_than_alpha = (p0_asub_q0 < alpha);
1969         is_less_than_beta = (p1_asub_p0 < beta);
1970         is_less_than = is_less_than_beta & is_less_than_alpha;
1971         is_less_than_beta = (q1_asub_q0 < beta);
1972         is_less_than = is_less_than_beta & is_less_than;
1973         is_less_than = is_less_than & is_bs_greater_than0;
1974
1975         is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);
1976
1977         if (!__msa_test_bz_v(is_less_than)) {
1978             negate_tc = zero - (v16i8) tc;
1979             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
1980
1981             ILVR_B2_SH(zero, tc, sign_negate_tc, negate_tc, tc_r, negate_tc_r);
1982
1983             ILVR_B4_SH(zero, p1_org, zero, p0_org, zero, q0_org, zero, q1_org,
1984                        p1_org_r, p0_org_r, q0_org_r, q1_org_r);
1985
1986             AVC_LPF_P0Q0(q0_org_r, p0_org_r, p1_org_r, q1_org_r, negate_tc_r,
1987                          tc_r, p0_r, q0_r);
1988
1989             PCKEV_B2_UB(zero, p0_r, zero, q0_r, p0, q0);
1990
1991             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
1992             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
1993
1994             ST_UB(q0_org, data);
1995             ST_UB(p0_org, (data - img_width));
1996         }
1997     }
1998 }
1999
2000 static void avc_loopfilter_cb_or_cr_inter_edge_ver_msa(uint8_t *data,
2001                                                        uint8_t bs0, uint8_t bs1,
2002                                                        uint8_t bs2, uint8_t bs3,
2003                                                        uint8_t tc0, uint8_t tc1,
2004                                                        uint8_t tc2, uint8_t tc3,
2005                                                        uint8_t alpha_in,
2006                                                        uint8_t beta_in,
2007                                                        uint32_t img_width)
2008 {
2009     uint8_t *src;
2010     v16u8 alpha, beta;
2011     v16u8 p0_asub_q0, p1_asub_p0, q1_asub_q0;
2012     v16u8 is_less_than, is_less_than_beta, is_less_than_alpha;
2013     v16u8 p0, q0;
2014     v8i16 p0_r = { 0 };
2015     v8i16 q0_r = { 0 };
2016     v16u8 p1_org, p0_org, q0_org, q1_org;
2017     v8i16 p1_org_r, p0_org_r, q0_org_r, q1_org_r;
2018     v16u8 is_bs_greater_than0;
2019     v8i16 tc_r, negate_tc_r;
2020     v16i8 negate_tc, sign_negate_tc;
2021     v16i8 zero = { 0 };
2022     v16u8 row0, row1, row2, row3, row4, row5, row6, row7;
2023     v8i16 tmp1, tmp_vec, bs = { 0 };
2024     v8i16 tc = { 0 };
2025
2026     tmp_vec = (v8i16) __msa_fill_b(bs0);
2027     bs = __msa_insve_h(bs, 0, tmp_vec);
2028     tmp_vec = (v8i16) __msa_fill_b(bs1);
2029     bs = __msa_insve_h(bs, 1, tmp_vec);
2030     tmp_vec = (v8i16) __msa_fill_b(bs2);
2031     bs = __msa_insve_h(bs, 2, tmp_vec);
2032     tmp_vec = (v8i16) __msa_fill_b(bs3);
2033     bs = __msa_insve_h(bs, 3, tmp_vec);
2034
2035     if (!__msa_test_bz_v((v16u8) bs)) {
2036         tmp_vec = (v8i16) __msa_fill_b(tc0);
2037         tc = __msa_insve_h(tc, 0, tmp_vec);
2038         tmp_vec = (v8i16) __msa_fill_b(tc1);
2039         tc = __msa_insve_h(tc, 1, tmp_vec);
2040         tmp_vec = (v8i16) __msa_fill_b(tc2);
2041         tc = __msa_insve_h(tc, 2, tmp_vec);
2042         tmp_vec = (v8i16) __msa_fill_b(tc3);
2043         tc = __msa_insve_h(tc, 3, tmp_vec);
2044
2045         is_bs_greater_than0 = (v16u8) (zero < (v16i8) bs);
2046
2047         LD_UB8((data - 2), img_width,
2048                row0, row1, row2, row3, row4, row5, row6, row7);
2049
2050         TRANSPOSE8x4_UB_UB(row0, row1, row2, row3,
2051                            row4, row5, row6, row7,
2052                            p1_org, p0_org, q0_org, q1_org);
2053
2054         p0_asub_q0 = __msa_asub_u_b(p0_org, q0_org);
2055         p1_asub_p0 = __msa_asub_u_b(p1_org, p0_org);
2056         q1_asub_q0 = __msa_asub_u_b(q1_org, q0_org);
2057
2058         alpha = (v16u8) __msa_fill_b(alpha_in);
2059         beta = (v16u8) __msa_fill_b(beta_in);
2060
2061         is_less_than_alpha = (p0_asub_q0 < alpha);
2062         is_less_than_beta = (p1_asub_p0 < beta);
2063         is_less_than = is_less_than_beta & is_less_than_alpha;
2064         is_less_than_beta = (q1_asub_q0 < beta);
2065         is_less_than = is_less_than_beta & is_less_than;
2066         is_less_than = is_bs_greater_than0 & is_less_than;
2067
2068         is_less_than = (v16u8) __msa_ilvr_d((v2i64) zero, (v2i64) is_less_than);
2069
2070         if (!__msa_test_bz_v(is_less_than)) {
2071             ILVR_B4_SH(zero, p1_org, zero, p0_org, zero, q0_org, zero, q1_org,
2072                        p1_org_r, p0_org_r, q0_org_r, q1_org_r);
2073
2074             negate_tc = zero - (v16i8) tc;
2075             sign_negate_tc = __msa_clti_s_b(negate_tc, 0);
2076
2077             ILVR_B2_SH(sign_negate_tc, negate_tc, zero, tc, negate_tc_r, tc_r);
2078
2079             AVC_LPF_P0Q0(q0_org_r, p0_org_r, p1_org_r, q1_org_r, negate_tc_r,
2080                          tc_r, p0_r, q0_r);
2081
2082             PCKEV_B2_UB(zero, p0_r, zero, q0_r, p0, q0);
2083
2084             p0_org = __msa_bmnz_v(p0_org, p0, is_less_than);
2085             q0_org = __msa_bmnz_v(q0_org, q0, is_less_than);
2086             tmp1 = (v8i16) __msa_ilvr_b((v16i8) q0_org, (v16i8) p0_org);
2087             src = data - 1;
2088             ST2x4_UB(tmp1, 0, src, img_width);
2089             src += 4 * img_width;
2090             ST2x4_UB(tmp1, 4, src, img_width);
2091         }
2092     }
2093 }
2094
2095 static void avc_h_loop_filter_chroma422_msa(uint8_t *src, int32_t stride,
2096                                             int32_t alpha_in, int32_t beta_in,
2097                                             int8_t *tc0)
2098 {
2099     int32_t col, tc_val;
2100     v16u8 alpha, beta, res;
2101
2102     alpha = (v16u8) __msa_fill_b(alpha_in);
2103     beta = (v16u8) __msa_fill_b(beta_in);
2104
2105     for (col = 0; col < 4; col++) {
2106         tc_val = (tc0[col] - 1) + 1;
2107
2108         if (tc_val <= 0) {
2109             src += (4 * stride);
2110             continue;
2111         }
2112
2113         AVC_LPF_H_CHROMA_422(src, stride, tc_val, alpha, beta, res);
2114         ST2x4_UB(res, 0, (src - 1), stride);
2115         src += (4 * stride);
2116     }
2117 }
2118
2119 static void avc_h_loop_filter_chroma422_mbaff_msa(uint8_t *src, int32_t stride,
2120                                                   int32_t alpha_in,
2121                                                   int32_t beta_in,
2122                                                   int8_t *tc0)
2123 {
2124     int32_t col, tc_val;
2125     int16_t out0, out1;
2126     v16u8 alpha, beta, res;
2127
2128     alpha = (v16u8) __msa_fill_b(alpha_in);
2129     beta = (v16u8) __msa_fill_b(beta_in);
2130
2131     for (col = 0; col < 4; col++) {
2132         tc_val = (tc0[col] - 1) + 1;
2133
2134         if (tc_val <= 0) {
2135             src += 4 * stride;
2136             continue;
2137         }
2138
2139         AVC_LPF_H_2BYTE_CHROMA_422(src, stride, tc_val, alpha, beta, res);
2140
2141         out0 = __msa_copy_s_h((v8i16) res, 0);
2142         out1 = __msa_copy_s_h((v8i16) res, 1);
2143
2144         SH(out0, (src - 1));
2145         src += stride;
2146         SH(out1, (src - 1));
2147         src += stride;
2148     }
2149 }
2150
2151 void ff_h264_h_lpf_luma_inter_msa(uint8_t *data, int img_width,
2152                                   int alpha, int beta, int8_t *tc)
2153 {
2154     uint8_t bs0 = 1;
2155     uint8_t bs1 = 1;
2156     uint8_t bs2 = 1;
2157     uint8_t bs3 = 1;
2158
2159     if (tc[0] < 0)
2160         bs0 = 0;
2161     if (tc[1] < 0)
2162         bs1 = 0;
2163     if (tc[2] < 0)
2164         bs2 = 0;
2165     if (tc[3] < 0)
2166         bs3 = 0;
2167
2168     avc_loopfilter_luma_inter_edge_ver_msa(data, bs0, bs1, bs2, bs3,
2169                                            tc[0], tc[1], tc[2], tc[3],
2170                                            alpha, beta, img_width);
2171 }
2172
2173 void ff_h264_v_lpf_luma_inter_msa(uint8_t *data, int img_width,
2174                                   int alpha, int beta, int8_t *tc)
2175 {
2176
2177     uint8_t bs0 = 1;
2178     uint8_t bs1 = 1;
2179     uint8_t bs2 = 1;
2180     uint8_t bs3 = 1;
2181
2182     if (tc[0] < 0)
2183         bs0 = 0;
2184     if (tc[1] < 0)
2185         bs1 = 0;
2186     if (tc[2] < 0)
2187         bs2 = 0;
2188     if (tc[3] < 0)
2189         bs3 = 0;
2190
2191     avc_loopfilter_luma_inter_edge_hor_msa(data, bs0, bs1, bs2, bs3,
2192                                            tc[0], tc[1], tc[2], tc[3],
2193                                            alpha, beta, img_width);
2194 }
2195
2196 void ff_h264_h_lpf_chroma_inter_msa(uint8_t *data, int img_width,
2197                                     int alpha, int beta, int8_t *tc)
2198 {
2199     uint8_t bs0 = 1;
2200     uint8_t bs1 = 1;
2201     uint8_t bs2 = 1;
2202     uint8_t bs3 = 1;
2203
2204     if (tc[0] < 0)
2205         bs0 = 0;
2206     if (tc[1] < 0)
2207         bs1 = 0;
2208     if (tc[2] < 0)
2209         bs2 = 0;
2210     if (tc[3] < 0)
2211         bs3 = 0;
2212
2213     avc_loopfilter_cb_or_cr_inter_edge_ver_msa(data, bs0, bs1, bs2, bs3,
2214                                                tc[0], tc[1], tc[2], tc[3],
2215                                                alpha, beta, img_width);
2216 }
2217
2218 void ff_h264_v_lpf_chroma_inter_msa(uint8_t *data, int img_width,
2219                                     int alpha, int beta, int8_t *tc)
2220 {
2221     uint8_t bs0 = 1;
2222     uint8_t bs1 = 1;
2223     uint8_t bs2 = 1;
2224     uint8_t bs3 = 1;
2225
2226     if (tc[0] < 0)
2227         bs0 = 0;
2228     if (tc[1] < 0)
2229         bs1 = 0;
2230     if (tc[2] < 0)
2231         bs2 = 0;
2232     if (tc[3] < 0)
2233         bs3 = 0;
2234
2235     avc_loopfilter_cb_or_cr_inter_edge_hor_msa(data, bs0, bs1, bs2, bs3,
2236                                                tc[0], tc[1], tc[2], tc[3],
2237                                                alpha, beta, img_width);
2238 }
2239
2240 void ff_h264_h_lpf_luma_intra_msa(uint8_t *data, int img_width,
2241                                   int alpha, int beta)
2242 {
2243     avc_loopfilter_luma_intra_edge_ver_msa(data, (uint8_t) alpha,
2244                                            (uint8_t) beta,
2245                                            (unsigned int) img_width);
2246 }
2247
2248 void ff_h264_v_lpf_luma_intra_msa(uint8_t *data, int img_width,
2249                                   int alpha, int beta)
2250 {
2251     avc_loopfilter_luma_intra_edge_hor_msa(data, (uint8_t) alpha,
2252                                            (uint8_t) beta,
2253                                            (unsigned int) img_width);
2254 }
2255
2256 void ff_h264_h_lpf_chroma_intra_msa(uint8_t *data, int img_width,
2257                                     int alpha, int beta)
2258 {
2259     avc_loopfilter_cb_or_cr_intra_edge_ver_msa(data, (uint8_t) alpha,
2260                                                (uint8_t) beta,
2261                                                (unsigned int) img_width);
2262 }
2263
2264 void ff_h264_v_lpf_chroma_intra_msa(uint8_t *data, int img_width,
2265                                     int alpha, int beta)
2266 {
2267     avc_loopfilter_cb_or_cr_intra_edge_hor_msa(data, (uint8_t) alpha,
2268                                                (uint8_t) beta,
2269                                                (unsigned int) img_width);
2270 }
2271
2272 void ff_h264_h_loop_filter_chroma422_msa(uint8_t *src,
2273                                          int32_t ystride,
2274                                          int32_t alpha, int32_t beta,
2275                                          int8_t *tc0)
2276 {
2277     avc_h_loop_filter_chroma422_msa(src, ystride, alpha, beta, tc0);
2278 }
2279
2280 void ff_h264_h_loop_filter_chroma422_mbaff_msa(uint8_t *src,
2281                                                int32_t ystride,
2282                                                int32_t alpha,
2283                                                int32_t beta,
2284                                                int8_t *tc0)
2285 {
2286     avc_h_loop_filter_chroma422_mbaff_msa(src, ystride, alpha, beta, tc0);
2287 }
2288
2289 void ff_h264_h_loop_filter_luma_mbaff_msa(uint8_t *src,
2290                                           int32_t ystride,
2291                                           int32_t alpha,
2292                                           int32_t beta,
2293                                           int8_t *tc0)
2294 {
2295     avc_h_loop_filter_luma_mbaff_msa(src, ystride, alpha, beta, tc0);
2296 }
2297
2298 void ff_h264_h_loop_filter_luma_mbaff_intra_msa(uint8_t *src,
2299                                                 int32_t ystride,
2300                                                 int32_t alpha,
2301                                                 int32_t beta)
2302 {
2303     avc_h_loop_filter_luma_mbaff_intra_msa(src, ystride, alpha, beta);
2304 }
2305
2306 void ff_weight_h264_pixels16_8_msa(uint8_t *src, ptrdiff_t stride,
2307                                    int height, int log2_denom,
2308                                    int weight_src, int offset_in)
2309 {
2310     uint32_t offset_val;
2311     v16i8 zero = { 0 };
2312     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
2313     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
2314     v8i16 src0_l, src1_l, src2_l, src3_l, src0_r, src1_r, src2_r, src3_r;
2315     v8i16 src4_l, src5_l, src6_l, src7_l, src4_r, src5_r, src6_r, src7_r;
2316     v8i16 tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
2317     v8i16 tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15;
2318     v8i16 wgt, denom, offset;
2319
2320     offset_val = (unsigned) offset_in << log2_denom;
2321
2322     wgt = __msa_fill_h(weight_src);
2323     offset = __msa_fill_h(offset_val);
2324     denom = __msa_fill_h(log2_denom);
2325
2326     LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
2327     ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_r, src1_r,
2328                src2_r, src3_r);
2329     ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_l, src1_l,
2330                src2_l, src3_l);
2331     ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_r, src5_r,
2332                src6_r, src7_r);
2333     ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_l, src5_l,
2334                src6_l, src7_l);
2335     MUL4(wgt, src0_r, wgt, src0_l, wgt, src1_r, wgt, src1_l, tmp0, tmp1, tmp2,
2336          tmp3);
2337     MUL4(wgt, src2_r, wgt, src2_l, wgt, src3_r, wgt, src3_l, tmp4, tmp5, tmp6,
2338          tmp7);
2339     MUL4(wgt, src4_r, wgt, src4_l, wgt, src5_r, wgt, src5_l, tmp8, tmp9, tmp10,
2340          tmp11);
2341     MUL4(wgt, src6_r, wgt, src6_l, wgt, src7_r, wgt, src7_l, tmp12, tmp13,
2342          tmp14, tmp15);
2343     ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset, tmp0,
2344                 tmp1, tmp2, tmp3);
2345     ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset, tmp4,
2346                 tmp5, tmp6, tmp7);
2347     ADDS_SH4_SH(tmp8, offset, tmp9, offset, tmp10, offset, tmp11, offset, tmp8,
2348                 tmp9, tmp10, tmp11);
2349     ADDS_SH4_SH(tmp12, offset, tmp13, offset, tmp14, offset, tmp15, offset,
2350                 tmp12, tmp13, tmp14, tmp15);
2351     MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
2352     MAXI_SH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 0);
2353     SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
2354     SRLR_H8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, denom);
2355     SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
2356     SAT_UH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 7);
2357     PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
2358                 dst2, dst3);
2359     PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
2360                 dst5, dst6, dst7);
2361     ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, src, stride);
2362     src += 8 * stride;
2363
2364     if (16 == height) {
2365         LD_UB8(src, stride, src0, src1, src2, src3, src4, src5, src6, src7);
2366         ILVR_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_r,
2367                    src1_r, src2_r, src3_r);
2368         ILVL_B4_SH(zero, src0, zero, src1, zero, src2, zero, src3, src0_l,
2369                    src1_l, src2_l, src3_l);
2370         ILVR_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_r,
2371                    src5_r, src6_r, src7_r);
2372         ILVL_B4_SH(zero, src4, zero, src5, zero, src6, zero, src7, src4_l,
2373                    src5_l, src6_l, src7_l);
2374         MUL4(wgt, src0_r, wgt, src0_l, wgt, src1_r, wgt, src1_l, tmp0, tmp1,
2375              tmp2, tmp3);
2376         MUL4(wgt, src2_r, wgt, src2_l, wgt, src3_r, wgt, src3_l, tmp4, tmp5,
2377              tmp6, tmp7);
2378         MUL4(wgt, src4_r, wgt, src4_l, wgt, src5_r, wgt, src5_l, tmp8, tmp9,
2379              tmp10, tmp11);
2380         MUL4(wgt, src6_r, wgt, src6_l, wgt, src7_r, wgt, src7_l, tmp12, tmp13,
2381              tmp14, tmp15);
2382         ADDS_SH4_SH(tmp0, offset, tmp1, offset, tmp2, offset, tmp3, offset,
2383                     tmp0, tmp1, tmp2, tmp3);
2384         ADDS_SH4_SH(tmp4, offset, tmp5, offset, tmp6, offset, tmp7, offset,
2385                     tmp4, tmp5, tmp6, tmp7);
2386         ADDS_SH4_SH(tmp8, offset, tmp9, offset, tmp10, offset, tmp11, offset,
2387                     tmp8, tmp9, tmp10, tmp11);
2388         ADDS_SH4_SH(tmp12, offset, tmp13, offset, tmp14, offset, tmp15, offset,
2389                     tmp12, tmp13, tmp14, tmp15);
2390         MAXI_SH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 0);
2391         MAXI_SH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 0);
2392         SRLR_H8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, denom);
2393         SRLR_H8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, denom);
2394         SAT_UH8_SH(tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, 7);
2395         SAT_UH8_SH(tmp8, tmp9, tmp10, tmp11, tmp12, tmp13, tmp14, tmp15, 7);
2396         PCKEV_B4_UB(tmp1, tmp0, tmp3, tmp2, tmp5, tmp4, tmp7, tmp6, dst0, dst1,
2397                     dst2, dst3);
2398         PCKEV_B4_UB(tmp9, tmp8, tmp11, tmp10, tmp13, tmp12, tmp15, tmp14, dst4,
2399                     dst5, dst6, dst7);
2400         ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, src, stride);
2401     }
2402 }
2403
2404 void ff_weight_h264_pixels8_8_msa(uint8_t *src, ptrdiff_t stride,
2405                                   int height, int log2_denom,
2406                                   int weight_src, int offset)
2407 {
2408     if (4 == height) {
2409         avc_wgt_8x4_msa(src, stride, log2_denom, weight_src, offset);
2410     } else if (8 == height) {
2411         avc_wgt_8x8_msa(src, stride, log2_denom, weight_src, offset);
2412     } else {
2413         avc_wgt_8x16_msa(src, stride, log2_denom, weight_src, offset);
2414     }
2415 }
2416
2417 void ff_weight_h264_pixels4_8_msa(uint8_t *src, ptrdiff_t stride,
2418                                   int height, int log2_denom,
2419                                   int weight_src, int offset)
2420 {
2421     if (2 == height) {
2422         avc_wgt_4x2_msa(src, stride, log2_denom, weight_src, offset);
2423     } else if (4 == height) {
2424         avc_wgt_4x4_msa(src, stride, log2_denom, weight_src, offset);
2425     } else {
2426         avc_wgt_4x8_msa(src, stride, log2_denom, weight_src, offset);
2427     }
2428 }
2429
2430 void ff_biweight_h264_pixels16_8_msa(uint8_t *dst, uint8_t *src,
2431                                      ptrdiff_t stride, int height,
2432                                      int log2_denom, int weight_dst,
2433                                      int weight_src, int offset)
2434 {
2435     avc_biwgt_16width_msa(src, stride, dst, stride, height, log2_denom,
2436                           weight_src, weight_dst, offset);
2437 }
2438
2439 void ff_biweight_h264_pixels8_8_msa(uint8_t *dst, uint8_t *src,
2440                                     ptrdiff_t stride, int height,
2441                                     int log2_denom, int weight_dst,
2442                                     int weight_src, int offset)
2443 {
2444     avc_biwgt_8width_msa(src, stride, dst, stride, height, log2_denom,
2445                          weight_src, weight_dst, offset);
2446 }
2447
2448 void ff_biweight_h264_pixels4_8_msa(uint8_t *dst, uint8_t *src,
2449                                     ptrdiff_t stride, int height,
2450                                     int log2_denom, int weight_dst,
2451                                     int weight_src, int offset)
2452 {
2453     avc_biwgt_4width_msa(src, stride, dst, stride, height, log2_denom,
2454                          weight_src, weight_dst, offset);
2455 }