Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2015 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. #define AVC_CALC_DPADD_H_6PIX_2COEFF_SH(in0, in1, in2, in3, in4, in5)    \
  25. ( {                                                                      \
  26.     v4i32 tmp0_m, tmp1_m;                                                \
  27.     v8i16 out0_m, out1_m, out2_m, out3_m;                                \
  28.     v8i16 minus5h_m = __msa_ldi_h(-5);                                   \
  29.     v8i16 plus20h_m = __msa_ldi_h(20);                                   \
  30.                                                                          \
  31.     ILVRL_H2_SW(in5, in0, tmp0_m, tmp1_m);                               \
  32.                                                                          \
  33.     tmp0_m = __msa_hadd_s_w((v8i16) tmp0_m, (v8i16) tmp0_m);             \
  34.     tmp1_m = __msa_hadd_s_w((v8i16) tmp1_m, (v8i16) tmp1_m);             \
  35.                                                                          \
  36.     ILVRL_H2_SH(in1, in4, out0_m, out1_m);                               \
  37.     DPADD_SH2_SW(out0_m, out1_m, minus5h_m, minus5h_m, tmp0_m, tmp1_m);  \
  38.     ILVRL_H2_SH(in2, in3, out2_m, out3_m);                               \
  39.     DPADD_SH2_SW(out2_m, out3_m, plus20h_m, plus20h_m, tmp0_m, tmp1_m);  \
  40.                                                                          \
  41.     SRARI_W2_SW(tmp0_m, tmp1_m, 10);                                     \
  42.     SAT_SW2_SW(tmp0_m, tmp1_m, 7);                                       \
  43.     out0_m = __msa_pckev_h((v8i16) tmp1_m, (v8i16) tmp0_m);              \
  44.                                                                          \
  45.     out0_m;                                                              \
  46. } )
  47.  
  48. #define AVC_HORZ_FILTER_SH(in, mask0, mask1, mask2)     \
  49. ( {                                                     \
  50.     v8i16 out0_m, out1_m;                               \
  51.     v16i8 tmp0_m, tmp1_m;                               \
  52.     v16i8 minus5b = __msa_ldi_b(-5);                    \
  53.     v16i8 plus20b = __msa_ldi_b(20);                    \
  54.                                                         \
  55.     tmp0_m = __msa_vshf_b((v16i8) mask0, in, in);       \
  56.     out0_m = __msa_hadd_s_h(tmp0_m, tmp0_m);            \
  57.                                                         \
  58.     tmp0_m = __msa_vshf_b((v16i8) mask1, in, in);       \
  59.     out0_m = __msa_dpadd_s_h(out0_m, minus5b, tmp0_m);  \
  60.                                                         \
  61.     tmp1_m = __msa_vshf_b((v16i8) (mask2), in, in);     \
  62.     out1_m = __msa_dpadd_s_h(out0_m, plus20b, tmp1_m);  \
  63.                                                         \
  64.     out1_m;                                             \
  65. } )
  66.  
  67. static const uint8_t luma_mask_arr[16 * 8] = {
  68.     /* 8 width cases */
  69.     0, 5, 1, 6, 2, 7, 3, 8, 4, 9, 5, 10, 6, 11, 7, 12,
  70.     1, 4, 2, 5, 3, 6, 4, 7, 5, 8, 6, 9, 7, 10, 8, 11,
  71.     2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10,
  72.  
  73.     /* 4 width cases */
  74.     0, 5, 1, 6, 2, 7, 3, 8, 16, 21, 17, 22, 18, 23, 19, 24,
  75.     1, 4, 2, 5, 3, 6, 4, 7, 17, 20, 18, 21, 19, 22, 20, 23,
  76.     2, 3, 3, 4, 4, 5, 5, 6, 18, 19, 19, 20, 20, 21, 21, 22,
  77.  
  78.     2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25,
  79.     3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 24, 25, 26
  80. };
  81.  
  82. #define AVC_CALC_DPADD_B_6PIX_2COEFF_SH(vec0, vec1, vec2, vec3, vec4, vec5,  \
  83.                                         out1, out2)                          \
  84. {                                                                            \
  85.     v16i8 tmp0_m, tmp1_m;                                                    \
  86.     v16i8 minus5b_m = __msa_ldi_b(-5);                                       \
  87.     v16i8 plus20b_m = __msa_ldi_b(20);                                       \
  88.                                                                              \
  89.     ILVRL_B2_SB(vec5, vec0, tmp0_m, tmp1_m);                                 \
  90.     HADD_SB2_SH(tmp0_m, tmp1_m, out1, out2);                                 \
  91.     ILVRL_B2_SB(vec4, vec1, tmp0_m, tmp1_m);                                 \
  92.     DPADD_SB2_SH(tmp0_m, tmp1_m, minus5b_m, minus5b_m, out1, out2);          \
  93.     ILVRL_B2_SB(vec3, vec2, tmp0_m, tmp1_m);                                 \
  94.     DPADD_SB2_SH(tmp0_m, tmp1_m, plus20b_m, plus20b_m, out1, out2);          \
  95. }
  96.  
  97. #define AVC_CALC_DPADD_B_6PIX_2COEFF_R_SH(vec0, vec1, vec2, vec3, vec4, vec5)  \
  98. ( {                                                                            \
  99.     v8i16 tmp1_m;                                                              \
  100.     v16i8 tmp0_m, tmp2_m;                                                      \
  101.     v16i8 minus5b_m = __msa_ldi_b(-5);                                         \
  102.     v16i8 plus20b_m = __msa_ldi_b(20);                                         \
  103.                                                                                \
  104.     tmp1_m = (v8i16) __msa_ilvr_b((v16i8) vec5, (v16i8) vec0);                 \
  105.     tmp1_m = __msa_hadd_s_h((v16i8) tmp1_m, (v16i8) tmp1_m);                   \
  106.                                                                                \
  107.     ILVR_B2_SB(vec4, vec1, vec3, vec2, tmp0_m, tmp2_m);                        \
  108.     DPADD_SB2_SH(tmp0_m, tmp2_m, minus5b_m, plus20b_m, tmp1_m, tmp1_m);        \
  109.                                                                                \
  110.     tmp1_m;                                                                    \
  111. } )
  112.  
  113. #define AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(vec0, vec1, vec2, vec3, vec4, vec5)  \
  114. ( {                                                                            \
  115.     v4i32 tmp1_m;                                                              \
  116.     v8i16 tmp2_m, tmp3_m;                                                      \
  117.     v8i16 minus5h_m = __msa_ldi_h(-5);                                         \
  118.     v8i16 plus20h_m = __msa_ldi_h(20);                                         \
  119.                                                                                \
  120.     tmp1_m = (v4i32) __msa_ilvr_h((v8i16) vec5, (v8i16) vec0);                 \
  121.     tmp1_m = __msa_hadd_s_w((v8i16) tmp1_m, (v8i16) tmp1_m);                   \
  122.                                                                                \
  123.     ILVR_H2_SH(vec1, vec4, vec2, vec3, tmp2_m, tmp3_m);                        \
  124.     DPADD_SH2_SW(tmp2_m, tmp3_m, minus5h_m, plus20h_m, tmp1_m, tmp1_m);        \
  125.                                                                                \
  126.     tmp1_m = __msa_srari_w(tmp1_m, 10);                                        \
  127.     tmp1_m = __msa_sat_s_w(tmp1_m, 7);                                         \
  128.                                                                                \
  129.     tmp2_m = __msa_pckev_h((v8i16) tmp1_m, (v8i16) tmp1_m);                    \
  130.                                                                                \
  131.     tmp2_m;                                                                    \
  132. } )
  133.  
  134. #define AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,              \
  135.                                                     mask0, mask1, mask2)     \
  136. ( {                                                                          \
  137.     v8i16 hz_out_m;                                                          \
  138.     v16i8 vec0_m, vec1_m, vec2_m;                                            \
  139.     v16i8 minus5b_m = __msa_ldi_b(-5);                                       \
  140.     v16i8 plus20b_m = __msa_ldi_b(20);                                       \
  141.                                                                              \
  142.     vec0_m = __msa_vshf_b((v16i8) mask0, (v16i8) src1, (v16i8) src0);        \
  143.     hz_out_m = __msa_hadd_s_h(vec0_m, vec0_m);                               \
  144.                                                                              \
  145.     VSHF_B2_SB(src0, src1, src0, src1, mask1, mask2, vec1_m, vec2_m);        \
  146.     DPADD_SB2_SH(vec1_m, vec2_m, minus5b_m, plus20b_m, hz_out_m, hz_out_m);  \
  147.                                                                              \
  148.     hz_out_m;                                                                \
  149. } )
  150.  
  151. static void avc_luma_hz_4w_msa(const uint8_t *src, int32_t src_stride,
  152.                                uint8_t *dst, int32_t dst_stride,
  153.                                int32_t height)
  154. {
  155.     uint32_t loop_cnt;
  156.     v16i8 src0, src1, src2, src3;
  157.     v8i16 res0, res1;
  158.     v16u8 out;
  159.     v16i8 mask0, mask1, mask2;
  160.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  161.     v16i8 minus5b = __msa_ldi_b(-5);
  162.     v16i8 plus20b = __msa_ldi_b(20);
  163.  
  164.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  165.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  166.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  167.         src += (4 * src_stride);
  168.  
  169.         XORI_B4_128_SB(src0, src1, src2, src3);
  170.         VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
  171.         HADD_SB2_SH(vec0, vec1, res0, res1);
  172.         VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
  173.         DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, res0, res1);
  174.         VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
  175.         DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, res0, res1);
  176.         SRARI_H2_SH(res0, res1, 5);
  177.         SAT_SH2_SH(res0, res1, 7);
  178.         out = PCKEV_XORI128_UB(res0, res1);
  179.         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
  180.         dst += (4 * dst_stride);
  181.     }
  182. }
  183.  
  184. static void avc_luma_hz_8w_msa(const uint8_t *src, int32_t src_stride,
  185.                                uint8_t *dst, int32_t dst_stride,
  186.                                int32_t height)
  187. {
  188.     uint32_t loop_cnt;
  189.     v16i8 src0, src1, src2, src3;
  190.     v8i16 res0, res1, res2, res3;
  191.     v16i8 mask0, mask1, mask2;
  192.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  193.     v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
  194.     v16i8 minus5b = __msa_ldi_b(-5);
  195.     v16i8 plus20b = __msa_ldi_b(20);
  196.     v16u8 out0, out1;
  197.  
  198.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  199.  
  200.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  201.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  202.         src += (4 * src_stride);
  203.  
  204.         XORI_B4_128_SB(src0, src1, src2, src3);
  205.         VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
  206.         VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
  207.         HADD_SB4_SH(vec0, vec1, vec2, vec3, res0, res1, res2, res3);
  208.         VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
  209.         VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
  210.         DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
  211.                      res0, res1, res2, res3);
  212.         VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
  213.         VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
  214.         DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b,
  215.                      plus20b, res0, res1, res2, res3);
  216.         SRARI_H4_SH(res0, res1, res2, res3, 5);
  217.         SAT_SH4_SH(res0, res1, res2, res3, 7);
  218.         out0 = PCKEV_XORI128_UB(res0, res1);
  219.         out1 = PCKEV_XORI128_UB(res2, res3);
  220.         ST8x4_UB(out0, out1, dst, dst_stride);
  221.         dst += (4 * dst_stride);
  222.     }
  223. }
  224.  
  225. static void avc_luma_hz_16w_msa(const uint8_t *src, int32_t src_stride,
  226.                                 uint8_t *dst, int32_t dst_stride,
  227.                                 int32_t height)
  228. {
  229.     uint32_t loop_cnt;
  230.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  231.     v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
  232.     v16i8 mask0, mask1, mask2;
  233.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  234.     v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
  235.     v16i8 minus5b = __msa_ldi_b(-5);
  236.     v16i8 plus20b = __msa_ldi_b(20);
  237.  
  238.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  239.  
  240.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  241.         LD_SB2(src, 8, src0, src1);
  242.         src += src_stride;
  243.         LD_SB2(src, 8, src2, src3);
  244.         src += src_stride;
  245.  
  246.         XORI_B4_128_SB(src0, src1, src2, src3);
  247.         VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec3);
  248.         VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec6, vec9);
  249.         VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec1, vec4);
  250.         VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec7, vec10);
  251.         VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec2, vec5);
  252.         VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec8, vec11);
  253.         HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
  254.         DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
  255.                      minus5b, res0, res1, res2, res3);
  256.         DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
  257.                      plus20b, res0, res1, res2, res3);
  258.  
  259.         LD_SB2(src, 8, src4, src5);
  260.         src += src_stride;
  261.         LD_SB2(src, 8, src6, src7);
  262.         src += src_stride;
  263.  
  264.         XORI_B4_128_SB(src4, src5, src6, src7);
  265.         VSHF_B2_SB(src4, src4, src5, src5, mask0, mask0, vec0, vec3);
  266.         VSHF_B2_SB(src6, src6, src7, src7, mask0, mask0, vec6, vec9);
  267.         VSHF_B2_SB(src4, src4, src5, src5, mask1, mask1, vec1, vec4);
  268.         VSHF_B2_SB(src6, src6, src7, src7, mask1, mask1, vec7, vec10);
  269.         VSHF_B2_SB(src4, src4, src5, src5, mask2, mask2, vec2, vec5);
  270.         VSHF_B2_SB(src6, src6, src7, src7, mask2, mask2, vec8, vec11);
  271.         HADD_SB4_SH(vec0, vec3, vec6, vec9, res4, res5, res6, res7);
  272.         DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
  273.                      minus5b, res4, res5, res6, res7);
  274.         DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
  275.                      plus20b, res4, res5, res6, res7);
  276.         SRARI_H4_SH(res0, res1, res2, res3, 5);
  277.         SRARI_H4_SH(res4, res5, res6, res7, 5);
  278.         SAT_SH4_SH(res0, res1, res2, res3, 7);
  279.         SAT_SH4_SH(res4, res5, res6, res7, 7);
  280.         PCKEV_B4_SB(res1, res0, res3, res2, res5, res4, res7, res6,
  281.                     vec0, vec1, vec2, vec3);
  282.         XORI_B4_128_SB(vec0, vec1, vec2, vec3);
  283.  
  284.         ST_SB4(vec0, vec1, vec2, vec3, dst, dst_stride);
  285.         dst += (4 * dst_stride);
  286.     }
  287. }
  288.  
  289. static void avc_luma_hz_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
  290.                                    uint8_t *dst, int32_t dst_stride,
  291.                                    int32_t height, uint8_t hor_offset)
  292. {
  293.     uint8_t slide;
  294.     uint32_t loop_cnt;
  295.     v16i8 src0, src1, src2, src3;
  296.     v8i16 res0, res1;
  297.     v16i8 res, mask0, mask1, mask2;
  298.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  299.     v16i8 minus5b = __msa_ldi_b(-5);
  300.     v16i8 plus20b = __msa_ldi_b(20);
  301.  
  302.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  303.     slide = 2 + hor_offset;
  304.  
  305.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  306.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  307.         src += (4 * src_stride);
  308.  
  309.         XORI_B4_128_SB(src0, src1, src2, src3);
  310.         VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
  311.         HADD_SB2_SH(vec0, vec1, res0, res1);
  312.         VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
  313.         DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, res0, res1);
  314.         VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
  315.         DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, res0, res1);
  316.         SRARI_H2_SH(res0, res1, 5);
  317.         SAT_SH2_SH(res0, res1, 7);
  318.  
  319.         res = __msa_pckev_b((v16i8) res1, (v16i8) res0);
  320.         src0 = __msa_sld_b(src0, src0, slide);
  321.         src1 = __msa_sld_b(src1, src1, slide);
  322.         src2 = __msa_sld_b(src2, src2, slide);
  323.         src3 = __msa_sld_b(src3, src3, slide);
  324.         src0 = (v16i8) __msa_insve_w((v4i32) src0, 1, (v4i32) src1);
  325.         src1 = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
  326.         src0 = (v16i8) __msa_insve_d((v2i64) src0, 1, (v2i64) src1);
  327.         res = __msa_aver_s_b(res, src0);
  328.         res = (v16i8) __msa_xori_b((v16u8) res, 128);
  329.  
  330.         ST4x4_UB(res, res, 0, 1, 2, 3, dst, dst_stride);
  331.         dst += (4 * dst_stride);
  332.     }
  333. }
  334.  
  335. static void avc_luma_hz_qrt_8w_msa(const uint8_t *src, int32_t src_stride,
  336.                                    uint8_t *dst, int32_t dst_stride,
  337.                                    int32_t height, uint8_t hor_offset)
  338. {
  339.     uint8_t slide;
  340.     uint32_t loop_cnt;
  341.     v16i8 src0, src1, src2, src3;
  342.     v16i8 tmp0, tmp1;
  343.     v8i16 res0, res1, res2, res3;
  344.     v16i8 mask0, mask1, mask2;
  345.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  346.     v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
  347.     v16i8 minus5b = __msa_ldi_b(-5);
  348.     v16i8 plus20b = __msa_ldi_b(20);
  349.  
  350.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  351.     slide = 2 + hor_offset;
  352.  
  353.     for (loop_cnt = height >> 2; loop_cnt--;) {
  354.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  355.         src += (4 * src_stride);
  356.  
  357.         XORI_B4_128_SB(src0, src1, src2, src3);
  358.         VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
  359.         VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
  360.         HADD_SB4_SH(vec0, vec1, vec2, vec3, res0, res1, res2, res3);
  361.         VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
  362.         VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
  363.         DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
  364.                      res0, res1, res2, res3);
  365.         VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
  366.         VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
  367.         DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b,
  368.                      plus20b, res0, res1, res2, res3);
  369.  
  370.         src0 = __msa_sld_b(src0, src0, slide);
  371.         src1 = __msa_sld_b(src1, src1, slide);
  372.         src2 = __msa_sld_b(src2, src2, slide);
  373.         src3 = __msa_sld_b(src3, src3, slide);
  374.  
  375.         SRARI_H4_SH(res0, res1, res2, res3, 5);
  376.         SAT_SH4_SH(res0, res1, res2, res3, 7);
  377.         PCKEV_B2_SB(res1, res0, res3, res2, tmp0, tmp1);
  378.         PCKEV_D2_SB(src1, src0, src3, src2, src0, src1);
  379.  
  380.         tmp0 = __msa_aver_s_b(tmp0, src0);
  381.         tmp1 = __msa_aver_s_b(tmp1, src1);
  382.  
  383.         XORI_B2_128_SB(tmp0, tmp1);
  384.         ST8x4_UB(tmp0, tmp1, dst, dst_stride);
  385.  
  386.         dst += (4 * dst_stride);
  387.     }
  388. }
  389.  
  390. static void avc_luma_hz_qrt_16w_msa(const uint8_t *src, int32_t src_stride,
  391.                                     uint8_t *dst, int32_t dst_stride,
  392.                                     int32_t height, uint8_t hor_offset)
  393. {
  394.     uint32_t loop_cnt;
  395.     v16i8 dst0, dst1;
  396.     v16i8 src0, src1, src2, src3;
  397.     v16i8 mask0, mask1, mask2, vshf;
  398.     v8i16 res0, res1, res2, res3;
  399.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  400.     v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
  401.     v16i8 minus5b = __msa_ldi_b(-5);
  402.     v16i8 plus20b = __msa_ldi_b(20);
  403.  
  404.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  405.  
  406.     if (hor_offset) {
  407.         vshf = LD_SB(&luma_mask_arr[16 + 96]);
  408.     } else {
  409.         vshf = LD_SB(&luma_mask_arr[96]);
  410.     }
  411.  
  412.     for (loop_cnt = height >> 1; loop_cnt--;) {
  413.         LD_SB2(src, 8, src0, src1);
  414.         src += src_stride;
  415.         LD_SB2(src, 8, src2, src3);
  416.         src += src_stride;
  417.  
  418.         XORI_B4_128_SB(src0, src1, src2, src3);
  419.         VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec3);
  420.         VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec6, vec9);
  421.         VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec1, vec4);
  422.         VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec7, vec10);
  423.         VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec2, vec5);
  424.         VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec8, vec11);
  425.         HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
  426.         DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
  427.                      minus5b, res0, res1, res2, res3);
  428.         DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
  429.                      plus20b, res0, res1, res2, res3);
  430.         VSHF_B2_SB(src0, src1, src2, src3, vshf, vshf, src0, src2);
  431.         SRARI_H4_SH(res0, res1, res2, res3, 5);
  432.         SAT_SH4_SH(res0, res1, res2, res3, 7);
  433.         PCKEV_B2_SB(res1, res0, res3, res2, dst0, dst1);
  434.  
  435.         dst0 = __msa_aver_s_b(dst0, src0);
  436.         dst1 = __msa_aver_s_b(dst1, src2);
  437.  
  438.         XORI_B2_128_SB(dst0, dst1);
  439.  
  440.         ST_SB2(dst0, dst1, dst, dst_stride);
  441.         dst += (2 * dst_stride);
  442.     }
  443. }
  444.  
  445. static void avc_luma_vt_4w_msa(const uint8_t *src, int32_t src_stride,
  446.                                uint8_t *dst, int32_t dst_stride,
  447.                                int32_t height)
  448. {
  449.     int32_t loop_cnt;
  450.     int16_t filt_const0 = 0xfb01;
  451.     int16_t filt_const1 = 0x1414;
  452.     int16_t filt_const2 = 0x1fb;
  453.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  454.     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
  455.     v16i8 src87_r, src2110, src4332, src6554, src8776;
  456.     v16i8 filt0, filt1, filt2;
  457.     v8i16 out10, out32;
  458.     v16u8 out;
  459.  
  460.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  461.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  462.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  463.  
  464.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  465.     src += (5 * src_stride);
  466.  
  467.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  468.                src10_r, src21_r, src32_r, src43_r);
  469.     ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
  470.     XORI_B2_128_SB(src2110, src4332);
  471.  
  472.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  473.         LD_SB4(src, src_stride, src5, src6, src7, src8);
  474.         src += (4 * src_stride);
  475.  
  476.         ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  477.                    src54_r, src65_r, src76_r, src87_r);
  478.         ILVR_D2_SB(src65_r, src54_r, src87_r, src76_r, src6554, src8776);
  479.         XORI_B2_128_SB(src6554, src8776);
  480.         out10 = DPADD_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
  481.         out32 = DPADD_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
  482.         SRARI_H2_SH(out10, out32, 5);
  483.         SAT_SH2_SH(out10, out32, 7);
  484.         out = PCKEV_XORI128_UB(out10, out32);
  485.         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
  486.  
  487.         dst += (4 * dst_stride);
  488.         src2110 = src6554;
  489.         src4332 = src8776;
  490.         src4 = src8;
  491.     }
  492. }
  493.  
  494. static void avc_luma_vt_8w_msa(const uint8_t *src, int32_t src_stride,
  495.                                uint8_t *dst, int32_t dst_stride,
  496.                                int32_t height)
  497. {
  498.     int32_t loop_cnt;
  499.     int16_t filt_const0 = 0xfb01;
  500.     int16_t filt_const1 = 0x1414;
  501.     int16_t filt_const2 = 0x1fb;
  502.     v16i8 src0, src1, src2, src3, src4, src7, src8, src9, src10;
  503.     v16i8 src10_r, src32_r, src76_r, src98_r;
  504.     v16i8 src21_r, src43_r, src87_r, src109_r;
  505.     v8i16 out0_r, out1_r, out2_r, out3_r;
  506.     v16i8 filt0, filt1, filt2;
  507.     v16u8 out0, out1;
  508.  
  509.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  510.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  511.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  512.  
  513.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  514.     src += (5 * src_stride);
  515.  
  516.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  517.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  518.                src10_r, src21_r, src32_r, src43_r);
  519.  
  520.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  521.         LD_SB4(src, src_stride, src7, src8, src9, src10);
  522.         src += (4 * src_stride);
  523.  
  524.         XORI_B4_128_SB(src7, src8, src9, src10);
  525.         ILVR_B4_SB(src7, src4, src8, src7, src9, src8, src10, src9,
  526.                    src76_r, src87_r, src98_r, src109_r);
  527.         out0_r = DPADD_SH3_SH(src10_r, src32_r, src76_r, filt0, filt1, filt2);
  528.         out1_r = DPADD_SH3_SH(src21_r, src43_r, src87_r, filt0, filt1, filt2);
  529.         out2_r = DPADD_SH3_SH(src32_r, src76_r, src98_r, filt0, filt1, filt2);
  530.         out3_r = DPADD_SH3_SH(src43_r, src87_r, src109_r, filt0, filt1, filt2);
  531.         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
  532.         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
  533.         out0 = PCKEV_XORI128_UB(out0_r, out1_r);
  534.         out1 = PCKEV_XORI128_UB(out2_r, out3_r);
  535.         ST8x4_UB(out0, out1, dst, dst_stride);
  536.         dst += (4 * dst_stride);
  537.  
  538.         src10_r = src76_r;
  539.         src32_r = src98_r;
  540.         src21_r = src87_r;
  541.         src43_r = src109_r;
  542.         src4 = src10;
  543.     }
  544. }
  545.  
  546. static void avc_luma_vt_16w_msa(const uint8_t *src, int32_t src_stride,
  547.                                 uint8_t *dst, int32_t dst_stride,
  548.                                 int32_t height)
  549. {
  550.     int32_t loop_cnt;
  551.     int16_t filt_const0 = 0xfb01;
  552.     int16_t filt_const1 = 0x1414;
  553.     int16_t filt_const2 = 0x1fb;
  554.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  555.     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
  556.     v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
  557.     v16i8 src65_l, src87_l;
  558.     v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
  559.     v16u8 res0, res1, res2, res3;
  560.     v16i8 filt0, filt1, filt2;
  561.  
  562.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  563.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  564.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  565.  
  566.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  567.     src += (5 * src_stride);
  568.  
  569.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  570.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  571.                src10_r, src21_r, src32_r, src43_r);
  572.     ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  573.                src10_l, src21_l, src32_l, src43_l);
  574.  
  575.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  576.         LD_SB4(src, src_stride, src5, src6, src7, src8);
  577.         src += (4 * src_stride);
  578.  
  579.         XORI_B4_128_SB(src5, src6, src7, src8);
  580.         ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  581.                    src54_r, src65_r, src76_r, src87_r);
  582.         ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  583.                    src54_l, src65_l, src76_l, src87_l);
  584.         out0_r = DPADD_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
  585.         out1_r = DPADD_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
  586.         out2_r = DPADD_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
  587.         out3_r = DPADD_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
  588.         out0_l = DPADD_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
  589.         out1_l = DPADD_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
  590.         out2_l = DPADD_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
  591.         out3_l = DPADD_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
  592.         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
  593.         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
  594.         SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
  595.         SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
  596.         PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
  597.                     out3_r, res0, res1, res2, res3);
  598.         XORI_B4_128_UB(res0, res1, res2, res3);
  599.  
  600.         ST_UB4(res0, res1, res2, res3, dst, dst_stride);
  601.         dst += (4 * dst_stride);
  602.  
  603.         src10_r = src54_r;
  604.         src32_r = src76_r;
  605.         src21_r = src65_r;
  606.         src43_r = src87_r;
  607.         src10_l = src54_l;
  608.         src32_l = src76_l;
  609.         src21_l = src65_l;
  610.         src43_l = src87_l;
  611.         src4 = src8;
  612.     }
  613. }
  614.  
  615. static void avc_luma_vt_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
  616.                                    uint8_t *dst, int32_t dst_stride,
  617.                                    int32_t height, uint8_t ver_offset)
  618. {
  619.     int32_t loop_cnt;
  620.     int16_t filt_const0 = 0xfb01;
  621.     int16_t filt_const1 = 0x1414;
  622.     int16_t filt_const2 = 0x1fb;
  623.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  624.     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
  625.     v16i8 src87_r, src2110, src4332, src6554, src8776;
  626.     v8i16 out10, out32;
  627.     v16i8 filt0, filt1, filt2;
  628.     v16u8 out;
  629.  
  630.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  631.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  632.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  633.  
  634.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  635.     src += (5 * src_stride);
  636.  
  637.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  638.                src10_r, src21_r, src32_r, src43_r);
  639.     ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
  640.     XORI_B2_128_SB(src2110, src4332);
  641.  
  642.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  643.         LD_SB4(src, src_stride, src5, src6, src7, src8);
  644.         src += (4 * src_stride);
  645.  
  646.         ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  647.                    src54_r, src65_r, src76_r, src87_r);
  648.         ILVR_D2_SB(src65_r, src54_r, src87_r, src76_r, src6554, src8776);
  649.         XORI_B2_128_SB(src6554, src8776);
  650.         out10 = DPADD_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
  651.         out32 = DPADD_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
  652.         SRARI_H2_SH(out10, out32, 5);
  653.         SAT_SH2_SH(out10, out32, 7);
  654.  
  655.         out = PCKEV_XORI128_UB(out10, out32);
  656.  
  657.         if (ver_offset) {
  658.             src32_r = (v16i8) __msa_insve_w((v4i32) src3, 1, (v4i32) src4);
  659.             src54_r = (v16i8) __msa_insve_w((v4i32) src5, 1, (v4i32) src6);
  660.         } else {
  661.             src32_r = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
  662.             src54_r = (v16i8) __msa_insve_w((v4i32) src4, 1, (v4i32) src5);
  663.         }
  664.  
  665.         src32_r = (v16i8) __msa_insve_d((v2i64) src32_r, 1, (v2i64) src54_r);
  666.         out = __msa_aver_u_b(out, (v16u8) src32_r);
  667.  
  668.         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
  669.         dst += (4 * dst_stride);
  670.         src2110 = src6554;
  671.         src4332 = src8776;
  672.         src2 = src6;
  673.         src3 = src7;
  674.         src4 = src8;
  675.     }
  676. }
  677.  
  678. static void avc_luma_vt_qrt_8w_msa(const uint8_t *src, int32_t src_stride,
  679.                                    uint8_t *dst, int32_t dst_stride,
  680.                                    int32_t height, uint8_t ver_offset)
  681. {
  682.     int32_t loop_cnt;
  683.     int16_t filt_const0 = 0xfb01;
  684.     int16_t filt_const1 = 0x1414;
  685.     int16_t filt_const2 = 0x1fb;
  686.     v16i8 src0, src1, src2, src3, src4, src7, src8, src9, src10;
  687.     v16i8 src10_r, src32_r, src76_r, src98_r;
  688.     v16i8 src21_r, src43_r, src87_r, src109_r;
  689.     v8i16 out0_r, out1_r, out2_r, out3_r;
  690.     v16i8 res0, res1;
  691.     v16i8 filt0, filt1, filt2;
  692.  
  693.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  694.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  695.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  696.  
  697.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  698.     src += (5 * src_stride);
  699.  
  700.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  701.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  702.                src10_r, src21_r, src32_r, src43_r);
  703.  
  704.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  705.         LD_SB4(src, src_stride, src7, src8, src9, src10);
  706.         src += (4 * src_stride);
  707.  
  708.         XORI_B4_128_SB(src7, src8, src9, src10);
  709.         ILVR_B4_SB(src7, src4, src8, src7, src9, src8, src10, src9,
  710.                    src76_r, src87_r, src98_r, src109_r);
  711.         out0_r = DPADD_SH3_SH(src10_r, src32_r, src76_r, filt0, filt1, filt2);
  712.         out1_r = DPADD_SH3_SH(src21_r, src43_r, src87_r, filt0, filt1, filt2);
  713.         out2_r = DPADD_SH3_SH(src32_r, src76_r, src98_r, filt0, filt1, filt2);
  714.         out3_r = DPADD_SH3_SH(src43_r, src87_r, src109_r, filt0, filt1, filt2);
  715.         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
  716.         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
  717.         PCKEV_B2_SB(out1_r, out0_r, out3_r, out2_r, res0, res1);
  718.  
  719.         if (ver_offset) {
  720.             PCKEV_D2_SB(src4, src3, src8, src7, src10_r, src32_r);
  721.         } else {
  722.             PCKEV_D2_SB(src3, src2, src7, src4, src10_r, src32_r);
  723.         }
  724.  
  725.         res0 = __msa_aver_s_b(res0, (v16i8) src10_r);
  726.         res1 = __msa_aver_s_b(res1, (v16i8) src32_r);
  727.  
  728.         XORI_B2_128_SB(res0, res1);
  729.         ST8x4_UB(res0, res1, dst, dst_stride);
  730.  
  731.         dst += (4 * dst_stride);
  732.         src10_r = src76_r;
  733.         src32_r = src98_r;
  734.         src21_r = src87_r;
  735.         src43_r = src109_r;
  736.         src2 = src8;
  737.         src3 = src9;
  738.         src4 = src10;
  739.     }
  740. }
  741.  
  742. static void avc_luma_vt_qrt_16w_msa(const uint8_t *src, int32_t src_stride,
  743.                                     uint8_t *dst, int32_t dst_stride,
  744.                                     int32_t height, uint8_t ver_offset)
  745. {
  746.     int32_t loop_cnt;
  747.     int16_t filt_const0 = 0xfb01;
  748.     int16_t filt_const1 = 0x1414;
  749.     int16_t filt_const2 = 0x1fb;
  750.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  751.     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
  752.     v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
  753.     v16i8 src65_l, src87_l;
  754.     v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
  755.     v16u8 res0, res1, res2, res3;
  756.     v16i8 filt0, filt1, filt2;
  757.  
  758.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  759.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  760.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  761.  
  762.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  763.     src += (5 * src_stride);
  764.  
  765.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  766.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  767.                src10_r, src21_r, src32_r, src43_r);
  768.     ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  769.                src10_l, src21_l, src32_l, src43_l);
  770.  
  771.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  772.         LD_SB4(src, src_stride, src5, src6, src7, src8);
  773.         src += (4 * src_stride);
  774.  
  775.         XORI_B4_128_SB(src5, src6, src7, src8);
  776.         ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  777.                    src54_r, src65_r, src76_r, src87_r);
  778.         ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  779.                    src54_l, src65_l, src76_l, src87_l);
  780.         out0_r = DPADD_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
  781.         out1_r = DPADD_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
  782.         out2_r = DPADD_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
  783.         out3_r = DPADD_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
  784.         out0_l = DPADD_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
  785.         out1_l = DPADD_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
  786.         out2_l = DPADD_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
  787.         out3_l = DPADD_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
  788.         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
  789.         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
  790.         SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
  791.         SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
  792.         PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
  793.                     out3_r, res0, res1, res2, res3);
  794.  
  795.         if (ver_offset) {
  796.             res0 = (v16u8) __msa_aver_s_b((v16i8) res0, src3);
  797.             res1 = (v16u8) __msa_aver_s_b((v16i8) res1, src4);
  798.             res2 = (v16u8) __msa_aver_s_b((v16i8) res2, src5);
  799.             res3 = (v16u8) __msa_aver_s_b((v16i8) res3, src6);
  800.         } else {
  801.             res0 = (v16u8) __msa_aver_s_b((v16i8) res0, src2);
  802.             res1 = (v16u8) __msa_aver_s_b((v16i8) res1, src3);
  803.             res2 = (v16u8) __msa_aver_s_b((v16i8) res2, src4);
  804.             res3 = (v16u8) __msa_aver_s_b((v16i8) res3, src5);
  805.         }
  806.  
  807.         XORI_B4_128_UB(res0, res1, res2, res3);
  808.         ST_UB4(res0, res1, res2, res3, dst, dst_stride);
  809.  
  810.         dst += (4 * dst_stride);
  811.  
  812.         src10_r = src54_r;
  813.         src32_r = src76_r;
  814.         src21_r = src65_r;
  815.         src43_r = src87_r;
  816.         src10_l = src54_l;
  817.         src32_l = src76_l;
  818.         src21_l = src65_l;
  819.         src43_l = src87_l;
  820.         src2 = src6;
  821.         src3 = src7;
  822.         src4 = src8;
  823.     }
  824. }
  825.  
  826. static void avc_luma_mid_4w_msa(const uint8_t *src, int32_t src_stride,
  827.                                 uint8_t *dst, int32_t dst_stride,
  828.                                 int32_t height)
  829. {
  830.     uint32_t loop_cnt;
  831.     v16i8 src0, src1, src2, src3, src4;
  832.     v16i8 mask0, mask1, mask2;
  833.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  834.     v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
  835.     v8i16 dst0, dst1, dst2, dst3;
  836.  
  837.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  838.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  839.     src += (5 * src_stride);
  840.  
  841.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  842.  
  843.     hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
  844.                                                           mask0, mask1, mask2);
  845.     hz_out2 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
  846.                                                           mask0, mask1, mask2);
  847.  
  848.     PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
  849.  
  850.     hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
  851.  
  852.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  853.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  854.         src += (4 * src_stride);
  855.  
  856.         XORI_B4_128_SB(src0, src1, src2, src3);
  857.  
  858.         hz_out5 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
  859.                                                               mask0, mask1,
  860.                                                               mask2);
  861.         hz_out7 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
  862.                                                               mask0, mask1,
  863.                                                               mask2);
  864.  
  865.         PCKOD_D2_SH(hz_out5, hz_out5, hz_out7, hz_out7, hz_out6, hz_out8);
  866.  
  867.         dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out0, hz_out1, hz_out2,
  868.                                                  hz_out3, hz_out4, hz_out5);
  869.         dst1 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out1, hz_out2, hz_out3,
  870.                                                  hz_out4, hz_out5, hz_out6);
  871.         dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out2, hz_out3, hz_out4,
  872.                                                  hz_out5, hz_out6, hz_out7);
  873.         dst3 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out3, hz_out4, hz_out5,
  874.                                                  hz_out6, hz_out7, hz_out8);
  875.  
  876.         PCKEV_B2_SB(dst1, dst0, dst3, dst2, src0, src1);
  877.         XORI_B2_128_SB(src0, src1);
  878.  
  879.         ST4x4_UB(src0, src1, 0, 2, 0, 2, dst, dst_stride);
  880.  
  881.         dst += (4 * dst_stride);
  882.  
  883.         hz_out0 = hz_out4;
  884.         hz_out1 = hz_out5;
  885.         hz_out2 = hz_out6;
  886.         hz_out3 = hz_out7;
  887.         hz_out4 = hz_out8;
  888.     }
  889. }
  890.  
  891. static void avc_luma_mid_8w_msa(const uint8_t *src, int32_t src_stride,
  892.                                 uint8_t *dst, int32_t dst_stride,
  893.                                 int32_t height)
  894. {
  895.     uint32_t loop_cnt;
  896.     v16i8 src0, src1, src2, src3, src4;
  897.     v16i8 mask0, mask1, mask2;
  898.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  899.     v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
  900.     v8i16 dst0, dst1, dst2, dst3;
  901.     v16u8 out0, out1;
  902.  
  903.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  904.  
  905.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  906.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  907.     src += (5 * src_stride);
  908.  
  909.     hz_out0 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
  910.     hz_out1 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
  911.     hz_out2 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
  912.     hz_out3 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
  913.     hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
  914.  
  915.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  916.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  917.         XORI_B4_128_SB(src0, src1, src2, src3);
  918.         src += (4 * src_stride);
  919.  
  920.         hz_out5 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
  921.         hz_out6 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
  922.         hz_out7 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
  923.         hz_out8 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
  924.         dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
  925.                                                hz_out3, hz_out4, hz_out5);
  926.         dst1 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
  927.                                                hz_out4, hz_out5, hz_out6);
  928.         dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
  929.                                                hz_out5, hz_out6, hz_out7);
  930.         dst3 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
  931.                                                hz_out6, hz_out7, hz_out8);
  932.         out0 = PCKEV_XORI128_UB(dst0, dst1);
  933.         out1 = PCKEV_XORI128_UB(dst2, dst3);
  934.         ST8x4_UB(out0, out1, dst, dst_stride);
  935.  
  936.         dst += (4 * dst_stride);
  937.         hz_out3 = hz_out7;
  938.         hz_out1 = hz_out5;
  939.         hz_out5 = hz_out4;
  940.         hz_out4 = hz_out8;
  941.         hz_out2 = hz_out6;
  942.         hz_out0 = hz_out5;
  943.     }
  944. }
  945.  
  946. static void avc_luma_mid_16w_msa(const uint8_t *src, int32_t src_stride,
  947.                                  uint8_t *dst, int32_t dst_stride,
  948.                                  int32_t height)
  949. {
  950.     uint32_t multiple8_cnt;
  951.  
  952.     for (multiple8_cnt = 2; multiple8_cnt--;) {
  953.         avc_luma_mid_8w_msa(src, src_stride, dst, dst_stride, height);
  954.         src += 8;
  955.         dst += 8;
  956.     }
  957. }
  958.  
  959. static void avc_luma_midh_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
  960.                                      uint8_t *dst, int32_t dst_stride,
  961.                                      int32_t height, uint8_t horiz_offset)
  962. {
  963.     uint32_t row;
  964.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  965.     v8i16 vt_res0, vt_res1, vt_res2, vt_res3;
  966.     v4i32 hz_res0, hz_res1;
  967.     v8i16 dst0, dst1;
  968.     v8i16 shf_vec0, shf_vec1, shf_vec2, shf_vec3, shf_vec4, shf_vec5;
  969.     v8i16 mask0 = { 0, 5, 1, 6, 2, 7, 3, 8 };
  970.     v8i16 mask1 = { 1, 4, 2, 5, 3, 6, 4, 7 };
  971.     v8i16 mask2 = { 2, 3, 3, 4, 4, 5, 5, 6 };
  972.     v8i16 minus5h = __msa_ldi_h(-5);
  973.     v8i16 plus20h = __msa_ldi_h(20);
  974.     v8i16 zeros = { 0 };
  975.     v16u8 out;
  976.  
  977.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  978.     src += (5 * src_stride);
  979.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  980.  
  981.     for (row = (height >> 1); row--;) {
  982.         LD_SB2(src, src_stride, src5, src6);
  983.         src += (2 * src_stride);
  984.  
  985.         XORI_B2_128_SB(src5, src6);
  986.         AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src0, src1, src2, src3, src4, src5,
  987.                                         vt_res0, vt_res1);
  988.         AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src1, src2, src3, src4, src5, src6,
  989.                                         vt_res2, vt_res3);
  990.         VSHF_H3_SH(vt_res0, vt_res1, vt_res0, vt_res1, vt_res0, vt_res1,
  991.                    mask0, mask1, mask2, shf_vec0, shf_vec1, shf_vec2);
  992.         VSHF_H3_SH(vt_res2, vt_res3, vt_res2, vt_res3, vt_res2, vt_res3,
  993.                    mask0, mask1, mask2, shf_vec3, shf_vec4, shf_vec5);
  994.         hz_res0 = __msa_hadd_s_w(shf_vec0, shf_vec0);
  995.         DPADD_SH2_SW(shf_vec1, shf_vec2, minus5h, plus20h, hz_res0, hz_res0);
  996.         hz_res1 = __msa_hadd_s_w(shf_vec3, shf_vec3);
  997.         DPADD_SH2_SW(shf_vec4, shf_vec5, minus5h, plus20h, hz_res1, hz_res1);
  998.  
  999.         SRARI_W2_SW(hz_res0, hz_res1, 10);
  1000.         SAT_SW2_SW(hz_res0, hz_res1, 7);
  1001.  
  1002.         dst0 = __msa_srari_h(shf_vec2, 5);
  1003.         dst1 = __msa_srari_h(shf_vec5, 5);
  1004.  
  1005.         SAT_SH2_SH(dst0, dst1, 7);
  1006.  
  1007.         if (horiz_offset) {
  1008.             dst0 = __msa_ilvod_h(zeros, dst0);
  1009.             dst1 = __msa_ilvod_h(zeros, dst1);
  1010.         } else {
  1011.             ILVEV_H2_SH(dst0, zeros, dst1, zeros, dst0, dst1);
  1012.         }
  1013.  
  1014.         hz_res0 = __msa_aver_s_w(hz_res0, (v4i32) dst0);
  1015.         hz_res1 = __msa_aver_s_w(hz_res1, (v4i32) dst1);
  1016.         dst0 = __msa_pckev_h((v8i16) hz_res1, (v8i16) hz_res0);
  1017.  
  1018.         out = PCKEV_XORI128_UB(dst0, dst0);
  1019.         ST4x2_UB(out, dst, dst_stride);
  1020.  
  1021.         dst += (2 * dst_stride);
  1022.  
  1023.         src0 = src2;
  1024.         src1 = src3;
  1025.         src2 = src4;
  1026.         src3 = src5;
  1027.         src4 = src6;
  1028.     }
  1029. }
  1030.  
  1031. static void avc_luma_midh_qrt_8w_msa(const uint8_t *src, int32_t src_stride,
  1032.                                      uint8_t *dst, int32_t dst_stride,
  1033.                                      int32_t height, uint8_t horiz_offset)
  1034. {
  1035.     uint32_t multiple8_cnt;
  1036.  
  1037.     for (multiple8_cnt = 2; multiple8_cnt--;) {
  1038.         avc_luma_midh_qrt_4w_msa(src, src_stride, dst, dst_stride, height,
  1039.                                  horiz_offset);
  1040.  
  1041.         src += 4;
  1042.         dst += 4;
  1043.     }
  1044. }
  1045.  
  1046. static void avc_luma_midh_qrt_16w_msa(const uint8_t *src, int32_t src_stride,
  1047.                                       uint8_t *dst, int32_t dst_stride,
  1048.                                       int32_t height, uint8_t horiz_offset)
  1049. {
  1050.     uint32_t multiple8_cnt;
  1051.  
  1052.     for (multiple8_cnt = 4; multiple8_cnt--;) {
  1053.         avc_luma_midh_qrt_4w_msa(src, src_stride, dst, dst_stride, height,
  1054.                                  horiz_offset);
  1055.  
  1056.         src += 4;
  1057.         dst += 4;
  1058.     }
  1059. }
  1060.  
  1061. static void avc_luma_midv_qrt_4w_msa(const uint8_t *src, int32_t src_stride,
  1062.                                      uint8_t *dst, int32_t dst_stride,
  1063.                                      int32_t height, uint8_t ver_offset)
  1064. {
  1065.     uint32_t loop_cnt;
  1066.     v16i8 src0, src1, src2, src3, src4;
  1067.     v16i8 mask0, mask1, mask2;
  1068.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  1069.     v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
  1070.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
  1071.  
  1072.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  1073.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  1074.     src += (5 * src_stride);
  1075.  
  1076.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  1077.  
  1078.     hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
  1079.                                                           mask0, mask1, mask2);
  1080.     hz_out2 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
  1081.                                                           mask0, mask1, mask2);
  1082.  
  1083.     PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
  1084.  
  1085.     hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
  1086.  
  1087.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1088.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  1089.         src += (4 * src_stride);
  1090.         XORI_B4_128_SB(src0, src1, src2, src3);
  1091.  
  1092.         hz_out5 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
  1093.                                                               mask0, mask1,
  1094.                                                               mask2);
  1095.         hz_out7 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
  1096.                                                               mask0, mask1,
  1097.                                                               mask2);
  1098.  
  1099.         PCKOD_D2_SH(hz_out5, hz_out5, hz_out7, hz_out7, hz_out6, hz_out8);
  1100.  
  1101.         dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
  1102.                                                hz_out3, hz_out4, hz_out5);
  1103.         dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
  1104.                                                hz_out4, hz_out5, hz_out6);
  1105.         dst4 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
  1106.                                                hz_out5, hz_out6, hz_out7);
  1107.         dst6 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
  1108.                                                hz_out6, hz_out7, hz_out8);
  1109.  
  1110.         if (ver_offset) {
  1111.             dst1 = __msa_srari_h(hz_out3, 5);
  1112.             dst3 = __msa_srari_h(hz_out4, 5);
  1113.             dst5 = __msa_srari_h(hz_out5, 5);
  1114.             dst7 = __msa_srari_h(hz_out6, 5);
  1115.         } else {
  1116.             dst1 = __msa_srari_h(hz_out2, 5);
  1117.             dst3 = __msa_srari_h(hz_out3, 5);
  1118.             dst5 = __msa_srari_h(hz_out4, 5);
  1119.             dst7 = __msa_srari_h(hz_out5, 5);
  1120.         }
  1121.  
  1122.         SAT_SH4_SH(dst1, dst3, dst5, dst7, 7);
  1123.  
  1124.         dst0 = __msa_aver_s_h(dst0, dst1);
  1125.         dst1 = __msa_aver_s_h(dst2, dst3);
  1126.         dst2 = __msa_aver_s_h(dst4, dst5);
  1127.         dst3 = __msa_aver_s_h(dst6, dst7);
  1128.  
  1129.         PCKEV_B2_SB(dst1, dst0, dst3, dst2, src0, src1);
  1130.         XORI_B2_128_SB(src0, src1);
  1131.  
  1132.         ST4x4_UB(src0, src1, 0, 2, 0, 2, dst, dst_stride);
  1133.  
  1134.         dst += (4 * dst_stride);
  1135.         hz_out0 = hz_out4;
  1136.         hz_out1 = hz_out5;
  1137.         hz_out2 = hz_out6;
  1138.         hz_out3 = hz_out7;
  1139.         hz_out4 = hz_out8;
  1140.     }
  1141. }
  1142.  
  1143. static void avc_luma_midv_qrt_8w_msa(const uint8_t *src, int32_t src_stride,
  1144.                                      uint8_t *dst, int32_t dst_stride,
  1145.                                      int32_t height, uint8_t ver_offset)
  1146. {
  1147.     uint32_t loop_cnt;
  1148.     v16i8 src0, src1, src2, src3, src4;
  1149.     v16i8 mask0, mask1, mask2;
  1150.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  1151.     v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
  1152.     v8i16 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
  1153.     v16u8 out;
  1154.  
  1155.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  1156.  
  1157.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  1158.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  1159.     src += (5 * src_stride);
  1160.  
  1161.     hz_out0 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
  1162.     hz_out1 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
  1163.     hz_out2 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
  1164.     hz_out3 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
  1165.     hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
  1166.  
  1167.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1168.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  1169.         XORI_B4_128_SB(src0, src1, src2, src3);
  1170.         src += (4 * src_stride);
  1171.  
  1172.         hz_out5 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
  1173.         hz_out6 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
  1174.         hz_out7 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
  1175.         hz_out8 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
  1176.  
  1177.         dst0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
  1178.                                                hz_out3, hz_out4, hz_out5);
  1179.         dst2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
  1180.                                                hz_out4, hz_out5, hz_out6);
  1181.         dst4 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
  1182.                                                hz_out5, hz_out6, hz_out7);
  1183.         dst6 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
  1184.                                                hz_out6, hz_out7, hz_out8);
  1185.  
  1186.         if (ver_offset) {
  1187.             dst1 = __msa_srari_h(hz_out3, 5);
  1188.             dst3 = __msa_srari_h(hz_out4, 5);
  1189.             dst5 = __msa_srari_h(hz_out5, 5);
  1190.             dst7 = __msa_srari_h(hz_out6, 5);
  1191.         } else {
  1192.             dst1 = __msa_srari_h(hz_out2, 5);
  1193.             dst3 = __msa_srari_h(hz_out3, 5);
  1194.             dst5 = __msa_srari_h(hz_out4, 5);
  1195.             dst7 = __msa_srari_h(hz_out5, 5);
  1196.         }
  1197.  
  1198.         SAT_SH4_SH(dst1, dst3, dst5, dst7, 7);
  1199.  
  1200.         dst0 = __msa_aver_s_h(dst0, dst1);
  1201.         dst1 = __msa_aver_s_h(dst2, dst3);
  1202.         dst2 = __msa_aver_s_h(dst4, dst5);
  1203.         dst3 = __msa_aver_s_h(dst6, dst7);
  1204.  
  1205.         out = PCKEV_XORI128_UB(dst0, dst0);
  1206.         ST8x1_UB(out, dst);
  1207.         dst += dst_stride;
  1208.         out = PCKEV_XORI128_UB(dst1, dst1);
  1209.         ST8x1_UB(out, dst);
  1210.         dst += dst_stride;
  1211.         out = PCKEV_XORI128_UB(dst2, dst2);
  1212.         ST8x1_UB(out, dst);
  1213.         dst += dst_stride;
  1214.         out = PCKEV_XORI128_UB(dst3, dst3);
  1215.         ST8x1_UB(out, dst);
  1216.         dst += dst_stride;
  1217.  
  1218.         hz_out0 = hz_out4;
  1219.         hz_out1 = hz_out5;
  1220.         hz_out2 = hz_out6;
  1221.         hz_out3 = hz_out7;
  1222.         hz_out4 = hz_out8;
  1223.     }
  1224. }
  1225.  
  1226. static void avc_luma_midv_qrt_16w_msa(const uint8_t *src, int32_t src_stride,
  1227.                                       uint8_t *dst, int32_t dst_stride,
  1228.                                       int32_t height, uint8_t vert_offset)
  1229. {
  1230.     uint32_t multiple8_cnt;
  1231.  
  1232.     for (multiple8_cnt = 2; multiple8_cnt--;) {
  1233.         avc_luma_midv_qrt_8w_msa(src, src_stride, dst, dst_stride, height,
  1234.                                  vert_offset);
  1235.  
  1236.         src += 8;
  1237.         dst += 8;
  1238.     }
  1239. }
  1240.  
  1241. static void avc_luma_hv_qrt_4w_msa(const uint8_t *src_x, const uint8_t *src_y,
  1242.                                    int32_t src_stride, uint8_t *dst,
  1243.                                    int32_t dst_stride, int32_t height)
  1244. {
  1245.     uint32_t loop_cnt;
  1246.     v16i8 src_hz0, src_hz1, src_hz2, src_hz3;
  1247.     v16i8 src_vt0, src_vt1, src_vt2, src_vt3, src_vt4;
  1248.     v16i8 src_vt5, src_vt6, src_vt7, src_vt8;
  1249.     v16i8 mask0, mask1, mask2;
  1250.     v8i16 hz_out0, hz_out1, vert_out0, vert_out1;
  1251.     v8i16 out0, out1;
  1252.     v16u8 out;
  1253.  
  1254.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  1255.  
  1256.     LD_SB5(src_y, src_stride, src_vt0, src_vt1, src_vt2, src_vt3, src_vt4);
  1257.     src_y += (5 * src_stride);
  1258.  
  1259.     src_vt0 = (v16i8) __msa_insve_w((v4i32) src_vt0, 1, (v4i32) src_vt1);
  1260.     src_vt1 = (v16i8) __msa_insve_w((v4i32) src_vt1, 1, (v4i32) src_vt2);
  1261.     src_vt2 = (v16i8) __msa_insve_w((v4i32) src_vt2, 1, (v4i32) src_vt3);
  1262.     src_vt3 = (v16i8) __msa_insve_w((v4i32) src_vt3, 1, (v4i32) src_vt4);
  1263.  
  1264.     XORI_B4_128_SB(src_vt0, src_vt1, src_vt2, src_vt3);
  1265.  
  1266.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1267.         LD_SB4(src_x, src_stride, src_hz0, src_hz1, src_hz2, src_hz3);
  1268.         src_x += (4 * src_stride);
  1269.  
  1270.         XORI_B4_128_SB(src_hz0, src_hz1, src_hz2, src_hz3);
  1271.  
  1272.         hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src_hz0,
  1273.                                                               src_hz1, mask0,
  1274.                                                               mask1, mask2);
  1275.         hz_out1 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src_hz2,
  1276.                                                               src_hz3, mask0,
  1277.                                                               mask1, mask2);
  1278.  
  1279.         SRARI_H2_SH(hz_out0, hz_out1, 5);
  1280.         SAT_SH2_SH(hz_out0, hz_out1, 7);
  1281.  
  1282.         LD_SB4(src_y, src_stride, src_vt5, src_vt6, src_vt7, src_vt8);
  1283.         src_y += (4 * src_stride);
  1284.  
  1285.         src_vt4 = (v16i8) __msa_insve_w((v4i32) src_vt4, 1, (v4i32) src_vt5);
  1286.         src_vt5 = (v16i8) __msa_insve_w((v4i32) src_vt5, 1, (v4i32) src_vt6);
  1287.         src_vt6 = (v16i8) __msa_insve_w((v4i32) src_vt6, 1, (v4i32) src_vt7);
  1288.         src_vt7 = (v16i8) __msa_insve_w((v4i32) src_vt7, 1, (v4i32) src_vt8);
  1289.  
  1290.         XORI_B4_128_SB(src_vt4, src_vt5, src_vt6, src_vt7);
  1291.  
  1292.         /* filter calc */
  1293.         vert_out0 = AVC_CALC_DPADD_B_6PIX_2COEFF_R_SH(src_vt0, src_vt1,
  1294.                                                       src_vt2, src_vt3,
  1295.                                                       src_vt4, src_vt5);
  1296.         vert_out1 = AVC_CALC_DPADD_B_6PIX_2COEFF_R_SH(src_vt2, src_vt3,
  1297.                                                       src_vt4, src_vt5,
  1298.                                                       src_vt6, src_vt7);
  1299.  
  1300.         SRARI_H2_SH(vert_out0, vert_out1, 5);
  1301.         SAT_SH2_SH(vert_out0, vert_out1, 7);
  1302.  
  1303.         out0 = __msa_srari_h((hz_out0 + vert_out0), 1);
  1304.         out1 = __msa_srari_h((hz_out1 + vert_out1), 1);
  1305.  
  1306.         SAT_SH2_SH(out0, out1, 7);
  1307.         out = PCKEV_XORI128_UB(out0, out1);
  1308.         ST4x4_UB(out, out, 0, 1, 2, 3, dst, dst_stride);
  1309.         dst += (4 * dst_stride);
  1310.  
  1311.         src_vt3 = src_vt7;
  1312.         src_vt1 = src_vt5;
  1313.         src_vt0 = src_vt4;
  1314.         src_vt4 = src_vt8;
  1315.         src_vt2 = src_vt6;
  1316.     }
  1317. }
  1318.  
  1319. static void avc_luma_hv_qrt_8w_msa(const uint8_t *src_x, const uint8_t *src_y,
  1320.                                    int32_t src_stride, uint8_t *dst,
  1321.                                    int32_t dst_stride, int32_t height)
  1322. {
  1323.     uint32_t loop_cnt;
  1324.     v16i8 src_hz0, src_hz1, src_hz2, src_hz3;
  1325.     v16i8 src_vt0, src_vt1, src_vt2, src_vt3, src_vt4;
  1326.     v16i8 src_vt5, src_vt6, src_vt7, src_vt8;
  1327.     v16i8 mask0, mask1, mask2;
  1328.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  1329.     v8i16 vert_out0, vert_out1, vert_out2, vert_out3;
  1330.     v8i16 out0, out1, out2, out3;
  1331.     v16u8 tmp0, tmp1;
  1332.  
  1333.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  1334.     LD_SB5(src_y, src_stride, src_vt0, src_vt1, src_vt2, src_vt3, src_vt4);
  1335.     src_y += (5 * src_stride);
  1336.  
  1337.     src_vt0 = (v16i8) __msa_insve_d((v2i64) src_vt0, 1, (v2i64) src_vt1);
  1338.     src_vt1 = (v16i8) __msa_insve_d((v2i64) src_vt1, 1, (v2i64) src_vt2);
  1339.     src_vt2 = (v16i8) __msa_insve_d((v2i64) src_vt2, 1, (v2i64) src_vt3);
  1340.     src_vt3 = (v16i8) __msa_insve_d((v2i64) src_vt3, 1, (v2i64) src_vt4);
  1341.  
  1342.     XORI_B4_128_SB(src_vt0, src_vt1, src_vt2, src_vt3);
  1343.  
  1344.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  1345.         LD_SB4(src_x, src_stride, src_hz0, src_hz1, src_hz2, src_hz3);
  1346.         XORI_B4_128_SB(src_hz0, src_hz1, src_hz2, src_hz3);
  1347.         src_x += (4 * src_stride);
  1348.  
  1349.         hz_out0 = AVC_HORZ_FILTER_SH(src_hz0, mask0, mask1, mask2);
  1350.         hz_out1 = AVC_HORZ_FILTER_SH(src_hz1, mask0, mask1, mask2);
  1351.         hz_out2 = AVC_HORZ_FILTER_SH(src_hz2, mask0, mask1, mask2);
  1352.         hz_out3 = AVC_HORZ_FILTER_SH(src_hz3, mask0, mask1, mask2);
  1353.  
  1354.         SRARI_H4_SH(hz_out0, hz_out1, hz_out2, hz_out3, 5);
  1355.         SAT_SH4_SH(hz_out0, hz_out1, hz_out2, hz_out3, 7);
  1356.  
  1357.         LD_SB4(src_y, src_stride, src_vt5, src_vt6, src_vt7, src_vt8);
  1358.         src_y += (4 * src_stride);
  1359.  
  1360.         src_vt4 = (v16i8) __msa_insve_d((v2i64) src_vt4, 1, (v2i64) src_vt5);
  1361.         src_vt5 = (v16i8) __msa_insve_d((v2i64) src_vt5, 1, (v2i64) src_vt6);
  1362.         src_vt6 = (v16i8) __msa_insve_d((v2i64) src_vt6, 1, (v2i64) src_vt7);
  1363.         src_vt7 = (v16i8) __msa_insve_d((v2i64) src_vt7, 1, (v2i64) src_vt8);
  1364.  
  1365.         XORI_B4_128_SB(src_vt4, src_vt5, src_vt6, src_vt7);
  1366.  
  1367.         /* filter calc */
  1368.         AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src_vt0, src_vt1, src_vt2, src_vt3,
  1369.                                         src_vt4, src_vt5, vert_out0, vert_out1);
  1370.         AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src_vt2, src_vt3, src_vt4, src_vt5,
  1371.                                         src_vt6, src_vt7, vert_out2, vert_out3);
  1372.  
  1373.         SRARI_H4_SH(vert_out0, vert_out1, vert_out2, vert_out3, 5);
  1374.         SAT_SH4_SH(vert_out0, vert_out1, vert_out2, vert_out3, 7);
  1375.  
  1376.         out0 = __msa_srari_h((hz_out0 + vert_out0), 1);
  1377.         out1 = __msa_srari_h((hz_out1 + vert_out1), 1);
  1378.         out2 = __msa_srari_h((hz_out2 + vert_out2), 1);
  1379.         out3 = __msa_srari_h((hz_out3 + vert_out3), 1);
  1380.  
  1381.         SAT_SH4_SH(out0, out1, out2, out3, 7);
  1382.         tmp0 = PCKEV_XORI128_UB(out0, out1);
  1383.         tmp1 = PCKEV_XORI128_UB(out2, out3);
  1384.         ST8x4_UB(tmp0, tmp1, dst, dst_stride);
  1385.  
  1386.         dst += (4 * dst_stride);
  1387.         src_vt3 = src_vt7;
  1388.         src_vt1 = src_vt5;
  1389.         src_vt5 = src_vt4;
  1390.         src_vt4 = src_vt8;
  1391.         src_vt2 = src_vt6;
  1392.         src_vt0 = src_vt5;
  1393.     }
  1394. }
  1395.  
  1396. static void avc_luma_hv_qrt_16w_msa(const uint8_t *src_x, const uint8_t *src_y,
  1397.                                     int32_t src_stride, uint8_t *dst,
  1398.                                     int32_t dst_stride, int32_t height)
  1399. {
  1400.     uint32_t multiple8_cnt;
  1401.  
  1402.     for (multiple8_cnt = 2; multiple8_cnt--;) {
  1403.         avc_luma_hv_qrt_8w_msa(src_x, src_y, src_stride, dst, dst_stride,
  1404.                                height);
  1405.  
  1406.         src_x += 8;
  1407.         src_y += 8;
  1408.         dst += 8;
  1409.     }
  1410. }
  1411.  
  1412. static void avc_luma_hz_and_aver_dst_4x4_msa(const uint8_t *src,
  1413.                                              int32_t src_stride,
  1414.                                              uint8_t *dst, int32_t dst_stride)
  1415. {
  1416.     v16i8 src0, src1, src2, src3;
  1417.     v16u8 dst0, dst1, dst2, dst3, res;
  1418.     v8i16 res0, res1;
  1419.     v16i8 mask0, mask1, mask2;
  1420.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  1421.     v16i8 minus5b = __msa_ldi_b(-5);
  1422.     v16i8 plus20b = __msa_ldi_b(20);
  1423.  
  1424.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  1425.     LD_SB4(src, src_stride, src0, src1, src2, src3);
  1426.  
  1427.     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1428.     XORI_B4_128_SB(src0, src1, src2, src3);
  1429.     VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
  1430.     HADD_SB2_SH(vec0, vec1, res0, res1);
  1431.     VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
  1432.     DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, res0, res1);
  1433.     VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
  1434.     DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, res0, res1);
  1435.     SRARI_H2_SH(res0, res1, 5);
  1436.     SAT_SH2_SH(res0, res1, 7);
  1437.     res = PCKEV_XORI128_UB(res0, res1);
  1438.     ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
  1439.  
  1440.     dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
  1441.     res = __msa_aver_u_b(res, dst0);
  1442.  
  1443.     ST4x4_UB(res, res, 0, 1, 2, 3, dst, dst_stride);
  1444. }
  1445.  
  1446. static void avc_luma_hz_and_aver_dst_8x8_msa(const uint8_t *src,
  1447.                                              int32_t src_stride,
  1448.                                              uint8_t *dst, int32_t dst_stride)
  1449. {
  1450.     uint32_t loop_cnt;
  1451.     v16i8 src0, src1, src2, src3;
  1452.     v16u8 dst0, dst1, dst2, dst3;
  1453.     v8i16 res0, res1, res2, res3;
  1454.     v16i8 mask0, mask1, mask2;
  1455.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  1456.     v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
  1457.     v16i8 minus5b = __msa_ldi_b(-5);
  1458.     v16i8 plus20b = __msa_ldi_b(20);
  1459.  
  1460.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  1461.  
  1462.     for (loop_cnt = 2; loop_cnt--;) {
  1463.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  1464.         src += (4 * src_stride);
  1465.  
  1466.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1467.  
  1468.         XORI_B4_128_SB(src0, src1, src2, src3);
  1469.         VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
  1470.         VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
  1471.         HADD_SB4_SH(vec0, vec1, vec2, vec3, res0, res1, res2, res3);
  1472.         VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
  1473.         VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
  1474.         DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
  1475.                      res0, res1, res2, res3);
  1476.         VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
  1477.         VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
  1478.         DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b,
  1479.                      plus20b, res0, res1, res2, res3);
  1480.         SRARI_H4_SH(res0, res1, res2, res3, 5);
  1481.         SAT_SH4_SH(res0, res1, res2, res3, 7);
  1482.         CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1, dst2, dst3,
  1483.                                 dst, dst_stride);
  1484.  
  1485.         dst += (4 * dst_stride);
  1486.     }
  1487. }
  1488.  
  1489. static void avc_luma_hz_and_aver_dst_16x16_msa(const uint8_t *src,
  1490.                                                int32_t src_stride,
  1491.                                                uint8_t *dst, int32_t dst_stride)
  1492. {
  1493.     uint32_t loop_cnt;
  1494.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7;
  1495.     v16u8 dst0, dst1, dst2, dst3;
  1496.     v16i8 mask0, mask1, mask2;
  1497.     v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
  1498.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  1499.     v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
  1500.     v16i8 minus5b = __msa_ldi_b(-5);
  1501.     v16i8 plus20b = __msa_ldi_b(20);
  1502.  
  1503.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  1504.  
  1505.     for (loop_cnt = 4; loop_cnt--;) {
  1506.         LD_SB2(src, 8, src0, src1);
  1507.         src += src_stride;
  1508.         LD_SB2(src, 8, src2, src3);
  1509.         src += src_stride;
  1510.  
  1511.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1512.  
  1513.         XORI_B4_128_SB(src0, src1, src2, src3);
  1514.         VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec3);
  1515.         VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec6, vec9);
  1516.         VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec1, vec4);
  1517.         VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec7, vec10);
  1518.         VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec2, vec5);
  1519.         VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec8, vec11);
  1520.         HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
  1521.         DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
  1522.                      minus5b, res0, res1, res2, res3);
  1523.         DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
  1524.                      plus20b, res0, res1, res2, res3);
  1525.         LD_SB2(src, 8, src4, src5);
  1526.         src += src_stride;
  1527.         LD_SB2(src, 8, src6, src7);
  1528.         src += src_stride;
  1529.         XORI_B4_128_SB(src4, src5, src6, src7);
  1530.         VSHF_B2_SB(src4, src4, src5, src5, mask0, mask0, vec0, vec3);
  1531.         VSHF_B2_SB(src6, src6, src7, src7, mask0, mask0, vec6, vec9);
  1532.         VSHF_B2_SB(src4, src4, src5, src5, mask1, mask1, vec1, vec4);
  1533.         VSHF_B2_SB(src6, src6, src7, src7, mask1, mask1, vec7, vec10);
  1534.         VSHF_B2_SB(src4, src4, src5, src5, mask2, mask2, vec2, vec5);
  1535.         VSHF_B2_SB(src6, src6, src7, src7, mask2, mask2, vec8, vec11);
  1536.         HADD_SB4_SH(vec0, vec3, vec6, vec9, res4, res5, res6, res7);
  1537.         DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
  1538.                      minus5b, res4, res5, res6, res7);
  1539.         DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
  1540.                      plus20b, res4, res5, res6, res7);
  1541.         SRARI_H4_SH(res0, res1, res2, res3, 5);
  1542.         SRARI_H4_SH(res4, res5, res6, res7, 5);
  1543.         SAT_SH4_SH(res0, res1, res2, res3, 7);
  1544.         SAT_SH4_SH(res4, res5, res6, res7, 7);
  1545.         PCKEV_B4_SB(res1, res0, res3, res2, res5, res4, res7, res6,
  1546.                     vec0, vec1, vec2, vec3);
  1547.         XORI_B4_128_SB(vec0, vec1, vec2, vec3);
  1548.         AVER_UB4_UB(vec0, dst0, vec1, dst1, vec2, dst2, vec3, dst3,
  1549.                     dst0, dst1, dst2, dst3);
  1550.         ST_UB4(dst0, dst1, dst2, dst3, dst, dst_stride);
  1551.         dst += (4 * dst_stride);
  1552.     }
  1553. }
  1554.  
  1555. static void avc_luma_hz_qrt_and_aver_dst_4x4_msa(const uint8_t *src,
  1556.                                                  int32_t src_stride,
  1557.                                                  uint8_t *dst,
  1558.                                                  int32_t dst_stride,
  1559.                                                  uint8_t hor_offset)
  1560. {
  1561.     uint8_t slide;
  1562.     v16i8 src0, src1, src2, src3;
  1563.     v16u8 dst0, dst1, dst2, dst3;
  1564.     v16i8 mask0, mask1, mask2;
  1565.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  1566.     v8i16 out0, out1;
  1567.     v16i8 minus5b = __msa_ldi_b(-5);
  1568.     v16i8 plus20b = __msa_ldi_b(20);
  1569.     v16u8 res0, res1;
  1570.  
  1571.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  1572.  
  1573.     if (hor_offset) {
  1574.         slide = 3;
  1575.     } else {
  1576.         slide = 2;
  1577.     }
  1578.  
  1579.     LD_SB4(src, src_stride, src0, src1, src2, src3);
  1580.     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1581.  
  1582.     XORI_B4_128_SB(src0, src1, src2, src3);
  1583.     VSHF_B2_SB(src0, src1, src2, src3, mask0, mask0, vec0, vec1);
  1584.     HADD_SB2_SH(vec0, vec1, out0, out1);
  1585.     VSHF_B2_SB(src0, src1, src2, src3, mask1, mask1, vec2, vec3);
  1586.     DPADD_SB2_SH(vec2, vec3, minus5b, minus5b, out0, out1);
  1587.     VSHF_B2_SB(src0, src1, src2, src3, mask2, mask2, vec4, vec5);
  1588.     DPADD_SB2_SH(vec4, vec5, plus20b, plus20b, out0, out1);
  1589.     SRARI_H2_SH(out0, out1, 5);
  1590.     SAT_SH2_SH(out0, out1, 7);
  1591.  
  1592.     PCKEV_B2_UB(out0, out0, out1, out1, res0, res1);
  1593.  
  1594.     src0 = __msa_sld_b(src0, src0, slide);
  1595.     src1 = __msa_sld_b(src1, src1, slide);
  1596.     src2 = __msa_sld_b(src2, src2, slide);
  1597.     src3 = __msa_sld_b(src3, src3, slide);
  1598.     src0 = (v16i8) __msa_insve_w((v4i32) src0, 1, (v4i32) src1);
  1599.     src1 = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
  1600.     res0 = (v16u8) __msa_aver_s_b((v16i8) res0, src0);
  1601.     res1 = (v16u8) __msa_aver_s_b((v16i8) res1, src1);
  1602.  
  1603.     XORI_B2_128_UB(res0, res1);
  1604.  
  1605.     dst0 = (v16u8) __msa_insve_w((v4i32) dst0, 1, (v4i32) dst1);
  1606.     dst1 = (v16u8) __msa_insve_w((v4i32) dst2, 1, (v4i32) dst3);
  1607.  
  1608.     AVER_UB2_UB(res0, dst0, res1, dst1, dst0, dst1);
  1609.  
  1610.     ST4x4_UB(dst0, dst1, 0, 1, 0, 1, dst, dst_stride);
  1611. }
  1612.  
  1613. static void avc_luma_hz_qrt_and_aver_dst_8x8_msa(const uint8_t *src,
  1614.                                                  int32_t src_stride,
  1615.                                                  uint8_t *dst,
  1616.                                                  int32_t dst_stride,
  1617.                                                  uint8_t hor_offset)
  1618. {
  1619.     uint8_t slide;
  1620.     uint32_t loop_cnt;
  1621.     v16i8 src0, src1, src2, src3;
  1622.     v16i8 mask0, mask1, mask2;
  1623.     v16u8 dst0, dst1, dst2, dst3;
  1624.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  1625.     v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
  1626.     v8i16 out0, out1, out2, out3;
  1627.     v16i8 minus5b = __msa_ldi_b(-5);
  1628.     v16i8 plus20b = __msa_ldi_b(20);
  1629.     v16i8 res0, res1, res2, res3;
  1630.  
  1631.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  1632.  
  1633.     if (hor_offset) {
  1634.         slide = 3;
  1635.     } else {
  1636.         slide = 2;
  1637.     }
  1638.  
  1639.     for (loop_cnt = 2; loop_cnt--;) {
  1640.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  1641.         src += (4 * src_stride);
  1642.  
  1643.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1644.  
  1645.         XORI_B4_128_SB(src0, src1, src2, src3);
  1646.         VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec1);
  1647.         VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec2, vec3);
  1648.         HADD_SB4_SH(vec0, vec1, vec2, vec3, out0, out1, out2, out3);
  1649.         VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec4, vec5);
  1650.         VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec6, vec7);
  1651.         DPADD_SB4_SH(vec4, vec5, vec6, vec7, minus5b, minus5b, minus5b, minus5b,
  1652.                      out0, out1, out2, out3);
  1653.         VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec8, vec9);
  1654.         VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec10, vec11);
  1655.         DPADD_SB4_SH(vec8, vec9, vec10, vec11, plus20b, plus20b, plus20b,
  1656.                      plus20b, out0, out1, out2, out3);
  1657.  
  1658.         src0 = __msa_sld_b(src0, src0, slide);
  1659.         src1 = __msa_sld_b(src1, src1, slide);
  1660.         src2 = __msa_sld_b(src2, src2, slide);
  1661.         src3 = __msa_sld_b(src3, src3, slide);
  1662.  
  1663.         SRARI_H4_SH(out0, out1, out2, out3, 5);
  1664.         SAT_SH4_SH(out0, out1, out2, out3, 7);
  1665.  
  1666.         PCKEV_B4_SB(out0, out0, out1, out1, out2, out2, out3, out3,
  1667.                     res0, res1, res2, res3);
  1668.  
  1669.         res0 = __msa_aver_s_b(res0, src0);
  1670.         res1 = __msa_aver_s_b(res1, src1);
  1671.         res2 = __msa_aver_s_b(res2, src2);
  1672.         res3 = __msa_aver_s_b(res3, src3);
  1673.  
  1674.         XORI_B4_128_SB(res0, res1, res2, res3);
  1675.         AVER_ST8x4_UB(res0, dst0, res1, dst1, res2, dst2, res3, dst3,
  1676.                       dst, dst_stride);
  1677.  
  1678.         dst += (4 * dst_stride);
  1679.     }
  1680. }
  1681.  
  1682. static void avc_luma_hz_qrt_and_aver_dst_16x16_msa(const uint8_t *src,
  1683.                                                    int32_t src_stride,
  1684.                                                    uint8_t *dst,
  1685.                                                    int32_t dst_stride,
  1686.                                                    uint8_t hor_offset)
  1687. {
  1688.     uint32_t loop_cnt;
  1689.     v16i8 out0, out1;
  1690.     v16i8 src0, src1, src2, src3;
  1691.     v16i8 mask0, mask1, mask2, vshf;
  1692.     v16u8 dst0, dst1;
  1693.     v8i16 res0, res1, res2, res3;
  1694.     v16i8 vec0, vec1, vec2, vec3, vec4, vec5;
  1695.     v16i8 vec6, vec7, vec8, vec9, vec10, vec11;
  1696.     v16i8 minus5b = __msa_ldi_b(-5);
  1697.     v16i8 plus20b = __msa_ldi_b(20);
  1698.  
  1699.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  1700.  
  1701.     if (hor_offset) {
  1702.         vshf = LD_SB(&luma_mask_arr[16 + 96]);
  1703.     } else {
  1704.         vshf = LD_SB(&luma_mask_arr[96]);
  1705.     }
  1706.  
  1707.     for (loop_cnt = 8; loop_cnt--;) {
  1708.         LD_SB2(src, 8, src0, src1);
  1709.         src += src_stride;
  1710.         LD_SB2(src, 8, src2, src3);
  1711.         src += src_stride;
  1712.  
  1713.         LD_UB2(dst, dst_stride, dst0, dst1);
  1714.  
  1715.         XORI_B4_128_SB(src0, src1, src2, src3);
  1716.         VSHF_B2_SB(src0, src0, src1, src1, mask0, mask0, vec0, vec3);
  1717.         VSHF_B2_SB(src2, src2, src3, src3, mask0, mask0, vec6, vec9);
  1718.         VSHF_B2_SB(src0, src0, src1, src1, mask1, mask1, vec1, vec4);
  1719.         VSHF_B2_SB(src2, src2, src3, src3, mask1, mask1, vec7, vec10);
  1720.         VSHF_B2_SB(src0, src0, src1, src1, mask2, mask2, vec2, vec5);
  1721.         VSHF_B2_SB(src2, src2, src3, src3, mask2, mask2, vec8, vec11);
  1722.         HADD_SB4_SH(vec0, vec3, vec6, vec9, res0, res1, res2, res3);
  1723.         DPADD_SB4_SH(vec1, vec4, vec7, vec10, minus5b, minus5b, minus5b,
  1724.                      minus5b, res0, res1, res2, res3);
  1725.         DPADD_SB4_SH(vec2, vec5, vec8, vec11, plus20b, plus20b, plus20b,
  1726.                      plus20b, res0, res1, res2, res3);
  1727.         VSHF_B2_SB(src0, src1, src2, src3, vshf, vshf, src0, src2);
  1728.         SRARI_H4_SH(res0, res1, res2, res3, 5);
  1729.         SAT_SH4_SH(res0, res1, res2, res3, 7);
  1730.         PCKEV_B2_SB(res1, res0, res3, res2, out0, out1);
  1731.  
  1732.         out0 = __msa_aver_s_b(out0, src0);
  1733.         out1 = __msa_aver_s_b(out1, src2);
  1734.  
  1735.         XORI_B2_128_SB(out0, out1);
  1736.         AVER_UB2_UB(out0, dst0, out1, dst1, dst0, dst1);
  1737.         ST_UB2(dst0, dst1, dst, dst_stride);
  1738.         dst += (2 * dst_stride);
  1739.     }
  1740. }
  1741.  
  1742. static void avc_luma_vt_and_aver_dst_4x4_msa(const uint8_t *src,
  1743.                                              int32_t src_stride,
  1744.                                              uint8_t *dst, int32_t dst_stride)
  1745. {
  1746.     int16_t filt_const0 = 0xfb01;
  1747.     int16_t filt_const1 = 0x1414;
  1748.     int16_t filt_const2 = 0x1fb;
  1749.     v16u8 dst0, dst1, dst2, dst3;
  1750.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1751.     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
  1752.     v16i8 src87_r, src2110, src4332, src6554, src8776;
  1753.     v8i16 out10, out32;
  1754.     v16i8 filt0, filt1, filt2;
  1755.     v16u8 res;
  1756.  
  1757.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  1758.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  1759.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  1760.  
  1761.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  1762.     src += (5 * src_stride);
  1763.  
  1764.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  1765.                src10_r, src21_r, src32_r, src43_r);
  1766.     ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
  1767.     XORI_B2_128_SB(src2110, src4332);
  1768.     LD_SB4(src, src_stride, src5, src6, src7, src8);
  1769.     ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  1770.                src54_r, src65_r, src76_r, src87_r);
  1771.     ILVR_D2_SB(src65_r, src54_r, src87_r, src76_r, src6554, src8776);
  1772.     XORI_B2_128_SB(src6554, src8776);
  1773.     out10 = DPADD_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
  1774.     out32 = DPADD_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
  1775.     SRARI_H2_SH(out10, out32, 5);
  1776.     SAT_SH2_SH(out10, out32, 7);
  1777.     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1778.     res = PCKEV_XORI128_UB(out10, out32);
  1779.  
  1780.     ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
  1781.  
  1782.     dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
  1783.     dst0 = __msa_aver_u_b(res, dst0);
  1784.  
  1785.     ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
  1786. }
  1787.  
  1788. static void avc_luma_vt_and_aver_dst_8x8_msa(const uint8_t *src,
  1789.                                              int32_t src_stride,
  1790.                                              uint8_t *dst, int32_t dst_stride)
  1791. {
  1792.     int32_t loop_cnt;
  1793.     int16_t filt_const0 = 0xfb01;
  1794.     int16_t filt_const1 = 0x1414;
  1795.     int16_t filt_const2 = 0x1fb;
  1796.     v16u8 dst0, dst1, dst2, dst3;
  1797.     v16i8 src0, src1, src2, src3, src4, src7, src8, src9, src10;
  1798.     v16i8 src10_r, src32_r, src76_r, src98_r;
  1799.     v16i8 src21_r, src43_r, src87_r, src109_r;
  1800.     v8i16 out0, out1, out2, out3;
  1801.     v16i8 filt0, filt1, filt2;
  1802.  
  1803.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  1804.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  1805.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  1806.  
  1807.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  1808.     src += (5 * src_stride);
  1809.  
  1810.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  1811.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  1812.                src10_r, src21_r, src32_r, src43_r);
  1813.  
  1814.     for (loop_cnt = 2; loop_cnt--;) {
  1815.         LD_SB4(src, src_stride, src7, src8, src9, src10);
  1816.         src += (4 * src_stride);
  1817.  
  1818.         XORI_B4_128_SB(src7, src8, src9, src10);
  1819.         ILVR_B4_SB(src7, src4, src8, src7, src9, src8, src10, src9,
  1820.                    src76_r, src87_r, src98_r, src109_r);
  1821.         out0 = DPADD_SH3_SH(src10_r, src32_r, src76_r, filt0, filt1, filt2);
  1822.         out1 = DPADD_SH3_SH(src21_r, src43_r, src87_r, filt0, filt1, filt2);
  1823.         out2 = DPADD_SH3_SH(src32_r, src76_r, src98_r, filt0, filt1, filt2);
  1824.         out3 = DPADD_SH3_SH(src43_r, src87_r, src109_r, filt0, filt1, filt2);
  1825.         SRARI_H4_SH(out0, out1, out2, out3, 5);
  1826.         SAT_SH4_SH(out0, out1, out2, out3, 7);
  1827.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1828.  
  1829.         CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1, dst2, dst3,
  1830.                                 dst, dst_stride);
  1831.         dst += (4 * dst_stride);
  1832.  
  1833.         src10_r = src76_r;
  1834.         src32_r = src98_r;
  1835.         src21_r = src87_r;
  1836.         src43_r = src109_r;
  1837.         src4 = src10;
  1838.     }
  1839. }
  1840.  
  1841. static void avc_luma_vt_and_aver_dst_16x16_msa(const uint8_t *src,
  1842.                                                int32_t src_stride,
  1843.                                                uint8_t *dst, int32_t dst_stride)
  1844. {
  1845.     int32_t loop_cnt;
  1846.     int16_t filt_const0 = 0xfb01;
  1847.     int16_t filt_const1 = 0x1414;
  1848.     int16_t filt_const2 = 0x1fb;
  1849.     v16u8 dst0, dst1, dst2, dst3;
  1850.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1851.     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
  1852.     v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
  1853.     v16i8 src65_l, src87_l;
  1854.     v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
  1855.     v16i8 filt0, filt1, filt2;
  1856.     v16u8 res0, res1, res2, res3;
  1857.  
  1858.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  1859.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  1860.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  1861.  
  1862.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  1863.     src += (5 * src_stride);
  1864.  
  1865.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  1866.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  1867.                src10_r, src21_r, src32_r, src43_r);
  1868.     ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  1869.                src10_l, src21_l, src32_l, src43_l);
  1870.  
  1871.     for (loop_cnt = 4; loop_cnt--;) {
  1872.         LD_SB4(src, src_stride, src5, src6, src7, src8);
  1873.         src += (4 * src_stride);
  1874.  
  1875.         XORI_B4_128_SB(src5, src6, src7, src8);
  1876.         ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  1877.                    src54_r, src65_r, src76_r, src87_r);
  1878.         ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  1879.                    src54_l, src65_l, src76_l, src87_l);
  1880.         out0_r = DPADD_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
  1881.         out1_r = DPADD_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
  1882.         out2_r = DPADD_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
  1883.         out3_r = DPADD_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
  1884.         out0_l = DPADD_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
  1885.         out1_l = DPADD_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
  1886.         out2_l = DPADD_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
  1887.         out3_l = DPADD_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
  1888.         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
  1889.         SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
  1890.         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
  1891.         SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
  1892.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1893.         PCKEV_B4_UB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
  1894.                     out3_r, res0, res1, res2, res3);
  1895.         XORI_B4_128_UB(res0, res1, res2, res3);
  1896.         AVER_UB4_UB(res0, dst0, res1, dst1, res2, dst2, res3, dst3,
  1897.                     res0, res1, res2, res3);
  1898.         ST_UB4(res0, res1, res2, res3, dst, dst_stride);
  1899.         dst += (4 * dst_stride);
  1900.  
  1901.         src10_r = src54_r;
  1902.         src32_r = src76_r;
  1903.         src21_r = src65_r;
  1904.         src43_r = src87_r;
  1905.         src10_l = src54_l;
  1906.         src32_l = src76_l;
  1907.         src21_l = src65_l;
  1908.         src43_l = src87_l;
  1909.         src4 = src8;
  1910.     }
  1911. }
  1912.  
  1913. static void avc_luma_vt_qrt_and_aver_dst_4x4_msa(const uint8_t *src,
  1914.                                                  int32_t src_stride,
  1915.                                                  uint8_t *dst,
  1916.                                                  int32_t dst_stride,
  1917.                                                  uint8_t ver_offset)
  1918. {
  1919.     int16_t filt_const0 = 0xfb01;
  1920.     int16_t filt_const1 = 0x1414;
  1921.     int16_t filt_const2 = 0x1fb;
  1922.     v16u8 dst0, dst1, dst2, dst3;
  1923.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  1924.     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
  1925.     v16i8 src87_r, src2110, src4332, src6554, src8776;
  1926.     v8i16 out10, out32;
  1927.     v16i8 filt0, filt1, filt2;
  1928.     v16u8 res;
  1929.  
  1930.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  1931.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  1932.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  1933.  
  1934.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  1935.     src += (5 * src_stride);
  1936.  
  1937.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  1938.                src10_r, src21_r, src32_r, src43_r);
  1939.     ILVR_D2_SB(src21_r, src10_r, src43_r, src32_r, src2110, src4332);
  1940.     XORI_B2_128_SB(src2110, src4332);
  1941.     LD_SB4(src, src_stride, src5, src6, src7, src8);
  1942.     ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  1943.                src54_r, src65_r, src76_r, src87_r);
  1944.     ILVR_D2_SB(src65_r, src54_r, src87_r, src76_r, src6554, src8776);
  1945.     XORI_B2_128_SB(src6554, src8776);
  1946.     out10 = DPADD_SH3_SH(src2110, src4332, src6554, filt0, filt1, filt2);
  1947.     out32 = DPADD_SH3_SH(src4332, src6554, src8776, filt0, filt1, filt2);
  1948.     SRARI_H2_SH(out10, out32, 5);
  1949.     SAT_SH2_SH(out10, out32, 7);
  1950.     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  1951.     res = PCKEV_XORI128_UB(out10, out32);
  1952.  
  1953.     if (ver_offset) {
  1954.         src32_r = (v16i8) __msa_insve_w((v4i32) src3, 1, (v4i32) src4);
  1955.         src54_r = (v16i8) __msa_insve_w((v4i32) src5, 1, (v4i32) src6);
  1956.     } else {
  1957.         src32_r = (v16i8) __msa_insve_w((v4i32) src2, 1, (v4i32) src3);
  1958.         src54_r = (v16i8) __msa_insve_w((v4i32) src4, 1, (v4i32) src5);
  1959.     }
  1960.  
  1961.     src32_r = (v16i8) __msa_insve_d((v2i64) src32_r, 1, (v2i64) src54_r);
  1962.     res = __msa_aver_u_b(res, (v16u8) src32_r);
  1963.  
  1964.     ILVR_W2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
  1965.  
  1966.     dst0 = (v16u8) __msa_pckev_d((v2i64) dst1, (v2i64) dst0);
  1967.     dst0 = __msa_aver_u_b(res, dst0);
  1968.  
  1969.     ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
  1970. }
  1971.  
  1972. static void avc_luma_vt_qrt_and_aver_dst_8x8_msa(const uint8_t *src,
  1973.                                                  int32_t src_stride,
  1974.                                                  uint8_t *dst,
  1975.                                                  int32_t dst_stride,
  1976.                                                  uint8_t ver_offset)
  1977. {
  1978.     int32_t loop_cnt;
  1979.     int16_t filt_const0 = 0xfb01;
  1980.     int16_t filt_const1 = 0x1414;
  1981.     int16_t filt_const2 = 0x1fb;
  1982.     v16u8 dst0, dst1, dst2, dst3;
  1983.     v16i8 src0, src1, src2, src3, src4, src7, src8, src9, src10;
  1984.     v16i8 src10_r, src32_r, src76_r, src98_r;
  1985.     v16i8 src21_r, src43_r, src87_r, src109_r;
  1986.     v8i16 out0_r, out1_r, out2_r, out3_r;
  1987.     v16i8 res0, res1;
  1988.     v16u8 vec0, vec1;
  1989.     v16i8 filt0, filt1, filt2;
  1990.  
  1991.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  1992.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  1993.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  1994.  
  1995.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  1996.     src += (5 * src_stride);
  1997.  
  1998.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  1999.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  2000.                src10_r, src21_r, src32_r, src43_r);
  2001.  
  2002.     for (loop_cnt = 2; loop_cnt--;) {
  2003.         LD_SB4(src, src_stride, src7, src8, src9, src10);
  2004.         src += (4 * src_stride);
  2005.  
  2006.         XORI_B4_128_SB(src7, src8, src9, src10);
  2007.         ILVR_B4_SB(src7, src4, src8, src7, src9, src8, src10, src9,
  2008.                    src76_r, src87_r, src98_r, src109_r);
  2009.         out0_r = DPADD_SH3_SH(src10_r, src32_r, src76_r, filt0, filt1, filt2);
  2010.         out1_r = DPADD_SH3_SH(src21_r, src43_r, src87_r, filt0, filt1, filt2);
  2011.         out2_r = DPADD_SH3_SH(src32_r, src76_r, src98_r, filt0, filt1, filt2);
  2012.         out3_r = DPADD_SH3_SH(src43_r, src87_r, src109_r, filt0, filt1, filt2);
  2013.         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
  2014.         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
  2015.         PCKEV_B2_SB(out1_r, out0_r, out3_r, out2_r, res0, res1);
  2016.  
  2017.         if (ver_offset) {
  2018.             PCKEV_D2_SB(src4, src3, src8, src7, src10_r, src32_r);
  2019.         } else {
  2020.             PCKEV_D2_SB(src3, src2, src7, src4, src10_r, src32_r);
  2021.         }
  2022.  
  2023.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2024.         ILVR_D2_UB(dst1, dst0, dst3, dst2, dst0, dst1);
  2025.  
  2026.         vec0 = (v16u8) __msa_aver_s_b(res0, src10_r);
  2027.         vec1 = (v16u8) __msa_aver_s_b(res1, src32_r);
  2028.  
  2029.         XORI_B2_128_UB(vec0, vec1);
  2030.         AVER_UB2_UB(vec0, dst0, vec1, dst1, vec0, vec1);
  2031.         ST8x4_UB(vec0, vec1, dst, dst_stride);
  2032.         dst += (4 * dst_stride);
  2033.  
  2034.         src10_r = src76_r;
  2035.         src32_r = src98_r;
  2036.         src21_r = src87_r;
  2037.         src43_r = src109_r;
  2038.         src2 = src8;
  2039.         src3 = src9;
  2040.         src4 = src10;
  2041.     }
  2042. }
  2043.  
  2044. static void avc_luma_vt_qrt_and_aver_dst_16x16_msa(const uint8_t *src,
  2045.                                                    int32_t src_stride,
  2046.                                                    uint8_t *dst,
  2047.                                                    int32_t dst_stride,
  2048.                                                    uint8_t ver_offset)
  2049. {
  2050.     int32_t loop_cnt;
  2051.     int16_t filt_const0 = 0xfb01;
  2052.     int16_t filt_const1 = 0x1414;
  2053.     int16_t filt_const2 = 0x1fb;
  2054.     v16u8 dst0, dst1, dst2, dst3;
  2055.     v16i8 src0, src1, src2, src3, src4, src5, src6, src7, src8;
  2056.     v16i8 src10_r, src32_r, src54_r, src76_r, src21_r, src43_r, src65_r;
  2057.     v16i8 src87_r, src10_l, src32_l, src54_l, src76_l, src21_l, src43_l;
  2058.     v16i8 src65_l, src87_l;
  2059.     v8i16 out0_r, out1_r, out2_r, out3_r, out0_l, out1_l, out2_l, out3_l;
  2060.     v16i8 out0, out1, out2, out3;
  2061.     v16i8 filt0, filt1, filt2;
  2062.     v16u8 res0, res1, res2, res3;
  2063.  
  2064.     filt0 = (v16i8) __msa_fill_h(filt_const0);
  2065.     filt1 = (v16i8) __msa_fill_h(filt_const1);
  2066.     filt2 = (v16i8) __msa_fill_h(filt_const2);
  2067.  
  2068.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  2069.     src += (5 * src_stride);
  2070.  
  2071.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  2072.     ILVR_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  2073.                src10_r, src21_r, src32_r, src43_r);
  2074.     ILVL_B4_SB(src1, src0, src2, src1, src3, src2, src4, src3,
  2075.                src10_l, src21_l, src32_l, src43_l);
  2076.  
  2077.     for (loop_cnt = 4; loop_cnt--;) {
  2078.         LD_SB4(src, src_stride, src5, src6, src7, src8);
  2079.         src += (4 * src_stride);
  2080.  
  2081.         XORI_B4_128_SB(src5, src6, src7, src8);
  2082.         ILVR_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  2083.                    src54_r, src65_r, src76_r, src87_r);
  2084.         ILVL_B4_SB(src5, src4, src6, src5, src7, src6, src8, src7,
  2085.                    src54_l, src65_l, src76_l, src87_l);
  2086.         out0_r = DPADD_SH3_SH(src10_r, src32_r, src54_r, filt0, filt1, filt2);
  2087.         out1_r = DPADD_SH3_SH(src21_r, src43_r, src65_r, filt0, filt1, filt2);
  2088.         out2_r = DPADD_SH3_SH(src32_r, src54_r, src76_r, filt0, filt1, filt2);
  2089.         out3_r = DPADD_SH3_SH(src43_r, src65_r, src87_r, filt0, filt1, filt2);
  2090.         out0_l = DPADD_SH3_SH(src10_l, src32_l, src54_l, filt0, filt1, filt2);
  2091.         out1_l = DPADD_SH3_SH(src21_l, src43_l, src65_l, filt0, filt1, filt2);
  2092.         out2_l = DPADD_SH3_SH(src32_l, src54_l, src76_l, filt0, filt1, filt2);
  2093.         out3_l = DPADD_SH3_SH(src43_l, src65_l, src87_l, filt0, filt1, filt2);
  2094.         SRARI_H4_SH(out0_r, out1_r, out2_r, out3_r, 5);
  2095.         SRARI_H4_SH(out0_l, out1_l, out2_l, out3_l, 5);
  2096.         SAT_SH4_SH(out0_r, out1_r, out2_r, out3_r, 7);
  2097.         SAT_SH4_SH(out0_l, out1_l, out2_l, out3_l, 7);
  2098.         PCKEV_B4_SB(out0_l, out0_r, out1_l, out1_r, out2_l, out2_r, out3_l,
  2099.                     out3_r, out0, out1, out2, out3);
  2100.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2101.  
  2102.         if (ver_offset) {
  2103.             res0 = (v16u8) __msa_aver_s_b(out0, src3);
  2104.             res1 = (v16u8) __msa_aver_s_b(out1, src4);
  2105.             res2 = (v16u8) __msa_aver_s_b(out2, src5);
  2106.             res3 = (v16u8) __msa_aver_s_b(out3, src6);
  2107.         } else {
  2108.             res0 = (v16u8) __msa_aver_s_b(out0, src2);
  2109.             res1 = (v16u8) __msa_aver_s_b(out1, src3);
  2110.             res2 = (v16u8) __msa_aver_s_b(out2, src4);
  2111.             res3 = (v16u8) __msa_aver_s_b(out3, src5);
  2112.         }
  2113.  
  2114.         XORI_B4_128_UB(res0, res1, res2, res3);
  2115.         AVER_UB4_UB(res0, dst0, res1, dst1, res2, dst2, res3, dst3,
  2116.                     dst0, dst1, dst2, dst3);
  2117.         ST_UB4(dst0, dst1, dst2, dst3, dst, dst_stride);
  2118.         dst += (4 * dst_stride);
  2119.  
  2120.         src10_r = src54_r;
  2121.         src32_r = src76_r;
  2122.         src21_r = src65_r;
  2123.         src43_r = src87_r;
  2124.         src10_l = src54_l;
  2125.         src32_l = src76_l;
  2126.         src21_l = src65_l;
  2127.         src43_l = src87_l;
  2128.         src2 = src6;
  2129.         src3 = src7;
  2130.         src4 = src8;
  2131.     }
  2132. }
  2133.  
  2134. static void avc_luma_mid_and_aver_dst_4x4_msa(const uint8_t *src,
  2135.                                               int32_t src_stride,
  2136.                                               uint8_t *dst, int32_t dst_stride)
  2137. {
  2138.     v16i8 src0, src1, src2, src3, src4;
  2139.     v16i8 mask0, mask1, mask2;
  2140.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  2141.     v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
  2142.     v8i16 res0, res1, res2, res3;
  2143.     v16u8 dst0, dst1, dst2, dst3;
  2144.     v16u8 tmp0, tmp1, tmp2, tmp3;
  2145.  
  2146.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  2147.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  2148.     src += (5 * src_stride);
  2149.  
  2150.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  2151.  
  2152.     hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
  2153.                                                           mask0, mask1, mask2);
  2154.     hz_out2 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
  2155.                                                           mask0, mask1, mask2);
  2156.  
  2157.     PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
  2158.  
  2159.     hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
  2160.  
  2161.     LD_SB4(src, src_stride, src0, src1, src2, src3);
  2162.     XORI_B4_128_SB(src0, src1, src2, src3);
  2163.  
  2164.     hz_out5 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
  2165.                                                           mask0, mask1, mask2);
  2166.     hz_out7 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
  2167.                                                           mask0, mask1, mask2);
  2168.  
  2169.     PCKOD_D2_SH(hz_out5, hz_out5, hz_out7, hz_out7, hz_out6, hz_out8);
  2170.  
  2171.     res0 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out0, hz_out1, hz_out2,
  2172.                                              hz_out3, hz_out4, hz_out5);
  2173.     res1 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out1, hz_out2, hz_out3,
  2174.                                              hz_out4, hz_out5, hz_out6);
  2175.     res2 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out2, hz_out3, hz_out4,
  2176.                                              hz_out5, hz_out6, hz_out7);
  2177.     res3 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out3, hz_out4, hz_out5,
  2178.                                              hz_out6, hz_out7, hz_out8);
  2179.     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2180.     tmp0 = PCKEV_XORI128_UB(res0, res1);
  2181.     tmp1 = PCKEV_XORI128_UB(res2, res3);
  2182.     PCKEV_D2_UB(dst1, dst0, dst3, dst2, tmp2, tmp3);
  2183.     AVER_UB2_UB(tmp0, tmp2, tmp1, tmp3, tmp0, tmp1);
  2184.  
  2185.     ST4x4_UB(tmp0, tmp1, 0, 2, 0, 2, dst, dst_stride);
  2186. }
  2187.  
  2188. static void avc_luma_mid_and_aver_dst_8w_msa(const uint8_t *src,
  2189.                                              int32_t src_stride,
  2190.                                              uint8_t *dst, int32_t dst_stride,
  2191.                                              int32_t height)
  2192. {
  2193.     uint32_t loop_cnt;
  2194.     v16i8 src0, src1, src2, src3, src4;
  2195.     v16i8 mask0, mask1, mask2;
  2196.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  2197.     v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
  2198.     v16u8 dst0, dst1, dst2, dst3;
  2199.     v8i16 res0, res1, res2, res3;
  2200.  
  2201.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  2202.  
  2203.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  2204.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  2205.     src += (5 * src_stride);
  2206.  
  2207.     hz_out0 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
  2208.     hz_out1 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
  2209.     hz_out2 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
  2210.     hz_out3 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
  2211.     hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
  2212.  
  2213.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2214.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  2215.         XORI_B4_128_SB(src0, src1, src2, src3);
  2216.         src += (4 * src_stride);
  2217.  
  2218.         hz_out5 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
  2219.         hz_out6 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
  2220.         hz_out7 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
  2221.         hz_out8 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
  2222.  
  2223.         res0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
  2224.                                                hz_out3, hz_out4, hz_out5);
  2225.         res1 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
  2226.                                                hz_out4, hz_out5, hz_out6);
  2227.         res2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
  2228.                                                hz_out5, hz_out6, hz_out7);
  2229.         res3 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
  2230.                                                hz_out6, hz_out7, hz_out8);
  2231.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2232.         CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1, dst2, dst3,
  2233.                                 dst, dst_stride);
  2234.  
  2235.         dst += (4 * dst_stride);
  2236.         hz_out3 = hz_out7;
  2237.         hz_out1 = hz_out5;
  2238.         hz_out5 = hz_out4;
  2239.         hz_out4 = hz_out8;
  2240.         hz_out2 = hz_out6;
  2241.         hz_out0 = hz_out5;
  2242.     }
  2243. }
  2244.  
  2245. static void avc_luma_mid_and_aver_dst_16x16_msa(const uint8_t *src,
  2246.                                                 int32_t src_stride,
  2247.                                                 uint8_t *dst,
  2248.                                                 int32_t dst_stride)
  2249. {
  2250.     avc_luma_mid_and_aver_dst_8w_msa(src, src_stride, dst, dst_stride, 16);
  2251.     avc_luma_mid_and_aver_dst_8w_msa(src + 8, src_stride, dst + 8, dst_stride,
  2252.                                      16);
  2253. }
  2254.  
  2255. static void avc_luma_midh_qrt_and_aver_dst_4w_msa(const uint8_t *src,
  2256.                                                   int32_t src_stride,
  2257.                                                   uint8_t *dst,
  2258.                                                   int32_t dst_stride,
  2259.                                                   int32_t height,
  2260.                                                   uint8_t horiz_offset)
  2261. {
  2262.     uint32_t row;
  2263.     v16i8 src0, src1, src2, src3, src4, src5, src6;
  2264.     v16u8 dst0, dst1, res;
  2265.     v8i16 vt_res0, vt_res1, vt_res2, vt_res3;
  2266.     v4i32 hz_res0, hz_res1;
  2267.     v8i16 res0, res1;
  2268.     v8i16 shf_vec0, shf_vec1, shf_vec2, shf_vec3, shf_vec4, shf_vec5;
  2269.     v8i16 mask0 = { 0, 5, 1, 6, 2, 7, 3, 8 };
  2270.     v8i16 mask1 = { 1, 4, 2, 5, 3, 6, 4, 7 };
  2271.     v8i16 mask2 = { 2, 3, 3, 4, 4, 5, 5, 6 };
  2272.     v8i16 minus5h = __msa_ldi_h(-5);
  2273.     v8i16 plus20h = __msa_ldi_h(20);
  2274.     v8i16 zeros = { 0 };
  2275.  
  2276.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  2277.     src += (5 * src_stride);
  2278.  
  2279.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  2280.  
  2281.     for (row = (height >> 1); row--;) {
  2282.         LD_SB2(src, src_stride, src5, src6);
  2283.         src += (2 * src_stride);
  2284.  
  2285.         XORI_B2_128_SB(src5, src6);
  2286.         LD_UB2(dst, dst_stride, dst0, dst1);
  2287.  
  2288.         dst0 = (v16u8) __msa_ilvr_w((v4i32) dst1, (v4i32) dst0);
  2289.  
  2290.         AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src0, src1, src2, src3, src4, src5,
  2291.                                         vt_res0, vt_res1);
  2292.         AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src1, src2, src3, src4, src5, src6,
  2293.                                         vt_res2, vt_res3);
  2294.         VSHF_H3_SH(vt_res0, vt_res1, vt_res0, vt_res1, vt_res0, vt_res1,
  2295.                    mask0, mask1, mask2, shf_vec0, shf_vec1, shf_vec2);
  2296.         VSHF_H3_SH(vt_res2, vt_res3, vt_res2, vt_res3, vt_res2, vt_res3,
  2297.                    mask0, mask1, mask2, shf_vec3, shf_vec4, shf_vec5);
  2298.  
  2299.         hz_res0 = __msa_hadd_s_w(shf_vec0, shf_vec0);
  2300.         DPADD_SH2_SW(shf_vec1, shf_vec2, minus5h, plus20h, hz_res0, hz_res0);
  2301.  
  2302.         hz_res1 = __msa_hadd_s_w(shf_vec3, shf_vec3);
  2303.         DPADD_SH2_SW(shf_vec4, shf_vec5, minus5h, plus20h, hz_res1, hz_res1);
  2304.  
  2305.         SRARI_W2_SW(hz_res0, hz_res1, 10);
  2306.         SAT_SW2_SW(hz_res0, hz_res1, 7);
  2307.  
  2308.         res0 = __msa_srari_h(shf_vec2, 5);
  2309.         res1 = __msa_srari_h(shf_vec5, 5);
  2310.  
  2311.         SAT_SH2_SH(res0, res1, 7);
  2312.  
  2313.         if (horiz_offset) {
  2314.             res0 = __msa_ilvod_h(zeros, res0);
  2315.             res1 = __msa_ilvod_h(zeros, res1);
  2316.         } else {
  2317.             ILVEV_H2_SH(res0, zeros, res1, zeros, res0, res1);
  2318.         }
  2319.         hz_res0 = __msa_aver_s_w(hz_res0, (v4i32) res0);
  2320.         hz_res1 = __msa_aver_s_w(hz_res1, (v4i32) res1);
  2321.         res0 = __msa_pckev_h((v8i16) hz_res1, (v8i16) hz_res0);
  2322.  
  2323.         res = PCKEV_XORI128_UB(res0, res0);
  2324.  
  2325.         dst0 = __msa_aver_u_b(res, dst0);
  2326.  
  2327.         ST4x2_UB(dst0, dst, dst_stride);
  2328.         dst += (2 * dst_stride);
  2329.  
  2330.         src0 = src2;
  2331.         src1 = src3;
  2332.         src2 = src4;
  2333.         src3 = src5;
  2334.         src4 = src6;
  2335.     }
  2336. }
  2337.  
  2338. static void avc_luma_midh_qrt_and_aver_dst_8w_msa(const uint8_t *src,
  2339.                                                   int32_t src_stride,
  2340.                                                   uint8_t *dst,
  2341.                                                   int32_t dst_stride,
  2342.                                                   int32_t height,
  2343.                                                   uint8_t horiz_offset)
  2344. {
  2345.     uint32_t multiple8_cnt;
  2346.  
  2347.     for (multiple8_cnt = 2; multiple8_cnt--;) {
  2348.         avc_luma_midh_qrt_and_aver_dst_4w_msa(src, src_stride, dst, dst_stride,
  2349.                                               height, horiz_offset);
  2350.  
  2351.         src += 4;
  2352.         dst += 4;
  2353.     }
  2354. }
  2355.  
  2356. static void avc_luma_midh_qrt_and_aver_dst_16w_msa(const uint8_t *src,
  2357.                                                    int32_t src_stride,
  2358.                                                    uint8_t *dst,
  2359.                                                    int32_t dst_stride,
  2360.                                                    int32_t height,
  2361.                                                    uint8_t horiz_offset)
  2362. {
  2363.     uint32_t multiple8_cnt;
  2364.  
  2365.     for (multiple8_cnt = 4; multiple8_cnt--;) {
  2366.         avc_luma_midh_qrt_and_aver_dst_4w_msa(src, src_stride, dst, dst_stride,
  2367.                                               height, horiz_offset);
  2368.  
  2369.         src += 4;
  2370.         dst += 4;
  2371.     }
  2372. }
  2373.  
  2374. static void avc_luma_midv_qrt_and_aver_dst_4w_msa(const uint8_t *src,
  2375.                                                   int32_t src_stride,
  2376.                                                   uint8_t *dst,
  2377.                                                   int32_t dst_stride,
  2378.                                                   int32_t height,
  2379.                                                   uint8_t ver_offset)
  2380. {
  2381.     int32_t loop_cnt;
  2382.     int32_t out0, out1;
  2383.     v16i8 src0, src1, src2, src3, src4;
  2384.     v16u8 dst0, dst1;
  2385.     v16i8 mask0, mask1, mask2;
  2386.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  2387.     v8i16 hz_out4, hz_out5, hz_out6;
  2388.     v8i16 res0, res1, res2, res3;
  2389.     v16u8 vec0, vec1;
  2390.  
  2391.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  2392.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  2393.     src += (5 * src_stride);
  2394.  
  2395.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  2396.  
  2397.     hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
  2398.                                                           mask0, mask1, mask2);
  2399.     hz_out2 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src2, src3,
  2400.                                                           mask0, mask1, mask2);
  2401.  
  2402.     PCKOD_D2_SH(hz_out0, hz_out0, hz_out2, hz_out2, hz_out1, hz_out3);
  2403.  
  2404.     hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
  2405.  
  2406.     for (loop_cnt = (height >> 1); loop_cnt--;) {
  2407.         LD_SB2(src, src_stride, src0, src1);
  2408.         src += (2 * src_stride);
  2409.  
  2410.         XORI_B2_128_SB(src0, src1);
  2411.         LD_UB2(dst, dst_stride, dst0, dst1);
  2412.         hz_out5 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src0, src1,
  2413.                                                               mask0, mask1,
  2414.                                                               mask2);
  2415.         hz_out6 = (v8i16) __msa_pckod_d((v2i64) hz_out5, (v2i64) hz_out5);
  2416.         res0 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out0, hz_out1, hz_out2,
  2417.                                                  hz_out3, hz_out4, hz_out5);
  2418.         res2 = AVC_CALC_DPADD_H_6PIX_2COEFF_R_SH(hz_out1, hz_out2, hz_out3,
  2419.                                                  hz_out4, hz_out5, hz_out6);
  2420.  
  2421.         if (ver_offset) {
  2422.             res1 = __msa_srari_h(hz_out3, 5);
  2423.             res3 = __msa_srari_h(hz_out4, 5);
  2424.         } else {
  2425.             res1 = __msa_srari_h(hz_out2, 5);
  2426.             res3 = __msa_srari_h(hz_out3, 5);
  2427.         }
  2428.  
  2429.         SAT_SH2_SH(res1, res3, 7);
  2430.  
  2431.         res0 = __msa_aver_s_h(res0, res1);
  2432.         res1 = __msa_aver_s_h(res2, res3);
  2433.  
  2434.         vec0 = PCKEV_XORI128_UB(res0, res0);
  2435.         vec1 = PCKEV_XORI128_UB(res1, res1);
  2436.  
  2437.         AVER_UB2_UB(vec0, dst0, vec1, dst1, dst0, dst1);
  2438.  
  2439.         out0 = __msa_copy_u_w((v4i32) dst0, 0);
  2440.         out1 = __msa_copy_u_w((v4i32) dst1, 0);
  2441.         SW(out0, dst);
  2442.         dst += dst_stride;
  2443.         SW(out1, dst);
  2444.         dst += dst_stride;
  2445.  
  2446.         hz_out0 = hz_out2;
  2447.         hz_out1 = hz_out3;
  2448.         hz_out2 = hz_out4;
  2449.         hz_out3 = hz_out5;
  2450.         hz_out4 = hz_out6;
  2451.     }
  2452. }
  2453.  
  2454. static void avc_luma_midv_qrt_and_aver_dst_8w_msa(const uint8_t *src,
  2455.                                                   int32_t src_stride,
  2456.                                                   uint8_t *dst,
  2457.                                                   int32_t dst_stride,
  2458.                                                   int32_t height,
  2459.                                                   uint8_t vert_offset)
  2460. {
  2461.     int32_t loop_cnt;
  2462.     v16i8 src0, src1, src2, src3, src4;
  2463.     v16u8 dst0, dst1, dst2, dst3;
  2464.     v16i8 mask0, mask1, mask2;
  2465.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  2466.     v8i16 hz_out4, hz_out5, hz_out6, hz_out7, hz_out8;
  2467.     v8i16 res0, res1, res2, res3;
  2468.     v8i16 res4, res5, res6, res7;
  2469.  
  2470.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  2471.  
  2472.     LD_SB5(src, src_stride, src0, src1, src2, src3, src4);
  2473.     XORI_B5_128_SB(src0, src1, src2, src3, src4);
  2474.     src += (5 * src_stride);
  2475.  
  2476.     hz_out0 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
  2477.     hz_out1 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
  2478.     hz_out2 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
  2479.     hz_out3 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
  2480.     hz_out4 = AVC_HORZ_FILTER_SH(src4, mask0, mask1, mask2);
  2481.  
  2482.     for (loop_cnt = (height >> 2); loop_cnt--;) {
  2483.         LD_SB4(src, src_stride, src0, src1, src2, src3);
  2484.         XORI_B4_128_SB(src0, src1, src2, src3);
  2485.         src += (4 * src_stride);
  2486.  
  2487.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2488.  
  2489.         hz_out5 = AVC_HORZ_FILTER_SH(src0, mask0, mask1, mask2);
  2490.         hz_out6 = AVC_HORZ_FILTER_SH(src1, mask0, mask1, mask2);
  2491.         hz_out7 = AVC_HORZ_FILTER_SH(src2, mask0, mask1, mask2);
  2492.         hz_out8 = AVC_HORZ_FILTER_SH(src3, mask0, mask1, mask2);
  2493.  
  2494.         res0 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out0, hz_out1, hz_out2,
  2495.                                                hz_out3, hz_out4, hz_out5);
  2496.         res2 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out1, hz_out2, hz_out3,
  2497.                                                hz_out4, hz_out5, hz_out6);
  2498.         res4 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out2, hz_out3, hz_out4,
  2499.                                                hz_out5, hz_out6, hz_out7);
  2500.         res6 = AVC_CALC_DPADD_H_6PIX_2COEFF_SH(hz_out3, hz_out4, hz_out5,
  2501.                                                hz_out6, hz_out7, hz_out8);
  2502.  
  2503.         if (vert_offset) {
  2504.             res1 = __msa_srari_h(hz_out3, 5);
  2505.             res3 = __msa_srari_h(hz_out4, 5);
  2506.             res5 = __msa_srari_h(hz_out5, 5);
  2507.             res7 = __msa_srari_h(hz_out6, 5);
  2508.         } else {
  2509.             res1 = __msa_srari_h(hz_out2, 5);
  2510.             res3 = __msa_srari_h(hz_out3, 5);
  2511.             res5 = __msa_srari_h(hz_out4, 5);
  2512.             res7 = __msa_srari_h(hz_out5, 5);
  2513.         }
  2514.  
  2515.         SAT_SH4_SH(res1, res3, res5, res7, 7);
  2516.  
  2517.         res0 = __msa_aver_s_h(res0, res1);
  2518.         res1 = __msa_aver_s_h(res2, res3);
  2519.         res2 = __msa_aver_s_h(res4, res5);
  2520.         res3 = __msa_aver_s_h(res6, res7);
  2521.  
  2522.         CONVERT_UB_AVG_ST8x4_UB(res0, res1, res2, res3, dst0, dst1, dst2, dst3,
  2523.                                 dst, dst_stride);
  2524.         dst += (4 * dst_stride);
  2525.  
  2526.         hz_out0 = hz_out4;
  2527.         hz_out1 = hz_out5;
  2528.         hz_out2 = hz_out6;
  2529.         hz_out3 = hz_out7;
  2530.         hz_out4 = hz_out8;
  2531.     }
  2532. }
  2533.  
  2534. static void avc_luma_midv_qrt_and_aver_dst_16w_msa(const uint8_t *src,
  2535.                                                    int32_t src_stride,
  2536.                                                    uint8_t *dst,
  2537.                                                    int32_t dst_stride,
  2538.                                                    int32_t height,
  2539.                                                    uint8_t vert_offset)
  2540. {
  2541.     int32_t multiple8_cnt;
  2542.  
  2543.     for (multiple8_cnt = 2; multiple8_cnt--;) {
  2544.         avc_luma_midv_qrt_and_aver_dst_8w_msa(src, src_stride, dst, dst_stride,
  2545.                                               height, vert_offset);
  2546.  
  2547.         src += 8;
  2548.         dst += 8;
  2549.     }
  2550. }
  2551.  
  2552. static void avc_luma_hv_qrt_and_aver_dst_4x4_msa(const uint8_t *src_x,
  2553.                                                  const uint8_t *src_y,
  2554.                                                  int32_t src_stride,
  2555.                                                  uint8_t *dst,
  2556.                                                  int32_t dst_stride)
  2557. {
  2558.     v16i8 src_hz0, src_hz1, src_hz2, src_hz3;
  2559.     v16u8 dst0, dst1, dst2, dst3;
  2560.     v16i8 src_vt0, src_vt1, src_vt2, src_vt3, src_vt4;
  2561.     v16i8 src_vt5, src_vt6, src_vt7, src_vt8;
  2562.     v16i8 mask0, mask1, mask2;
  2563.     v8i16 hz_out0, hz_out1, vert_out0, vert_out1;
  2564.     v8i16 res0, res1;
  2565.     v16u8 res;
  2566.  
  2567.     LD_SB3(&luma_mask_arr[48], 16, mask0, mask1, mask2);
  2568.     LD_SB5(src_y, src_stride, src_vt0, src_vt1, src_vt2, src_vt3, src_vt4);
  2569.     src_y += (5 * src_stride);
  2570.  
  2571.     src_vt0 = (v16i8) __msa_insve_w((v4i32) src_vt0, 1, (v4i32) src_vt1);
  2572.     src_vt1 = (v16i8) __msa_insve_w((v4i32) src_vt1, 1, (v4i32) src_vt2);
  2573.     src_vt2 = (v16i8) __msa_insve_w((v4i32) src_vt2, 1, (v4i32) src_vt3);
  2574.     src_vt3 = (v16i8) __msa_insve_w((v4i32) src_vt3, 1, (v4i32) src_vt4);
  2575.  
  2576.     XORI_B4_128_SB(src_vt0, src_vt1, src_vt2, src_vt3);
  2577.     LD_SB4(src_x, src_stride, src_hz0, src_hz1, src_hz2, src_hz3);
  2578.     LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2579.     XORI_B4_128_SB(src_hz0, src_hz1, src_hz2, src_hz3);
  2580.     hz_out0 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src_hz0, src_hz1,
  2581.                                                           mask0, mask1, mask2);
  2582.     hz_out1 = AVC_XOR_VSHF_B_AND_APPLY_6TAP_HORIZ_FILT_SH(src_hz2, src_hz3,
  2583.                                                           mask0, mask1, mask2);
  2584.     SRARI_H2_SH(hz_out0, hz_out1, 5);
  2585.     SAT_SH2_SH(hz_out0, hz_out1, 7);
  2586.     LD_SB4(src_y, src_stride, src_vt5, src_vt6, src_vt7, src_vt8);
  2587.  
  2588.     src_vt4 = (v16i8) __msa_insve_w((v4i32) src_vt4, 1, (v4i32) src_vt5);
  2589.     src_vt5 = (v16i8) __msa_insve_w((v4i32) src_vt5, 1, (v4i32) src_vt6);
  2590.     src_vt6 = (v16i8) __msa_insve_w((v4i32) src_vt6, 1, (v4i32) src_vt7);
  2591.     src_vt7 = (v16i8) __msa_insve_w((v4i32) src_vt7, 1, (v4i32) src_vt8);
  2592.  
  2593.     XORI_B4_128_SB(src_vt4, src_vt5, src_vt6, src_vt7);
  2594.  
  2595.     /* filter calc */
  2596.     vert_out0 = AVC_CALC_DPADD_B_6PIX_2COEFF_R_SH(src_vt0, src_vt1, src_vt2,
  2597.                                                   src_vt3, src_vt4, src_vt5);
  2598.     vert_out1 = AVC_CALC_DPADD_B_6PIX_2COEFF_R_SH(src_vt2, src_vt3, src_vt4,
  2599.                                                   src_vt5, src_vt6, src_vt7);
  2600.     SRARI_H2_SH(vert_out0, vert_out1, 5);
  2601.     SAT_SH2_SH(vert_out0, vert_out1, 7);
  2602.  
  2603.     res1 = __msa_srari_h((hz_out1 + vert_out1), 1);
  2604.     res0 = __msa_srari_h((hz_out0 + vert_out0), 1);
  2605.  
  2606.     SAT_SH2_SH(res0, res1, 7);
  2607.     res = PCKEV_XORI128_UB(res0, res1);
  2608.  
  2609.     dst0 = (v16u8) __msa_insve_w((v4i32) dst0, 1, (v4i32) dst1);
  2610.     dst1 = (v16u8) __msa_insve_w((v4i32) dst2, 1, (v4i32) dst3);
  2611.     dst0 = (v16u8) __msa_insve_d((v2i64) dst0, 1, (v2i64) dst1);
  2612.     dst0 = __msa_aver_u_b(res, dst0);
  2613.  
  2614.     ST4x4_UB(dst0, dst0, 0, 1, 2, 3, dst, dst_stride);
  2615. }
  2616.  
  2617. static void avc_luma_hv_qrt_and_aver_dst_8x8_msa(const uint8_t *src_x,
  2618.                                                  const uint8_t *src_y,
  2619.                                                  int32_t src_stride,
  2620.                                                  uint8_t *dst,
  2621.                                                  int32_t dst_stride)
  2622. {
  2623.     uint32_t loop_cnt;
  2624.     v16i8 src_hz0, src_hz1, src_hz2, src_hz3;
  2625.     v16u8 dst0, dst1, dst2, dst3;
  2626.     v16i8 src_vt0, src_vt1, src_vt2, src_vt3;
  2627.     v16i8 src_vt4, src_vt5, src_vt6, src_vt7, src_vt8;
  2628.     v16i8 mask0, mask1, mask2;
  2629.     v8i16 hz_out0, hz_out1, hz_out2, hz_out3;
  2630.     v8i16 vert_out0, vert_out1, vert_out2, vert_out3;
  2631.     v8i16 out0, out1, out2, out3;
  2632.  
  2633.     LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  2634.  
  2635.     LD_SB5(src_y, src_stride, src_vt0, src_vt1, src_vt2, src_vt3, src_vt4);
  2636.     src_y += (5 * src_stride);
  2637.  
  2638.     src_vt0 = (v16i8) __msa_insve_d((v2i64) src_vt0, 1, (v2i64) src_vt1);
  2639.     src_vt1 = (v16i8) __msa_insve_d((v2i64) src_vt1, 1, (v2i64) src_vt2);
  2640.     src_vt2 = (v16i8) __msa_insve_d((v2i64) src_vt2, 1, (v2i64) src_vt3);
  2641.     src_vt3 = (v16i8) __msa_insve_d((v2i64) src_vt3, 1, (v2i64) src_vt4);
  2642.  
  2643.     XORI_B4_128_SB(src_vt0, src_vt1, src_vt2, src_vt3);
  2644.  
  2645.     for (loop_cnt = 2; loop_cnt--;) {
  2646.         LD_SB4(src_x, src_stride, src_hz0, src_hz1, src_hz2, src_hz3);
  2647.         XORI_B4_128_SB(src_hz0, src_hz1, src_hz2, src_hz3);
  2648.         src_x += (4 * src_stride);
  2649.  
  2650.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2651.         hz_out0 = AVC_HORZ_FILTER_SH(src_hz0, mask0, mask1, mask2);
  2652.         hz_out1 = AVC_HORZ_FILTER_SH(src_hz1, mask0, mask1, mask2);
  2653.         hz_out2 = AVC_HORZ_FILTER_SH(src_hz2, mask0, mask1, mask2);
  2654.         hz_out3 = AVC_HORZ_FILTER_SH(src_hz3, mask0, mask1, mask2);
  2655.         SRARI_H4_SH(hz_out0, hz_out1, hz_out2, hz_out3, 5);
  2656.         SAT_SH4_SH(hz_out0, hz_out1, hz_out2, hz_out3, 7);
  2657.         LD_SB4(src_y, src_stride, src_vt5, src_vt6, src_vt7, src_vt8);
  2658.         src_y += (4 * src_stride);
  2659.  
  2660.         src_vt4 = (v16i8) __msa_insve_d((v2i64) src_vt4, 1, (v2i64) src_vt5);
  2661.         src_vt5 = (v16i8) __msa_insve_d((v2i64) src_vt5, 1, (v2i64) src_vt6);
  2662.         src_vt6 = (v16i8) __msa_insve_d((v2i64) src_vt6, 1, (v2i64) src_vt7);
  2663.         src_vt7 = (v16i8) __msa_insve_d((v2i64) src_vt7, 1, (v2i64) src_vt8);
  2664.  
  2665.         XORI_B4_128_SB(src_vt4, src_vt5, src_vt6, src_vt7);
  2666.         AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src_vt0, src_vt1, src_vt2, src_vt3,
  2667.                                         src_vt4, src_vt5, vert_out0, vert_out1);
  2668.         AVC_CALC_DPADD_B_6PIX_2COEFF_SH(src_vt2, src_vt3, src_vt4, src_vt5,
  2669.                                         src_vt6, src_vt7, vert_out2, vert_out3);
  2670.         SRARI_H4_SH(vert_out0, vert_out1, vert_out2, vert_out3, 5);
  2671.         SAT_SH4_SH(vert_out0, vert_out1, vert_out2, vert_out3, 7);
  2672.  
  2673.         out0 = __msa_srari_h((hz_out0 + vert_out0), 1);
  2674.         out1 = __msa_srari_h((hz_out1 + vert_out1), 1);
  2675.         out2 = __msa_srari_h((hz_out2 + vert_out2), 1);
  2676.         out3 = __msa_srari_h((hz_out3 + vert_out3), 1);
  2677.  
  2678.         SAT_SH4_SH(out0, out1, out2, out3, 7);
  2679.         CONVERT_UB_AVG_ST8x4_UB(out0, out1, out2, out3, dst0, dst1, dst2, dst3,
  2680.                                 dst, dst_stride);
  2681.         dst += (4 * dst_stride);
  2682.  
  2683.         src_vt0 = src_vt4;
  2684.         src_vt1 = src_vt5;
  2685.         src_vt2 = src_vt6;
  2686.         src_vt3 = src_vt7;
  2687.         src_vt4 = src_vt8;
  2688.     }
  2689. }
  2690.  
  2691. static void avc_luma_hv_qrt_and_aver_dst_16x16_msa(const uint8_t *src_x,
  2692.                                                    const uint8_t *src_y,
  2693.                                                    int32_t src_stride,
  2694.                                                    uint8_t *dst,
  2695.                                                    int32_t dst_stride)
  2696. {
  2697.     uint32_t multiple8_cnt;
  2698.  
  2699.     for (multiple8_cnt = 2; multiple8_cnt--;) {
  2700.         avc_luma_hv_qrt_and_aver_dst_8x8_msa(src_x, src_y, src_stride,
  2701.                                              dst, dst_stride);
  2702.  
  2703.         src_x += 8;
  2704.         src_y += 8;
  2705.         dst += 8;
  2706.     }
  2707.  
  2708.     src_x += (8 * src_stride) - 16;
  2709.     src_y += (8 * src_stride) - 16;
  2710.     dst += (8 * dst_stride) - 16;
  2711.  
  2712.     for (multiple8_cnt = 2; multiple8_cnt--;) {
  2713.         avc_luma_hv_qrt_and_aver_dst_8x8_msa(src_x, src_y, src_stride,
  2714.                                              dst, dst_stride);
  2715.  
  2716.         src_x += 8;
  2717.         src_y += 8;
  2718.         dst += 8;
  2719.     }
  2720. }
  2721.  
  2722. static void copy_width8_msa(const uint8_t *src, int32_t src_stride,
  2723.                             uint8_t *dst, int32_t dst_stride,
  2724.                             int32_t height)
  2725. {
  2726.     int32_t cnt;
  2727.     uint64_t out0, out1, out2, out3, out4, out5, out6, out7;
  2728.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
  2729.  
  2730.     if (0 == height % 12) {
  2731.         for (cnt = (height / 12); cnt--;) {
  2732.             LD_UB8(src, src_stride,
  2733.                    src0, src1, src2, src3, src4, src5, src6, src7);
  2734.             src += (8 * src_stride);
  2735.  
  2736.             out0 = __msa_copy_u_d((v2i64) src0, 0);
  2737.             out1 = __msa_copy_u_d((v2i64) src1, 0);
  2738.             out2 = __msa_copy_u_d((v2i64) src2, 0);
  2739.             out3 = __msa_copy_u_d((v2i64) src3, 0);
  2740.             out4 = __msa_copy_u_d((v2i64) src4, 0);
  2741.             out5 = __msa_copy_u_d((v2i64) src5, 0);
  2742.             out6 = __msa_copy_u_d((v2i64) src6, 0);
  2743.             out7 = __msa_copy_u_d((v2i64) src7, 0);
  2744.  
  2745.             SD4(out0, out1, out2, out3, dst, dst_stride);
  2746.             dst += (4 * dst_stride);
  2747.             SD4(out4, out5, out6, out7, dst, dst_stride);
  2748.             dst += (4 * dst_stride);
  2749.  
  2750.             LD_UB4(src, src_stride, src0, src1, src2, src3);
  2751.             src += (4 * src_stride);
  2752.  
  2753.             out0 = __msa_copy_u_d((v2i64) src0, 0);
  2754.             out1 = __msa_copy_u_d((v2i64) src1, 0);
  2755.             out2 = __msa_copy_u_d((v2i64) src2, 0);
  2756.             out3 = __msa_copy_u_d((v2i64) src3, 0);
  2757.  
  2758.             SD4(out0, out1, out2, out3, dst, dst_stride);
  2759.             dst += (4 * dst_stride);
  2760.         }
  2761.     } else if (0 == height % 8) {
  2762.         for (cnt = height >> 3; cnt--;) {
  2763.             LD_UB8(src, src_stride,
  2764.                    src0, src1, src2, src3, src4, src5, src6, src7);
  2765.             src += (8 * src_stride);
  2766.  
  2767.             out0 = __msa_copy_u_d((v2i64) src0, 0);
  2768.             out1 = __msa_copy_u_d((v2i64) src1, 0);
  2769.             out2 = __msa_copy_u_d((v2i64) src2, 0);
  2770.             out3 = __msa_copy_u_d((v2i64) src3, 0);
  2771.             out4 = __msa_copy_u_d((v2i64) src4, 0);
  2772.             out5 = __msa_copy_u_d((v2i64) src5, 0);
  2773.             out6 = __msa_copy_u_d((v2i64) src6, 0);
  2774.             out7 = __msa_copy_u_d((v2i64) src7, 0);
  2775.  
  2776.             SD4(out0, out1, out2, out3, dst, dst_stride);
  2777.             dst += (4 * dst_stride);
  2778.             SD4(out4, out5, out6, out7, dst, dst_stride);
  2779.             dst += (4 * dst_stride);
  2780.         }
  2781.     } else if (0 == height % 4) {
  2782.         for (cnt = (height / 4); cnt--;) {
  2783.             LD_UB4(src, src_stride, src0, src1, src2, src3);
  2784.             src += (4 * src_stride);
  2785.             out0 = __msa_copy_u_d((v2i64) src0, 0);
  2786.             out1 = __msa_copy_u_d((v2i64) src1, 0);
  2787.             out2 = __msa_copy_u_d((v2i64) src2, 0);
  2788.             out3 = __msa_copy_u_d((v2i64) src3, 0);
  2789.  
  2790.             SD4(out0, out1, out2, out3, dst, dst_stride);
  2791.             dst += (4 * dst_stride);
  2792.         }
  2793.     } else if (0 == height % 2) {
  2794.         for (cnt = (height / 2); cnt--;) {
  2795.             LD_UB2(src, src_stride, src0, src1);
  2796.             src += (2 * src_stride);
  2797.             out0 = __msa_copy_u_d((v2i64) src0, 0);
  2798.             out1 = __msa_copy_u_d((v2i64) src1, 0);
  2799.  
  2800.             SD(out0, dst);
  2801.             dst += dst_stride;
  2802.             SD(out1, dst);
  2803.             dst += dst_stride;
  2804.         }
  2805.     }
  2806. }
  2807.  
  2808. static void copy_16multx8mult_msa(const uint8_t *src, int32_t src_stride,
  2809.                                   uint8_t *dst, int32_t dst_stride,
  2810.                                   int32_t height, int32_t width)
  2811. {
  2812.     int32_t cnt, loop_cnt;
  2813.     const uint8_t *src_tmp;
  2814.     uint8_t *dst_tmp;
  2815.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
  2816.  
  2817.     for (cnt = (width >> 4); cnt--;) {
  2818.         src_tmp = src;
  2819.         dst_tmp = dst;
  2820.  
  2821.         for (loop_cnt = (height >> 3); loop_cnt--;) {
  2822.             LD_UB8(src_tmp, src_stride,
  2823.                    src0, src1, src2, src3, src4, src5, src6, src7);
  2824.             src_tmp += (8 * src_stride);
  2825.  
  2826.             ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
  2827.                    dst_tmp, dst_stride);
  2828.             dst_tmp += (8 * dst_stride);
  2829.         }
  2830.  
  2831.         src += 16;
  2832.         dst += 16;
  2833.     }
  2834. }
  2835.  
  2836. static void copy_width16_msa(const uint8_t *src, int32_t src_stride,
  2837.                              uint8_t *dst, int32_t dst_stride,
  2838.                              int32_t height)
  2839. {
  2840.     int32_t cnt;
  2841.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
  2842.  
  2843.     if (0 == height % 12) {
  2844.         for (cnt = (height / 12); cnt--;) {
  2845.             LD_UB8(src, src_stride,
  2846.                    src0, src1, src2, src3, src4, src5, src6, src7);
  2847.             src += (8 * src_stride);
  2848.             ST_UB8(src0, src1, src2, src3, src4, src5, src6, src7,
  2849.                    dst, dst_stride);
  2850.             dst += (8 * dst_stride);
  2851.  
  2852.             LD_UB4(src, src_stride, src0, src1, src2, src3);
  2853.             src += (4 * src_stride);
  2854.             ST_UB4(src0, src1, src2, src3, dst, dst_stride);
  2855.             dst += (4 * dst_stride);
  2856.         }
  2857.     } else if (0 == height % 8) {
  2858.         copy_16multx8mult_msa(src, src_stride, dst, dst_stride, height, 16);
  2859.     } else if (0 == height % 4) {
  2860.         for (cnt = (height >> 2); cnt--;) {
  2861.             LD_UB4(src, src_stride, src0, src1, src2, src3);
  2862.             src += (4 * src_stride);
  2863.  
  2864.             ST_UB4(src0, src1, src2, src3, dst, dst_stride);
  2865.             dst += (4 * dst_stride);
  2866.         }
  2867.     }
  2868. }
  2869.  
  2870. static void avg_width4_msa(const uint8_t *src, int32_t src_stride,
  2871.                            uint8_t *dst, int32_t dst_stride,
  2872.                            int32_t height)
  2873. {
  2874.     int32_t cnt;
  2875.     uint32_t out0, out1, out2, out3;
  2876.     v16u8 src0, src1, src2, src3;
  2877.     v16u8 dst0, dst1, dst2, dst3;
  2878.  
  2879.     if (0 == (height % 4)) {
  2880.         for (cnt = (height / 4); cnt--;) {
  2881.             LD_UB4(src, src_stride, src0, src1, src2, src3);
  2882.             src += (4 * src_stride);
  2883.  
  2884.             LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2885.  
  2886.             AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
  2887.                         dst0, dst1, dst2, dst3);
  2888.  
  2889.             out0 = __msa_copy_u_w((v4i32) dst0, 0);
  2890.             out1 = __msa_copy_u_w((v4i32) dst1, 0);
  2891.             out2 = __msa_copy_u_w((v4i32) dst2, 0);
  2892.             out3 = __msa_copy_u_w((v4i32) dst3, 0);
  2893.             SW4(out0, out1, out2, out3, dst, dst_stride);
  2894.             dst += (4 * dst_stride);
  2895.         }
  2896.     } else if (0 == (height % 2)) {
  2897.         for (cnt = (height / 2); cnt--;) {
  2898.             LD_UB2(src, src_stride, src0, src1);
  2899.             src += (2 * src_stride);
  2900.  
  2901.             LD_UB2(dst, dst_stride, dst0, dst1);
  2902.  
  2903.             AVER_UB2_UB(src0, dst0, src1, dst1, dst0, dst1);
  2904.  
  2905.             out0 = __msa_copy_u_w((v4i32) dst0, 0);
  2906.             out1 = __msa_copy_u_w((v4i32) dst1, 0);
  2907.             SW(out0, dst);
  2908.             dst += dst_stride;
  2909.             SW(out1, dst);
  2910.             dst += dst_stride;
  2911.         }
  2912.     }
  2913. }
  2914.  
  2915. static void avg_width8_msa(const uint8_t *src, int32_t src_stride,
  2916.                            uint8_t *dst, int32_t dst_stride,
  2917.                            int32_t height)
  2918. {
  2919.     int32_t cnt;
  2920.     uint64_t out0, out1, out2, out3;
  2921.     v16u8 src0, src1, src2, src3;
  2922.     v16u8 dst0, dst1, dst2, dst3;
  2923.  
  2924.     for (cnt = (height / 4); cnt--;) {
  2925.         LD_UB4(src, src_stride, src0, src1, src2, src3);
  2926.         src += (4 * src_stride);
  2927.         LD_UB4(dst, dst_stride, dst0, dst1, dst2, dst3);
  2928.  
  2929.         AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
  2930.                     dst0, dst1, dst2, dst3);
  2931.  
  2932.         out0 = __msa_copy_u_d((v2i64) dst0, 0);
  2933.         out1 = __msa_copy_u_d((v2i64) dst1, 0);
  2934.         out2 = __msa_copy_u_d((v2i64) dst2, 0);
  2935.         out3 = __msa_copy_u_d((v2i64) dst3, 0);
  2936.         SD4(out0, out1, out2, out3, dst, dst_stride);
  2937.         dst += (4 * dst_stride);
  2938.     }
  2939. }
  2940.  
  2941. static void avg_width16_msa(const uint8_t *src, int32_t src_stride,
  2942.                             uint8_t *dst, int32_t dst_stride,
  2943.                             int32_t height)
  2944. {
  2945.     int32_t cnt;
  2946.     v16u8 src0, src1, src2, src3, src4, src5, src6, src7;
  2947.     v16u8 dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7;
  2948.  
  2949.     for (cnt = (height / 8); cnt--;) {
  2950.         LD_UB8(src, src_stride, src0, src1, src2, src3, src4, src5, src6, src7);
  2951.         src += (8 * src_stride);
  2952.         LD_UB8(dst, dst_stride, dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7);
  2953.  
  2954.         AVER_UB4_UB(src0, dst0, src1, dst1, src2, dst2, src3, dst3,
  2955.                     dst0, dst1, dst2, dst3);
  2956.         AVER_UB4_UB(src4, dst4, src5, dst5, src6, dst6, src7, dst7,
  2957.                     dst4, dst5, dst6, dst7);
  2958.         ST_UB8(dst0, dst1, dst2, dst3, dst4, dst5, dst6, dst7, dst, dst_stride);
  2959.         dst += (8 * dst_stride);
  2960.     }
  2961. }
  2962.  
  2963. void ff_put_h264_qpel16_mc00_msa(uint8_t *dst, const uint8_t *src,
  2964.                                  ptrdiff_t stride)
  2965. {
  2966.     copy_width16_msa(src, stride, dst, stride, 16);
  2967. }
  2968.  
  2969. void ff_put_h264_qpel8_mc00_msa(uint8_t *dst, const uint8_t *src,
  2970.                                 ptrdiff_t stride)
  2971. {
  2972.     copy_width8_msa(src, stride, dst, stride, 8);
  2973. }
  2974.  
  2975. void ff_avg_h264_qpel16_mc00_msa(uint8_t *dst, const uint8_t *src,
  2976.                                  ptrdiff_t stride)
  2977. {
  2978.     avg_width16_msa(src, stride, dst, stride, 16);
  2979. }
  2980.  
  2981. void ff_avg_h264_qpel8_mc00_msa(uint8_t *dst, const uint8_t *src,
  2982.                                 ptrdiff_t stride)
  2983. {
  2984.     avg_width8_msa(src, stride, dst, stride, 8);
  2985. }
  2986.  
  2987. void ff_avg_h264_qpel4_mc00_msa(uint8_t *dst, const uint8_t *src,
  2988.                                 ptrdiff_t stride)
  2989. {
  2990.     avg_width4_msa(src, stride, dst, stride, 4);
  2991. }
  2992.  
  2993. void ff_put_h264_qpel16_mc10_msa(uint8_t *dst, const uint8_t *src,
  2994.                                  ptrdiff_t stride)
  2995. {
  2996.     avc_luma_hz_qrt_16w_msa(src - 2, stride, dst, stride, 16, 0);
  2997. }
  2998.  
  2999. void ff_put_h264_qpel16_mc30_msa(uint8_t *dst, const uint8_t *src,
  3000.                                  ptrdiff_t stride)
  3001. {
  3002.     avc_luma_hz_qrt_16w_msa(src - 2, stride, dst, stride, 16, 1);
  3003. }
  3004.  
  3005. void ff_put_h264_qpel8_mc10_msa(uint8_t *dst, const uint8_t *src,
  3006.                                 ptrdiff_t stride)
  3007. {
  3008.     avc_luma_hz_qrt_8w_msa(src - 2, stride, dst, stride, 8, 0);
  3009. }
  3010.  
  3011. void ff_put_h264_qpel8_mc30_msa(uint8_t *dst, const uint8_t *src,
  3012.                                 ptrdiff_t stride)
  3013. {
  3014.     avc_luma_hz_qrt_8w_msa(src - 2, stride, dst, stride, 8, 1);
  3015. }
  3016.  
  3017. void ff_put_h264_qpel4_mc10_msa(uint8_t *dst, const uint8_t *src,
  3018.                                 ptrdiff_t stride)
  3019. {
  3020.     avc_luma_hz_qrt_4w_msa(src - 2, stride, dst, stride, 4, 0);
  3021. }
  3022.  
  3023. void ff_put_h264_qpel4_mc30_msa(uint8_t *dst, const uint8_t *src,
  3024.                                 ptrdiff_t stride)
  3025. {
  3026.     avc_luma_hz_qrt_4w_msa(src - 2, stride, dst, stride, 4, 1);
  3027. }
  3028.  
  3029. void ff_put_h264_qpel16_mc20_msa(uint8_t *dst, const uint8_t *src,
  3030.                                  ptrdiff_t stride)
  3031. {
  3032.     avc_luma_hz_16w_msa(src - 2, stride, dst, stride, 16);
  3033. }
  3034.  
  3035. void ff_put_h264_qpel8_mc20_msa(uint8_t *dst, const uint8_t *src,
  3036.                                 ptrdiff_t stride)
  3037. {
  3038.     avc_luma_hz_8w_msa(src - 2, stride, dst, stride, 8);
  3039. }
  3040.  
  3041. void ff_put_h264_qpel4_mc20_msa(uint8_t *dst, const uint8_t *src,
  3042.                                 ptrdiff_t stride)
  3043. {
  3044.     avc_luma_hz_4w_msa(src - 2, stride, dst, stride, 4);
  3045. }
  3046.  
  3047. void ff_put_h264_qpel16_mc01_msa(uint8_t *dst, const uint8_t *src,
  3048.                                  ptrdiff_t stride)
  3049. {
  3050.     avc_luma_vt_qrt_16w_msa(src - (stride * 2), stride, dst, stride, 16, 0);
  3051. }
  3052.  
  3053. void ff_put_h264_qpel16_mc03_msa(uint8_t *dst, const uint8_t *src,
  3054.                                  ptrdiff_t stride)
  3055. {
  3056.     avc_luma_vt_qrt_16w_msa(src - (stride * 2), stride, dst, stride, 16, 1);
  3057. }
  3058.  
  3059. void ff_put_h264_qpel8_mc01_msa(uint8_t *dst, const uint8_t *src,
  3060.                                 ptrdiff_t stride)
  3061. {
  3062.     avc_luma_vt_qrt_8w_msa(src - (stride * 2), stride, dst, stride, 8, 0);
  3063. }
  3064.  
  3065. void ff_put_h264_qpel8_mc03_msa(uint8_t *dst, const uint8_t *src,
  3066.                                 ptrdiff_t stride)
  3067. {
  3068.     avc_luma_vt_qrt_8w_msa(src - (stride * 2), stride, dst, stride, 8, 1);
  3069. }
  3070.  
  3071. void ff_put_h264_qpel4_mc01_msa(uint8_t *dst, const uint8_t *src,
  3072.                                 ptrdiff_t stride)
  3073. {
  3074.     avc_luma_vt_qrt_4w_msa(src - (stride * 2), stride, dst, stride, 4, 0);
  3075. }
  3076.  
  3077. void ff_put_h264_qpel4_mc03_msa(uint8_t *dst, const uint8_t *src,
  3078.                                 ptrdiff_t stride)
  3079. {
  3080.     avc_luma_vt_qrt_4w_msa(src - (stride * 2), stride, dst, stride, 4, 1);
  3081. }
  3082.  
  3083. void ff_put_h264_qpel16_mc11_msa(uint8_t *dst, const uint8_t *src,
  3084.                                  ptrdiff_t stride)
  3085. {
  3086.     avc_luma_hv_qrt_16w_msa(src - 2,
  3087.                             src - (stride * 2), stride, dst, stride, 16);
  3088. }
  3089.  
  3090. void ff_put_h264_qpel16_mc31_msa(uint8_t *dst, const uint8_t *src,
  3091.                                  ptrdiff_t stride)
  3092. {
  3093.     avc_luma_hv_qrt_16w_msa(src - 2,
  3094.                             src - (stride * 2) +
  3095.                             sizeof(uint8_t), stride, dst, stride, 16);
  3096. }
  3097.  
  3098. void ff_put_h264_qpel16_mc13_msa(uint8_t *dst, const uint8_t *src,
  3099.                                  ptrdiff_t stride)
  3100. {
  3101.     avc_luma_hv_qrt_16w_msa(src + stride - 2,
  3102.                             src - (stride * 2), stride, dst, stride, 16);
  3103. }
  3104.  
  3105. void ff_put_h264_qpel16_mc33_msa(uint8_t *dst, const uint8_t *src,
  3106.                                  ptrdiff_t stride)
  3107. {
  3108.     avc_luma_hv_qrt_16w_msa(src + stride - 2,
  3109.                             src - (stride * 2) +
  3110.                             sizeof(uint8_t), stride, dst, stride, 16);
  3111. }
  3112.  
  3113. void ff_put_h264_qpel8_mc11_msa(uint8_t *dst, const uint8_t *src,
  3114.                                 ptrdiff_t stride)
  3115. {
  3116.     avc_luma_hv_qrt_8w_msa(src - 2, src - (stride * 2), stride, dst, stride, 8);
  3117. }
  3118.  
  3119. void ff_put_h264_qpel8_mc31_msa(uint8_t *dst, const uint8_t *src,
  3120.                                 ptrdiff_t stride)
  3121. {
  3122.     avc_luma_hv_qrt_8w_msa(src - 2,
  3123.                            src - (stride * 2) +
  3124.                            sizeof(uint8_t), stride, dst, stride, 8);
  3125. }
  3126.  
  3127. void ff_put_h264_qpel8_mc13_msa(uint8_t *dst, const uint8_t *src,
  3128.                                 ptrdiff_t stride)
  3129. {
  3130.     avc_luma_hv_qrt_8w_msa(src + stride - 2,
  3131.                            src - (stride * 2), stride, dst, stride, 8);
  3132. }
  3133.  
  3134. void ff_put_h264_qpel8_mc33_msa(uint8_t *dst, const uint8_t *src,
  3135.                                 ptrdiff_t stride)
  3136. {
  3137.     avc_luma_hv_qrt_8w_msa(src + stride - 2,
  3138.                            src - (stride * 2) +
  3139.                            sizeof(uint8_t), stride, dst, stride, 8);
  3140. }
  3141.  
  3142.  
  3143. void ff_put_h264_qpel4_mc11_msa(uint8_t *dst, const uint8_t *src,
  3144.                                 ptrdiff_t stride)
  3145. {
  3146.     avc_luma_hv_qrt_4w_msa(src - 2, src - (stride * 2), stride, dst, stride, 4);
  3147. }
  3148.  
  3149. void ff_put_h264_qpel4_mc31_msa(uint8_t *dst, const uint8_t *src,
  3150.                                 ptrdiff_t stride)
  3151. {
  3152.     avc_luma_hv_qrt_4w_msa(src - 2,
  3153.                            src - (stride * 2) +
  3154.                            sizeof(uint8_t), stride, dst, stride, 4);
  3155. }
  3156.  
  3157. void ff_put_h264_qpel4_mc13_msa(uint8_t *dst, const uint8_t *src,
  3158.                                 ptrdiff_t stride)
  3159. {
  3160.     avc_luma_hv_qrt_4w_msa(src + stride - 2,
  3161.                            src - (stride * 2), stride, dst, stride, 4);
  3162. }
  3163.  
  3164. void ff_put_h264_qpel4_mc33_msa(uint8_t *dst, const uint8_t *src,
  3165.                                 ptrdiff_t stride)
  3166. {
  3167.     avc_luma_hv_qrt_4w_msa(src + stride - 2,
  3168.                            src - (stride * 2) +
  3169.                            sizeof(uint8_t), stride, dst, stride, 4);
  3170. }
  3171.  
  3172. void ff_put_h264_qpel16_mc21_msa(uint8_t *dst, const uint8_t *src,
  3173.                                  ptrdiff_t stride)
  3174. {
  3175.     avc_luma_midv_qrt_16w_msa(src - (2 * stride) - 2,
  3176.                               stride, dst, stride, 16, 0);
  3177. }
  3178.  
  3179. void ff_put_h264_qpel16_mc23_msa(uint8_t *dst, const uint8_t *src,
  3180.                                  ptrdiff_t stride)
  3181. {
  3182.     avc_luma_midv_qrt_16w_msa(src - (2 * stride) - 2,
  3183.                               stride, dst, stride, 16, 1);
  3184. }
  3185.  
  3186. void ff_put_h264_qpel8_mc21_msa(uint8_t *dst, const uint8_t *src,
  3187.                                 ptrdiff_t stride)
  3188. {
  3189.     avc_luma_midv_qrt_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8, 0);
  3190. }
  3191.  
  3192. void ff_put_h264_qpel8_mc23_msa(uint8_t *dst, const uint8_t *src,
  3193.                                 ptrdiff_t stride)
  3194. {
  3195.     avc_luma_midv_qrt_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8, 1);
  3196. }
  3197.  
  3198. void ff_put_h264_qpel4_mc21_msa(uint8_t *dst, const uint8_t *src,
  3199.                                 ptrdiff_t stride)
  3200. {
  3201.     avc_luma_midv_qrt_4w_msa(src - (2 * stride) - 2, stride, dst, stride, 4, 0);
  3202. }
  3203.  
  3204. void ff_put_h264_qpel4_mc23_msa(uint8_t *dst, const uint8_t *src,
  3205.                                 ptrdiff_t stride)
  3206. {
  3207.     avc_luma_midv_qrt_4w_msa(src - (2 * stride) - 2, stride, dst, stride, 4, 1);
  3208. }
  3209.  
  3210. void ff_put_h264_qpel16_mc02_msa(uint8_t *dst, const uint8_t *src,
  3211.                                  ptrdiff_t stride)
  3212. {
  3213.     avc_luma_vt_16w_msa(src - (stride * 2), stride, dst, stride, 16);
  3214. }
  3215.  
  3216. void ff_put_h264_qpel8_mc02_msa(uint8_t *dst, const uint8_t *src,
  3217.                                 ptrdiff_t stride)
  3218. {
  3219.     avc_luma_vt_8w_msa(src - (stride * 2), stride, dst, stride, 8);
  3220. }
  3221.  
  3222. void ff_put_h264_qpel4_mc02_msa(uint8_t *dst, const uint8_t *src,
  3223.                                 ptrdiff_t stride)
  3224. {
  3225.     avc_luma_vt_4w_msa(src - (stride * 2), stride, dst, stride, 4);
  3226. }
  3227.  
  3228. void ff_put_h264_qpel16_mc12_msa(uint8_t *dst, const uint8_t *src,
  3229.                                  ptrdiff_t stride)
  3230. {
  3231.     avc_luma_midh_qrt_16w_msa(src - (2 * stride) - 2,
  3232.                               stride, dst, stride, 16, 0);
  3233. }
  3234.  
  3235. void ff_put_h264_qpel16_mc32_msa(uint8_t *dst, const uint8_t *src,
  3236.                                  ptrdiff_t stride)
  3237. {
  3238.     avc_luma_midh_qrt_16w_msa(src - (2 * stride) - 2,
  3239.                               stride, dst, stride, 16, 1);
  3240. }
  3241.  
  3242. void ff_put_h264_qpel8_mc12_msa(uint8_t *dst, const uint8_t *src,
  3243.                                 ptrdiff_t stride)
  3244. {
  3245.     avc_luma_midh_qrt_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8, 0);
  3246. }
  3247.  
  3248. void ff_put_h264_qpel8_mc32_msa(uint8_t *dst, const uint8_t *src,
  3249.                                 ptrdiff_t stride)
  3250. {
  3251.     avc_luma_midh_qrt_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8, 1);
  3252. }
  3253.  
  3254. void ff_put_h264_qpel4_mc12_msa(uint8_t *dst, const uint8_t *src,
  3255.                                 ptrdiff_t stride)
  3256. {
  3257.     avc_luma_midh_qrt_4w_msa(src - (2 * stride) - 2, stride, dst, stride, 4, 0);
  3258. }
  3259.  
  3260. void ff_put_h264_qpel4_mc32_msa(uint8_t *dst, const uint8_t *src,
  3261.                                 ptrdiff_t stride)
  3262. {
  3263.     avc_luma_midh_qrt_4w_msa(src - (2 * stride) - 2, stride, dst, stride, 4, 1);
  3264. }
  3265.  
  3266. void ff_put_h264_qpel16_mc22_msa(uint8_t *dst, const uint8_t *src,
  3267.                                  ptrdiff_t stride)
  3268. {
  3269.     avc_luma_mid_16w_msa(src - (2 * stride) - 2, stride, dst, stride, 16);
  3270. }
  3271.  
  3272. void ff_put_h264_qpel8_mc22_msa(uint8_t *dst, const uint8_t *src,
  3273.                                 ptrdiff_t stride)
  3274. {
  3275.     avc_luma_mid_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8);
  3276. }
  3277.  
  3278. void ff_put_h264_qpel4_mc22_msa(uint8_t *dst, const uint8_t *src,
  3279.                                 ptrdiff_t stride)
  3280. {
  3281.     avc_luma_mid_4w_msa(src - (2 * stride) - 2, stride, dst, stride, 4);
  3282. }
  3283.  
  3284. void ff_avg_h264_qpel16_mc10_msa(uint8_t *dst, const uint8_t *src,
  3285.                                  ptrdiff_t stride)
  3286. {
  3287.     avc_luma_hz_qrt_and_aver_dst_16x16_msa(src - 2, stride, dst, stride, 0);
  3288. }
  3289.  
  3290. void ff_avg_h264_qpel16_mc30_msa(uint8_t *dst, const uint8_t *src,
  3291.                                  ptrdiff_t stride)
  3292. {
  3293.     avc_luma_hz_qrt_and_aver_dst_16x16_msa(src - 2, stride, dst, stride, 1);
  3294. }
  3295.  
  3296. void ff_avg_h264_qpel8_mc10_msa(uint8_t *dst, const uint8_t *src,
  3297.                                 ptrdiff_t stride)
  3298. {
  3299.     avc_luma_hz_qrt_and_aver_dst_8x8_msa(src - 2, stride, dst, stride, 0);
  3300. }
  3301.  
  3302. void ff_avg_h264_qpel8_mc30_msa(uint8_t *dst, const uint8_t *src,
  3303.                                 ptrdiff_t stride)
  3304. {
  3305.     avc_luma_hz_qrt_and_aver_dst_8x8_msa(src - 2, stride, dst, stride, 1);
  3306. }
  3307.  
  3308. void ff_avg_h264_qpel4_mc10_msa(uint8_t *dst, const uint8_t *src,
  3309.                                 ptrdiff_t stride)
  3310. {
  3311.     avc_luma_hz_qrt_and_aver_dst_4x4_msa(src - 2, stride, dst, stride, 0);
  3312. }
  3313.  
  3314. void ff_avg_h264_qpel4_mc30_msa(uint8_t *dst, const uint8_t *src,
  3315.                                 ptrdiff_t stride)
  3316. {
  3317.     avc_luma_hz_qrt_and_aver_dst_4x4_msa(src - 2, stride, dst, stride, 1);
  3318. }
  3319.  
  3320. void ff_avg_h264_qpel16_mc20_msa(uint8_t *dst, const uint8_t *src,
  3321.                                  ptrdiff_t stride)
  3322. {
  3323.     avc_luma_hz_and_aver_dst_16x16_msa(src - 2, stride, dst, stride);
  3324. }
  3325.  
  3326. void ff_avg_h264_qpel8_mc20_msa(uint8_t *dst, const uint8_t *src,
  3327.                                 ptrdiff_t stride)
  3328. {
  3329.     avc_luma_hz_and_aver_dst_8x8_msa(src - 2, stride, dst, stride);
  3330. }
  3331.  
  3332. void ff_avg_h264_qpel4_mc20_msa(uint8_t *dst, const uint8_t *src,
  3333.                                 ptrdiff_t stride)
  3334. {
  3335.     avc_luma_hz_and_aver_dst_4x4_msa(src - 2, stride, dst, stride);
  3336. }
  3337.  
  3338. void ff_avg_h264_qpel16_mc01_msa(uint8_t *dst, const uint8_t *src,
  3339.                                  ptrdiff_t stride)
  3340. {
  3341.     avc_luma_vt_qrt_and_aver_dst_16x16_msa(src - (stride * 2),
  3342.                                            stride, dst, stride, 0);
  3343. }
  3344.  
  3345. void ff_avg_h264_qpel16_mc03_msa(uint8_t *dst, const uint8_t *src,
  3346.                                  ptrdiff_t stride)
  3347. {
  3348.     avc_luma_vt_qrt_and_aver_dst_16x16_msa(src - (stride * 2),
  3349.                                            stride, dst, stride, 1);
  3350. }
  3351.  
  3352. void ff_avg_h264_qpel8_mc01_msa(uint8_t *dst, const uint8_t *src,
  3353.                                 ptrdiff_t stride)
  3354. {
  3355.     avc_luma_vt_qrt_and_aver_dst_8x8_msa(src - (stride * 2),
  3356.                                          stride, dst, stride, 0);
  3357. }
  3358.  
  3359. void ff_avg_h264_qpel8_mc03_msa(uint8_t *dst, const uint8_t *src,
  3360.                                 ptrdiff_t stride)
  3361. {
  3362.     avc_luma_vt_qrt_and_aver_dst_8x8_msa(src - (stride * 2),
  3363.                                          stride, dst, stride, 1);
  3364. }
  3365.  
  3366. void ff_avg_h264_qpel4_mc01_msa(uint8_t *dst, const uint8_t *src,
  3367.                                 ptrdiff_t stride)
  3368. {
  3369.     avc_luma_vt_qrt_and_aver_dst_4x4_msa(src - (stride * 2),
  3370.                                          stride, dst, stride, 0);
  3371. }
  3372.  
  3373. void ff_avg_h264_qpel4_mc03_msa(uint8_t *dst, const uint8_t *src,
  3374.                                 ptrdiff_t stride)
  3375. {
  3376.     avc_luma_vt_qrt_and_aver_dst_4x4_msa(src - (stride * 2),
  3377.                                          stride, dst, stride, 1);
  3378. }
  3379.  
  3380. void ff_avg_h264_qpel16_mc11_msa(uint8_t *dst, const uint8_t *src,
  3381.                                  ptrdiff_t stride)
  3382. {
  3383.     avc_luma_hv_qrt_and_aver_dst_16x16_msa(src - 2,
  3384.                                            src - (stride * 2),
  3385.                                            stride, dst, stride);
  3386. }
  3387.  
  3388. void ff_avg_h264_qpel16_mc31_msa(uint8_t *dst, const uint8_t *src,
  3389.                                  ptrdiff_t stride)
  3390. {
  3391.     avc_luma_hv_qrt_and_aver_dst_16x16_msa(src - 2,
  3392.                                            src - (stride * 2) +
  3393.                                            sizeof(uint8_t), stride,
  3394.                                            dst, stride);
  3395. }
  3396.  
  3397. void ff_avg_h264_qpel16_mc13_msa(uint8_t *dst, const uint8_t *src,
  3398.                                  ptrdiff_t stride)
  3399. {
  3400.     avc_luma_hv_qrt_and_aver_dst_16x16_msa(src + stride - 2,
  3401.                                            src - (stride * 2),
  3402.                                            stride, dst, stride);
  3403. }
  3404.  
  3405. void ff_avg_h264_qpel16_mc33_msa(uint8_t *dst, const uint8_t *src,
  3406.                                  ptrdiff_t stride)
  3407. {
  3408.     avc_luma_hv_qrt_and_aver_dst_16x16_msa(src + stride - 2,
  3409.                                            src - (stride * 2) +
  3410.                                            sizeof(uint8_t), stride,
  3411.                                            dst, stride);
  3412. }
  3413.  
  3414. void ff_avg_h264_qpel8_mc11_msa(uint8_t *dst, const uint8_t *src,
  3415.                                 ptrdiff_t stride)
  3416. {
  3417.     avc_luma_hv_qrt_and_aver_dst_8x8_msa(src - 2,
  3418.                                          src - (stride * 2),
  3419.                                          stride, dst, stride);
  3420. }
  3421.  
  3422. void ff_avg_h264_qpel8_mc31_msa(uint8_t *dst, const uint8_t *src,
  3423.                                 ptrdiff_t stride)
  3424. {
  3425.     avc_luma_hv_qrt_and_aver_dst_8x8_msa(src - 2,
  3426.                                          src - (stride * 2) +
  3427.                                          sizeof(uint8_t), stride, dst, stride);
  3428. }
  3429.  
  3430. void ff_avg_h264_qpel8_mc13_msa(uint8_t *dst, const uint8_t *src,
  3431.                                 ptrdiff_t stride)
  3432. {
  3433.     avc_luma_hv_qrt_and_aver_dst_8x8_msa(src + stride - 2,
  3434.                                          src - (stride * 2),
  3435.                                          stride, dst, stride);
  3436. }
  3437.  
  3438. void ff_avg_h264_qpel8_mc33_msa(uint8_t *dst, const uint8_t *src,
  3439.                                 ptrdiff_t stride)
  3440. {
  3441.     avc_luma_hv_qrt_and_aver_dst_8x8_msa(src + stride - 2,
  3442.                                          src - (stride * 2) +
  3443.                                          sizeof(uint8_t), stride, dst, stride);
  3444. }
  3445.  
  3446.  
  3447. void ff_avg_h264_qpel4_mc11_msa(uint8_t *dst, const uint8_t *src,
  3448.                                 ptrdiff_t stride)
  3449. {
  3450.     avc_luma_hv_qrt_and_aver_dst_4x4_msa(src - 2,
  3451.                                          src - (stride * 2),
  3452.                                          stride, dst, stride);
  3453. }
  3454.  
  3455. void ff_avg_h264_qpel4_mc31_msa(uint8_t *dst, const uint8_t *src,
  3456.                                 ptrdiff_t stride)
  3457. {
  3458.     avc_luma_hv_qrt_and_aver_dst_4x4_msa(src - 2,
  3459.                                          src - (stride * 2) +
  3460.                                          sizeof(uint8_t), stride, dst, stride);
  3461. }
  3462.  
  3463. void ff_avg_h264_qpel4_mc13_msa(uint8_t *dst, const uint8_t *src,
  3464.                                 ptrdiff_t stride)
  3465. {
  3466.     avc_luma_hv_qrt_and_aver_dst_4x4_msa(src + stride - 2,
  3467.                                          src - (stride * 2),
  3468.                                          stride, dst, stride);
  3469. }
  3470.  
  3471. void ff_avg_h264_qpel4_mc33_msa(uint8_t *dst, const uint8_t *src,
  3472.                                 ptrdiff_t stride)
  3473. {
  3474.     avc_luma_hv_qrt_and_aver_dst_4x4_msa(src + stride - 2,
  3475.                                          src - (stride * 2) +
  3476.                                          sizeof(uint8_t), stride, dst, stride);
  3477. }
  3478.  
  3479. void ff_avg_h264_qpel16_mc21_msa(uint8_t *dst, const uint8_t *src,
  3480.                                  ptrdiff_t stride)
  3481. {
  3482.     avc_luma_midv_qrt_and_aver_dst_16w_msa(src - (2 * stride) - 2,
  3483.                                            stride, dst, stride, 16, 0);
  3484. }
  3485.  
  3486. void ff_avg_h264_qpel16_mc23_msa(uint8_t *dst, const uint8_t *src,
  3487.                                  ptrdiff_t stride)
  3488. {
  3489.     avc_luma_midv_qrt_and_aver_dst_16w_msa(src - (2 * stride) - 2,
  3490.                                            stride, dst, stride, 16, 1);
  3491. }
  3492.  
  3493. void ff_avg_h264_qpel8_mc21_msa(uint8_t *dst, const uint8_t *src,
  3494.                                 ptrdiff_t stride)
  3495. {
  3496.     avc_luma_midv_qrt_and_aver_dst_8w_msa(src - (2 * stride) - 2,
  3497.                                           stride, dst, stride, 8, 0);
  3498. }
  3499.  
  3500. void ff_avg_h264_qpel8_mc23_msa(uint8_t *dst, const uint8_t *src,
  3501.                                 ptrdiff_t stride)
  3502. {
  3503.     avc_luma_midv_qrt_and_aver_dst_8w_msa(src - (2 * stride) - 2,
  3504.                                           stride, dst, stride, 8, 1);
  3505. }
  3506.  
  3507. void ff_avg_h264_qpel4_mc21_msa(uint8_t *dst, const uint8_t *src,
  3508.                                 ptrdiff_t stride)
  3509. {
  3510.     avc_luma_midv_qrt_and_aver_dst_4w_msa(src - (2 * stride) - 2,
  3511.                                           stride, dst, stride, 4, 0);
  3512. }
  3513.  
  3514. void ff_avg_h264_qpel4_mc23_msa(uint8_t *dst, const uint8_t *src,
  3515.                                 ptrdiff_t stride)
  3516. {
  3517.     avc_luma_midv_qrt_and_aver_dst_4w_msa(src - (2 * stride) - 2,
  3518.                                           stride, dst, stride, 4, 1);
  3519. }
  3520.  
  3521. void ff_avg_h264_qpel16_mc02_msa(uint8_t *dst, const uint8_t *src,
  3522.                                  ptrdiff_t stride)
  3523. {
  3524.     avc_luma_vt_and_aver_dst_16x16_msa(src - (stride * 2), stride, dst, stride);
  3525. }
  3526.  
  3527. void ff_avg_h264_qpel8_mc02_msa(uint8_t *dst, const uint8_t *src,
  3528.                                 ptrdiff_t stride)
  3529. {
  3530.     avc_luma_vt_and_aver_dst_8x8_msa(src - (stride * 2), stride, dst, stride);
  3531. }
  3532.  
  3533. void ff_avg_h264_qpel4_mc02_msa(uint8_t *dst, const uint8_t *src,
  3534.                                 ptrdiff_t stride)
  3535. {
  3536.     avc_luma_vt_and_aver_dst_4x4_msa(src - (stride * 2), stride, dst, stride);
  3537. }
  3538.  
  3539. void ff_avg_h264_qpel16_mc12_msa(uint8_t *dst, const uint8_t *src,
  3540.                                  ptrdiff_t stride)
  3541. {
  3542.     avc_luma_midh_qrt_and_aver_dst_16w_msa(src - (2 * stride) - 2,
  3543.                                            stride, dst, stride, 16, 0);
  3544. }
  3545.  
  3546. void ff_avg_h264_qpel16_mc32_msa(uint8_t *dst, const uint8_t *src,
  3547.                                  ptrdiff_t stride)
  3548. {
  3549.     avc_luma_midh_qrt_and_aver_dst_16w_msa(src - (2 * stride) - 2,
  3550.                                            stride, dst, stride, 16, 1);
  3551. }
  3552.  
  3553. void ff_avg_h264_qpel8_mc12_msa(uint8_t *dst, const uint8_t *src,
  3554.                                 ptrdiff_t stride)
  3555. {
  3556.     avc_luma_midh_qrt_and_aver_dst_8w_msa(src - (2 * stride) - 2,
  3557.                                           stride, dst, stride, 8, 0);
  3558. }
  3559.  
  3560. void ff_avg_h264_qpel8_mc32_msa(uint8_t *dst, const uint8_t *src,
  3561.                                 ptrdiff_t stride)
  3562. {
  3563.     avc_luma_midh_qrt_and_aver_dst_8w_msa(src - (2 * stride) - 2,
  3564.                                           stride, dst, stride, 8, 1);
  3565. }
  3566.  
  3567. void ff_avg_h264_qpel4_mc12_msa(uint8_t *dst, const uint8_t *src,
  3568.                                 ptrdiff_t stride)
  3569. {
  3570.     avc_luma_midh_qrt_and_aver_dst_4w_msa(src - (2 * stride) - 2,
  3571.                                           stride, dst, stride, 4, 0);
  3572. }
  3573.  
  3574. void ff_avg_h264_qpel4_mc32_msa(uint8_t *dst, const uint8_t *src,
  3575.                                 ptrdiff_t stride)
  3576. {
  3577.     avc_luma_midh_qrt_and_aver_dst_4w_msa(src - (2 * stride) - 2,
  3578.                                           stride, dst, stride, 4, 1);
  3579. }
  3580.  
  3581. void ff_avg_h264_qpel16_mc22_msa(uint8_t *dst, const uint8_t *src,
  3582.                                  ptrdiff_t stride)
  3583. {
  3584.     avc_luma_mid_and_aver_dst_16x16_msa(src - (2 * stride) - 2,
  3585.                                         stride, dst, stride);
  3586. }
  3587.  
  3588. void ff_avg_h264_qpel8_mc22_msa(uint8_t *dst, const uint8_t *src,
  3589.                                 ptrdiff_t stride)
  3590. {
  3591.     avc_luma_mid_and_aver_dst_8w_msa(src - (2 * stride) - 2,
  3592.                                      stride, dst, stride, 8);
  3593. }
  3594.  
  3595. void ff_avg_h264_qpel4_mc22_msa(uint8_t *dst, const uint8_t *src,
  3596.                                 ptrdiff_t stride)
  3597. {
  3598.     avc_luma_mid_and_aver_dst_4x4_msa(src - (2 * stride) - 2,
  3599.                                       stride, dst, stride);
  3600. }
  3601.