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 "h264dsp_mips.h"
  23.  
  24. static void intra_predict_vert_8x8_msa(uint8_t *src, uint8_t *dst,
  25.                                        int32_t dst_stride)
  26. {
  27.     uint32_t row;
  28.     uint32_t src_data1, src_data2;
  29.  
  30.     src_data1 = LW(src);
  31.     src_data2 = LW(src + 4);
  32.  
  33.     for (row = 8; row--;) {
  34.         SW(src_data1, dst);
  35.         SW(src_data2, (dst + 4));
  36.         dst += dst_stride;
  37.     }
  38. }
  39.  
  40. static void intra_predict_vert_16x16_msa(uint8_t *src, uint8_t *dst,
  41.                                          int32_t dst_stride)
  42. {
  43.     uint32_t row;
  44.     v16u8 src0;
  45.  
  46.     src0 = LD_UB(src);
  47.  
  48.     for (row = 16; row--;) {
  49.         ST_UB(src0, dst);
  50.         dst += dst_stride;
  51.     }
  52. }
  53.  
  54. static void intra_predict_horiz_8x8_msa(uint8_t *src, int32_t src_stride,
  55.                                         uint8_t *dst, int32_t dst_stride)
  56. {
  57.     uint64_t out0, out1, out2, out3, out4, out5, out6, out7;
  58.  
  59.     out0 = src[0 * src_stride] * 0x0101010101010101;
  60.     out1 = src[1 * src_stride] * 0x0101010101010101;
  61.     out2 = src[2 * src_stride] * 0x0101010101010101;
  62.     out3 = src[3 * src_stride] * 0x0101010101010101;
  63.     out4 = src[4 * src_stride] * 0x0101010101010101;
  64.     out5 = src[5 * src_stride] * 0x0101010101010101;
  65.     out6 = src[6 * src_stride] * 0x0101010101010101;
  66.     out7 = src[7 * src_stride] * 0x0101010101010101;
  67.  
  68.     SD4(out0, out1, out2, out3, dst, dst_stride);
  69.     dst += (4 * dst_stride);
  70.     SD4(out4, out5, out6, out7, dst, dst_stride);
  71. }
  72.  
  73. static void intra_predict_horiz_16x16_msa(uint8_t *src, int32_t src_stride,
  74.                                           uint8_t *dst, int32_t dst_stride)
  75. {
  76.     uint32_t row;
  77.     uint8_t inp0, inp1, inp2, inp3;
  78.     v16u8 src0, src1, src2, src3;
  79.  
  80.     for (row = 4; row--;) {
  81.         inp0 = src[0];
  82.         src += src_stride;
  83.         inp1 = src[0];
  84.         src += src_stride;
  85.         inp2 = src[0];
  86.         src += src_stride;
  87.         inp3 = src[0];
  88.         src += src_stride;
  89.  
  90.         src0 = (v16u8) __msa_fill_b(inp0);
  91.         src1 = (v16u8) __msa_fill_b(inp1);
  92.         src2 = (v16u8) __msa_fill_b(inp2);
  93.         src3 = (v16u8) __msa_fill_b(inp3);
  94.  
  95.         ST_UB4(src0, src1, src2, src3, dst, dst_stride);
  96.         dst += (4 * dst_stride);
  97.     }
  98. }
  99.  
  100. static void intra_predict_dc_8x8_msa(uint8_t *src_top, uint8_t *src_left,
  101.                                      int32_t src_stride_left,
  102.                                      uint8_t *dst, int32_t dst_stride,
  103.                                      uint8_t is_above, uint8_t is_left)
  104. {
  105.     uint32_t row;
  106.     uint32_t out, addition = 0;
  107.     v16u8 src_above, store;
  108.     v8u16 sum_above;
  109.     v4u32 sum_top;
  110.     v2u64 sum;
  111.  
  112.     if (is_left && is_above) {
  113.         src_above = LD_UB(src_top);
  114.  
  115.         sum_above = __msa_hadd_u_h(src_above, src_above);
  116.         sum_top = __msa_hadd_u_w(sum_above, sum_above);
  117.         sum = __msa_hadd_u_d(sum_top, sum_top);
  118.         addition = __msa_copy_u_w((v4i32) sum, 0);
  119.  
  120.         for (row = 0; row < 8; row++) {
  121.             addition += src_left[row * src_stride_left];
  122.         }
  123.  
  124.         addition = (addition + 8) >> 4;
  125.         store = (v16u8) __msa_fill_b(addition);
  126.     } else if (is_left) {
  127.         for (row = 0; row < 8; row++) {
  128.             addition += src_left[row * src_stride_left];
  129.         }
  130.  
  131.         addition = (addition + 4) >> 3;
  132.         store = (v16u8) __msa_fill_b(addition);
  133.     } else if (is_above) {
  134.         src_above = LD_UB(src_top);
  135.  
  136.         sum_above = __msa_hadd_u_h(src_above, src_above);
  137.         sum_top = __msa_hadd_u_w(sum_above, sum_above);
  138.         sum = __msa_hadd_u_d(sum_top, sum_top);
  139.         sum = (v2u64) __msa_srari_d((v2i64) sum, 3);
  140.         store = (v16u8) __msa_splati_b((v16i8) sum, 0);
  141.     } else {
  142.         store = (v16u8) __msa_ldi_b(128);
  143.     }
  144.  
  145.     out = __msa_copy_u_w((v4i32) store, 0);
  146.  
  147.     for (row = 8; row--;) {
  148.         SW(out, dst);
  149.         SW(out, (dst + 4));
  150.         dst += dst_stride;
  151.     }
  152. }
  153.  
  154. static void intra_predict_dc_16x16_msa(uint8_t *src_top, uint8_t *src_left,
  155.                                        int32_t src_stride_left,
  156.                                        uint8_t *dst, int32_t dst_stride,
  157.                                        uint8_t is_above, uint8_t is_left)
  158. {
  159.     uint32_t row;
  160.     uint32_t addition = 0;
  161.     v16u8 src_above, store;
  162.     v8u16 sum_above;
  163.     v4u32 sum_top;
  164.     v2u64 sum;
  165.  
  166.     if (is_left && is_above) {
  167.         src_above = LD_UB(src_top);
  168.  
  169.         sum_above = __msa_hadd_u_h(src_above, src_above);
  170.         sum_top = __msa_hadd_u_w(sum_above, sum_above);
  171.         sum = __msa_hadd_u_d(sum_top, sum_top);
  172.         sum_top = (v4u32) __msa_pckev_w((v4i32) sum, (v4i32) sum);
  173.         sum = __msa_hadd_u_d(sum_top, sum_top);
  174.         addition = __msa_copy_u_w((v4i32) sum, 0);
  175.  
  176.         for (row = 0; row < 16; row++) {
  177.             addition += src_left[row * src_stride_left];
  178.         }
  179.  
  180.         addition = (addition + 16) >> 5;
  181.         store = (v16u8) __msa_fill_b(addition);
  182.     } else if (is_left) {
  183.         for (row = 0; row < 16; row++) {
  184.             addition += src_left[row * src_stride_left];
  185.         }
  186.  
  187.         addition = (addition + 8) >> 4;
  188.         store = (v16u8) __msa_fill_b(addition);
  189.     } else if (is_above) {
  190.         src_above = LD_UB(src_top);
  191.  
  192.         sum_above = __msa_hadd_u_h(src_above, src_above);
  193.         sum_top = __msa_hadd_u_w(sum_above, sum_above);
  194.         sum = __msa_hadd_u_d(sum_top, sum_top);
  195.         sum_top = (v4u32) __msa_pckev_w((v4i32) sum, (v4i32) sum);
  196.         sum = __msa_hadd_u_d(sum_top, sum_top);
  197.         sum = (v2u64) __msa_srari_d((v2i64) sum, 4);
  198.         store = (v16u8) __msa_splati_b((v16i8) sum, 0);
  199.     } else {
  200.         store = (v16u8) __msa_ldi_b(128);
  201.     }
  202.  
  203.     for (row = 16; row--;) {
  204.         ST_UB(store, dst);
  205.         dst += dst_stride;
  206.     }
  207. }
  208.  
  209. #define INTRA_PREDICT_VALDC_8X8_MSA(val)                         \
  210. static void intra_predict_##val##dc_8x8_msa(uint8_t *dst,        \
  211.                                             int32_t dst_stride)  \
  212. {                                                                \
  213.     uint32_t row, out;                                           \
  214.     v16i8 store;                                                 \
  215.                                                                  \
  216.     store = __msa_ldi_b(val);                                    \
  217.     out = __msa_copy_u_w((v4i32) store, 0);                      \
  218.                                                                  \
  219.     for (row = 8; row--;) {                                      \
  220.         SW(out, dst);                                            \
  221.         SW(out, (dst + 4));                                      \
  222.         dst += dst_stride;                                       \
  223.     }                                                            \
  224. }
  225.  
  226. INTRA_PREDICT_VALDC_8X8_MSA(127);
  227. INTRA_PREDICT_VALDC_8X8_MSA(129);
  228.  
  229. #define INTRA_PREDICT_VALDC_16X16_MSA(val)                         \
  230. static void intra_predict_##val##dc_16x16_msa(uint8_t *dst,        \
  231.                                               int32_t dst_stride)  \
  232. {                                                                  \
  233.     uint32_t row;                                                  \
  234.     v16u8 store;                                                   \
  235.                                                                    \
  236.     store = (v16u8) __msa_ldi_b(val);                              \
  237.                                                                    \
  238.     for (row = 16; row--;) {                                       \
  239.         ST_UB(store, dst);                                         \
  240.         dst += dst_stride;                                         \
  241.     }                                                              \
  242. }
  243.  
  244. INTRA_PREDICT_VALDC_16X16_MSA(127);
  245. INTRA_PREDICT_VALDC_16X16_MSA(129);
  246.  
  247. static void intra_predict_plane_8x8_msa(uint8_t *src, int32_t stride)
  248. {
  249.     uint8_t lpcnt;
  250.     int32_t res, res0, res1, res2, res3;
  251.     uint64_t out0, out1;
  252.     v16i8 shf_mask = { 3, 5, 2, 6, 1, 7, 0, 8, 3, 5, 2, 6, 1, 7, 0, 8 };
  253.     v8i16 short_multiplier = { 1, 2, 3, 4, 1, 2, 3, 4 };
  254.     v4i32 int_multiplier = { 0, 1, 2, 3 };
  255.     v16u8 src_top;
  256.     v8i16 vec9, vec10, vec11;
  257.     v4i32 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8;
  258.     v2i64 sum;
  259.  
  260.     src_top = LD_UB(src - (stride + 1));
  261.     src_top = (v16u8) __msa_vshf_b(shf_mask, (v16i8) src_top, (v16i8) src_top);
  262.  
  263.     vec9 = __msa_hsub_u_h(src_top, src_top);
  264.     vec9 *= short_multiplier;
  265.     vec8 = __msa_hadd_s_w(vec9, vec9);
  266.     sum = __msa_hadd_s_d(vec8, vec8);
  267.  
  268.     res0 = __msa_copy_s_w((v4i32) sum, 0);
  269.  
  270.     res1 = (src[4 * stride - 1] - src[2 * stride - 1]) +
  271.         2 * (src[5 * stride - 1] - src[stride - 1]) +
  272.         3 * (src[6 * stride - 1] - src[-1]) +
  273.         4 * (src[7 * stride - 1] - src[-stride - 1]);
  274.  
  275.     res0 *= 17;
  276.     res1 *= 17;
  277.     res0 = (res0 + 16) >> 5;
  278.     res1 = (res1 + 16) >> 5;
  279.  
  280.     res3 = 3 * (res0 + res1);
  281.     res2 = 16 * (src[7 * stride - 1] + src[-stride + 7] + 1);
  282.     res = res2 - res3;
  283.  
  284.     vec8 = __msa_fill_w(res0);
  285.     vec4 = __msa_fill_w(res);
  286.     vec2 = __msa_fill_w(res1);
  287.     vec5 = vec8 * int_multiplier;
  288.     vec3 = vec8 * 4;
  289.  
  290.     for (lpcnt = 4; lpcnt--;) {
  291.         vec0 = vec5;
  292.         vec0 += vec4;
  293.         vec1 = vec0 + vec3;
  294.         vec6 = vec5;
  295.         vec4 += vec2;
  296.         vec6 += vec4;
  297.         vec7 = vec6 + vec3;
  298.  
  299.         SRA_4V(vec0, vec1, vec6, vec7, 5);
  300.         PCKEV_H2_SH(vec1, vec0, vec7, vec6, vec10, vec11);
  301.         CLIP_SH2_0_255(vec10, vec11);
  302.         PCKEV_B2_SH(vec10, vec10, vec11, vec11, vec10, vec11);
  303.  
  304.         out0 = __msa_copy_s_d((v2i64) vec10, 0);
  305.         out1 = __msa_copy_s_d((v2i64) vec11, 0);
  306.         SD(out0, src);
  307.         src += stride;
  308.         SD(out1, src);
  309.         src += stride;
  310.  
  311.         vec4 += vec2;
  312.     }
  313. }
  314.  
  315. static void intra_predict_plane_16x16_msa(uint8_t *src, int32_t stride)
  316. {
  317.     uint8_t lpcnt;
  318.     int32_t res0, res1, res2, res3;
  319.     uint64_t load0, load1;
  320.     v16i8 shf_mask = { 7, 8, 6, 9, 5, 10, 4, 11, 3, 12, 2, 13, 1, 14, 0, 15 };
  321.     v8i16 short_multiplier = { 1, 2, 3, 4, 5, 6, 7, 8 };
  322.     v4i32 int_multiplier = { 0, 1, 2, 3 };
  323.     v16u8 src_top = { 0 };
  324.     v8i16 vec9, vec10;
  325.     v4i32 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, res_add;
  326.  
  327.     load0 = LD(src - (stride + 1));
  328.     load1 = LD(src - (stride + 1) + 9);
  329.  
  330.     INSERT_D2_UB(load0, load1, src_top);
  331.  
  332.     src_top = (v16u8) __msa_vshf_b(shf_mask, (v16i8) src_top, (v16i8) src_top);
  333.  
  334.     vec9 = __msa_hsub_u_h(src_top, src_top);
  335.     vec9 *= short_multiplier;
  336.     vec8 = __msa_hadd_s_w(vec9, vec9);
  337.     res_add = (v4i32) __msa_hadd_s_d(vec8, vec8);
  338.  
  339.     res0 = __msa_copy_s_w(res_add, 0) + __msa_copy_s_w(res_add, 2);
  340.  
  341.     res1 = (src[8 * stride - 1] - src[6 * stride - 1]) +
  342.         2 * (src[9 * stride - 1] - src[5 * stride - 1]) +
  343.         3 * (src[10 * stride - 1] - src[4 * stride - 1]) +
  344.         4 * (src[11 * stride - 1] - src[3 * stride - 1]) +
  345.         5 * (src[12 * stride - 1] - src[2 * stride - 1]) +
  346.         6 * (src[13 * stride - 1] - src[stride - 1]) +
  347.         7 * (src[14 * stride - 1] - src[-1]) +
  348.         8 * (src[15 * stride - 1] - src[-1 * stride - 1]);
  349.  
  350.     res0 *= 5;
  351.     res1 *= 5;
  352.     res0 = (res0 + 32) >> 6;
  353.     res1 = (res1 + 32) >> 6;
  354.  
  355.     res3 = 7 * (res0 + res1);
  356.     res2 = 16 * (src[15 * stride - 1] + src[-stride + 15] + 1);
  357.     res2 -= res3;
  358.  
  359.     vec8 = __msa_fill_w(res0);
  360.     vec4 = __msa_fill_w(res2);
  361.     vec5 = __msa_fill_w(res1);
  362.     vec6 = vec8 * 4;
  363.     vec7 = vec8 * int_multiplier;
  364.  
  365.     for (lpcnt = 16; lpcnt--;) {
  366.         vec0 = vec7;
  367.         vec0 += vec4;
  368.         vec1 = vec0 + vec6;
  369.         vec2 = vec1 + vec6;
  370.         vec3 = vec2 + vec6;
  371.  
  372.         SRA_4V(vec0, vec1, vec2, vec3, 5);
  373.         PCKEV_H2_SH(vec1, vec0, vec3, vec2, vec9, vec10);
  374.         CLIP_SH2_0_255(vec9, vec10);
  375.         PCKEV_ST_SB(vec9, vec10, src);
  376.         src += stride;
  377.  
  378.         vec4 += vec5;
  379.     }
  380. }
  381.  
  382. static void intra_predict_dc_4blk_8x8_msa(uint8_t *src, int32_t stride)
  383. {
  384.     uint8_t lp_cnt;
  385.     uint32_t src0, src1, src3, src2 = 0;
  386.     uint32_t out0, out1, out2, out3;
  387.     v16u8 src_top;
  388.     v8u16 add;
  389.     v4u32 sum;
  390.  
  391.     src_top = LD_UB(src - stride);
  392.     add = __msa_hadd_u_h((v16u8) src_top, (v16u8) src_top);
  393.     sum = __msa_hadd_u_w(add, add);
  394.     src0 = __msa_copy_u_w((v4i32) sum, 0);
  395.     src1 = __msa_copy_u_w((v4i32) sum, 1);
  396.  
  397.     for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
  398.         src0 += src[lp_cnt * stride - 1];
  399.         src2 += src[(4 + lp_cnt) * stride - 1];
  400.     }
  401.  
  402.     src0 = (src0 + 4) >> 3;
  403.     src3 = (src1 + src2 + 4) >> 3;
  404.     src1 = (src1 + 2) >> 2;
  405.     src2 = (src2 + 2) >> 2;
  406.     out0 = src0 * 0x01010101;
  407.     out1 = src1 * 0x01010101;
  408.     out2 = src2 * 0x01010101;
  409.     out3 = src3 * 0x01010101;
  410.  
  411.     for (lp_cnt = 4; lp_cnt--;) {
  412.         SW(out0, src);
  413.         SW(out1, (src + 4));
  414.         SW(out2, (src + 4 * stride));
  415.         SW(out3, (src + 4 * stride + 4));
  416.         src += stride;
  417.     }
  418. }
  419.  
  420. static void intra_predict_hor_dc_8x8_msa(uint8_t *src, int32_t stride)
  421. {
  422.     uint8_t lp_cnt;
  423.     uint32_t src0 = 0, src1 = 0;
  424.     uint64_t out0, out1;
  425.  
  426.     for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
  427.         src0 += src[lp_cnt * stride - 1];
  428.         src1 += src[(4 + lp_cnt) * stride - 1];
  429.     }
  430.  
  431.     src0 = (src0 + 2) >> 2;
  432.     src1 = (src1 + 2) >> 2;
  433.     out0 = src0 * 0x0101010101010101;
  434.     out1 = src1 * 0x0101010101010101;
  435.  
  436.     for (lp_cnt = 4; lp_cnt--;) {
  437.         SD(out0, src);
  438.         SD(out1, (src + 4 * stride));
  439.         src += stride;
  440.     }
  441. }
  442.  
  443. static void intra_predict_vert_dc_8x8_msa(uint8_t *src, int32_t stride)
  444. {
  445.     uint8_t lp_cnt;
  446.     uint32_t out0 = 0, out1 = 0;
  447.     v16u8 src_top;
  448.     v8u16 add;
  449.     v4u32 sum;
  450.     v4i32 res0, res1;
  451.  
  452.     src_top = LD_UB(src - stride);
  453.     add = __msa_hadd_u_h(src_top, src_top);
  454.     sum = __msa_hadd_u_w(add, add);
  455.     sum = (v4u32) __msa_srari_w((v4i32) sum, 2);
  456.     res0 = (v4i32) __msa_splati_b((v16i8) sum, 0);
  457.     res1 = (v4i32) __msa_splati_b((v16i8) sum, 4);
  458.     out0 = __msa_copy_u_w(res0, 0);
  459.     out1 = __msa_copy_u_w(res1, 0);
  460.  
  461.     for (lp_cnt = 8; lp_cnt--;) {
  462.         SW(out0, src);
  463.         SW(out1, src + 4);
  464.         src += stride;
  465.     }
  466. }
  467.  
  468. static void intra_predict_mad_cow_dc_l0t_8x8_msa(uint8_t *src, int32_t stride)
  469. {
  470.     uint8_t lp_cnt;
  471.     uint32_t src0, src1, src2 = 0;
  472.     uint32_t out0, out1, out2;
  473.     v16u8 src_top;
  474.     v8u16 add;
  475.     v4u32 sum;
  476.  
  477.     src_top = LD_UB(src - stride);
  478.     add = __msa_hadd_u_h(src_top, src_top);
  479.     sum = __msa_hadd_u_w(add, add);
  480.     src0 = __msa_copy_u_w((v4i32) sum, 0);
  481.     src1 = __msa_copy_u_w((v4i32) sum, 1);
  482.  
  483.     for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
  484.         src2 += src[lp_cnt * stride - 1];
  485.     }
  486.     src2 = (src0 + src2 + 4) >> 3;
  487.     src0 = (src0 + 2) >> 2;
  488.     src1 = (src1 + 2) >> 2;
  489.     out0 = src0 * 0x01010101;
  490.     out1 = src1 * 0x01010101;
  491.     out2 = src2 * 0x01010101;
  492.  
  493.     for (lp_cnt = 4; lp_cnt--;) {
  494.         SW(out2, src);
  495.         SW(out1, src + 4);
  496.         SW(out0, src + stride * 4);
  497.         SW(out1, src + stride * 4 + 4);
  498.         src += stride;
  499.     }
  500. }
  501.  
  502. static void intra_predict_mad_cow_dc_0lt_8x8_msa(uint8_t *src, int32_t stride)
  503. {
  504.     uint8_t lp_cnt;
  505.     uint32_t src0, src1, src2 = 0, src3;
  506.     uint32_t out0, out1, out2, out3;
  507.     v16u8 src_top;
  508.     v8u16 add;
  509.     v4u32 sum;
  510.  
  511.     src_top = LD_UB(src - stride);
  512.     add = __msa_hadd_u_h(src_top, src_top);
  513.     sum = __msa_hadd_u_w(add, add);
  514.     src0 = __msa_copy_u_w((v4i32) sum, 0);
  515.     src1 = __msa_copy_u_w((v4i32) sum, 1);
  516.  
  517.     for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
  518.         src2 += src[(4 + lp_cnt) * stride - 1];
  519.     }
  520.  
  521.     src0 = (src0 + 2) >> 2;
  522.     src3 = (src1 + src2 + 4) >> 3;
  523.     src1 = (src1 + 2) >> 2;
  524.     src2 = (src2 + 2) >> 2;
  525.  
  526.     out0 = src0 * 0x01010101;
  527.     out1 = src1 * 0x01010101;
  528.     out2 = src2 * 0x01010101;
  529.     out3 = src3 * 0x01010101;
  530.  
  531.     for (lp_cnt = 4; lp_cnt--;) {
  532.         SW(out0, src);
  533.         SW(out1, src + 4);
  534.         SW(out2, src + stride * 4);
  535.         SW(out3, src + stride * 4 + 4);
  536.         src += stride;
  537.     }
  538. }
  539.  
  540. static void intra_predict_mad_cow_dc_l00_8x8_msa(uint8_t *src, int32_t stride)
  541. {
  542.     uint8_t lp_cnt;
  543.     uint32_t src0 = 0;
  544.     uint64_t out0, out1;
  545.  
  546.     for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
  547.         src0 += src[lp_cnt * stride - 1];
  548.     }
  549.  
  550.     src0 = (src0 + 2) >> 2;
  551.     out0 = src0 * 0x0101010101010101;
  552.     out1 = 0x8080808080808080;
  553.  
  554.     for (lp_cnt = 4; lp_cnt--;) {
  555.         SD(out0, src);
  556.         SD(out1, src + stride * 4);
  557.         src += stride;
  558.     }
  559. }
  560.  
  561. static void intra_predict_mad_cow_dc_0l0_8x8_msa(uint8_t *src, int32_t stride)
  562. {
  563.     uint8_t lp_cnt;
  564.     uint32_t src0 = 0;
  565.     uint64_t out0, out1;
  566.  
  567.     for (lp_cnt = 0; lp_cnt < 4; lp_cnt++) {
  568.         src0 += src[(4 + lp_cnt) * stride - 1];
  569.     }
  570.  
  571.     src0 = (src0 + 2) >> 2;
  572.  
  573.     out0 = 0x8080808080808080;
  574.     out1 = src0 * 0x0101010101010101;
  575.  
  576.     for (lp_cnt = 4; lp_cnt--;) {
  577.         SD(out0, src);
  578.         SD(out1, src + stride * 4);
  579.         src += stride;
  580.     }
  581. }
  582.  
  583. void ff_h264_intra_predict_plane_8x8_msa(uint8_t *src, ptrdiff_t stride)
  584. {
  585.     intra_predict_plane_8x8_msa(src, stride);
  586. }
  587.  
  588. void ff_h264_intra_predict_dc_4blk_8x8_msa(uint8_t *src, ptrdiff_t stride)
  589. {
  590.     intra_predict_dc_4blk_8x8_msa(src, stride);
  591. }
  592.  
  593. void ff_h264_intra_predict_hor_dc_8x8_msa(uint8_t *src, ptrdiff_t stride)
  594. {
  595.     intra_predict_hor_dc_8x8_msa(src, stride);
  596. }
  597.  
  598. void ff_h264_intra_predict_vert_dc_8x8_msa(uint8_t *src, ptrdiff_t stride)
  599. {
  600.     intra_predict_vert_dc_8x8_msa(src, stride);
  601. }
  602.  
  603. void ff_h264_intra_predict_mad_cow_dc_l0t_8x8_msa(uint8_t *src,
  604.                                                   ptrdiff_t stride)
  605. {
  606.     intra_predict_mad_cow_dc_l0t_8x8_msa(src, stride);
  607. }
  608.  
  609. void ff_h264_intra_predict_mad_cow_dc_0lt_8x8_msa(uint8_t *src,
  610.                                                   ptrdiff_t stride)
  611. {
  612.     intra_predict_mad_cow_dc_0lt_8x8_msa(src, stride);
  613. }
  614.  
  615. void ff_h264_intra_predict_mad_cow_dc_l00_8x8_msa(uint8_t *src,
  616.                                                   ptrdiff_t stride)
  617. {
  618.     intra_predict_mad_cow_dc_l00_8x8_msa(src, stride);
  619. }
  620.  
  621. void ff_h264_intra_predict_mad_cow_dc_0l0_8x8_msa(uint8_t *src,
  622.                                                   ptrdiff_t stride)
  623. {
  624.     intra_predict_mad_cow_dc_0l0_8x8_msa(src, stride);
  625. }
  626.  
  627. void ff_h264_intra_predict_plane_16x16_msa(uint8_t *src, ptrdiff_t stride)
  628. {
  629.     intra_predict_plane_16x16_msa(src, stride);
  630. }
  631.  
  632. void ff_h264_intra_pred_vert_8x8_msa(uint8_t *src, ptrdiff_t stride)
  633. {
  634.     uint8_t *dst = src;
  635.  
  636.     intra_predict_vert_8x8_msa(src - stride, dst, stride);
  637. }
  638.  
  639. void ff_h264_intra_pred_horiz_8x8_msa(uint8_t *src, ptrdiff_t stride)
  640. {
  641.     uint8_t *dst = src;
  642.  
  643.     intra_predict_horiz_8x8_msa(src - 1, stride, dst, stride);
  644. }
  645.  
  646. void ff_h264_intra_pred_dc_16x16_msa(uint8_t *src, ptrdiff_t stride)
  647. {
  648.     uint8_t *src_top = src - stride;
  649.     uint8_t *src_left = src - 1;
  650.     uint8_t *dst = src;
  651.  
  652.     intra_predict_dc_16x16_msa(src_top, src_left, stride, dst, stride, 1, 1);
  653. }
  654.  
  655. void ff_h264_intra_pred_vert_16x16_msa(uint8_t *src, ptrdiff_t stride)
  656. {
  657.     uint8_t *dst = src;
  658.  
  659.     intra_predict_vert_16x16_msa(src - stride, dst, stride);
  660. }
  661.  
  662. void ff_h264_intra_pred_horiz_16x16_msa(uint8_t *src, ptrdiff_t stride)
  663. {
  664.     uint8_t *dst = src;
  665.  
  666.     intra_predict_horiz_16x16_msa(src - 1, stride, dst, stride);
  667. }
  668.  
  669. void ff_h264_intra_pred_dc_left_16x16_msa(uint8_t *src, ptrdiff_t stride)
  670. {
  671.     uint8_t *src_top = src - stride;
  672.     uint8_t *src_left = src - 1;
  673.     uint8_t *dst = src;
  674.  
  675.     intra_predict_dc_16x16_msa(src_top, src_left, stride, dst, stride, 0, 1);
  676. }
  677.  
  678. void ff_h264_intra_pred_dc_top_16x16_msa(uint8_t *src, ptrdiff_t stride)
  679. {
  680.     uint8_t *src_top = src - stride;
  681.     uint8_t *src_left = src - 1;
  682.     uint8_t *dst = src;
  683.  
  684.     intra_predict_dc_16x16_msa(src_top, src_left, stride, dst, stride, 1, 0);
  685. }
  686.  
  687. void ff_h264_intra_pred_dc_128_8x8_msa(uint8_t *src, ptrdiff_t stride)
  688. {
  689.     uint8_t *src_top = src - stride;
  690.     uint8_t *src_left = src - 1;
  691.     uint8_t *dst = src;
  692.  
  693.     intra_predict_dc_8x8_msa(src_top, src_left, stride, dst, stride, 0, 0);
  694. }
  695.  
  696. void ff_h264_intra_pred_dc_128_16x16_msa(uint8_t *src, ptrdiff_t stride)
  697. {
  698.     uint8_t *src_top = src - stride;
  699.     uint8_t *src_left = src - 1;
  700.     uint8_t *dst = src;
  701.  
  702.     intra_predict_dc_16x16_msa(src_top, src_left, stride, dst, stride, 0, 0);
  703. }
  704.  
  705. void ff_vp8_pred8x8_127_dc_8_msa(uint8_t *src, ptrdiff_t stride)
  706. {
  707.     intra_predict_127dc_8x8_msa(src, stride);
  708. }
  709.  
  710. void ff_vp8_pred8x8_129_dc_8_msa(uint8_t *src, ptrdiff_t stride)
  711. {
  712.     intra_predict_129dc_8x8_msa(src, stride);
  713. }
  714.  
  715. void ff_vp8_pred16x16_127_dc_8_msa(uint8_t *src, ptrdiff_t stride)
  716. {
  717.     intra_predict_127dc_16x16_msa(src, stride);
  718. }
  719.  
  720. void ff_vp8_pred16x16_129_dc_8_msa(uint8_t *src, ptrdiff_t stride)
  721. {
  722.     intra_predict_129dc_16x16_msa(src, stride);
  723. }
  724.