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