Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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