dsputil_vis.c

现在关于h.264的源码很多

                if (off != 0x7) {
                        vis_alignaddr_g0((void *)off_plus_1);

                        vis_ld64(dest[0], DST_0);
                        vis_faligndata(TMP0, TMP2, REF_2);

                        vis_ld64_2(dest, stride, DST_2);
                        vis_faligndata(TMP4, TMP6, REF_6);

                        vis_faligndata(TMP8, TMP10, REF_S2);

                        vis_faligndata(TMP12, TMP14, REF_S6);
                } else {
                        vis_ld64(dest[0], DST_0);
                        vis_src1(TMP2, REF_2);

                        vis_ld64_2(dest, stride, DST_2);
                        vis_src1(TMP6, REF_6);

                        vis_src1(TMP10, REF_S2);

                        vis_src1(TMP14, REF_S6);
                }

                vis_pmerge(ZERO,     REF_0,     TMP0);
                vis_mul8x16au(REF_0_1, CONST_256, TMP2);

                vis_pmerge(ZERO,     REF_2,     TMP4);
                vis_mul8x16au(REF_2_1, CONST_256, TMP6);

                vis_padd16(TMP0, CONST_3, TMP0);
                vis_mul8x16al(DST_0,   CONST_512, TMP16);

                vis_padd16(TMP2, CONST_3, TMP2);
                vis_mul8x16al(DST_1,   CONST_512, TMP18);

                vis_padd16(TMP0, TMP4, TMP0);
                vis_mul8x16au(REF_4, CONST_256, TMP8);

                vis_padd16(TMP2, TMP6, TMP2);
                vis_mul8x16au(REF_4_1, CONST_256, TMP10);

                vis_padd16(TMP0, TMP16, TMP0);
                vis_mul8x16au(REF_6, CONST_256, TMP12);

                vis_padd16(TMP2, TMP18, TMP2);
                vis_mul8x16au(REF_6_1, CONST_256, TMP14);

                vis_padd16(TMP8, CONST_3, TMP8);
                vis_mul8x16al(DST_2, CONST_512, TMP16);

                vis_padd16(TMP8, TMP12, TMP8);
                vis_mul8x16al(DST_3, CONST_512, TMP18);

                vis_padd16(TMP10, TMP14, TMP10);
                vis_pack16(TMP0, DST_0);

                vis_pack16(TMP2, DST_1);
                vis_st64(DST_0, dest[0]);
                dest += stride;
                vis_padd16(TMP10, CONST_3, TMP10);

                vis_ld64_2(dest, stride, DST_0);
                vis_padd16(TMP8, TMP16, TMP8);

                vis_ld64_2(dest, stride_times_2, TMP4/*DST_2*/);
                vis_padd16(TMP10, TMP18, TMP10);
                vis_pack16(TMP8, DST_2);

                vis_pack16(TMP10, DST_3);
                vis_st64(DST_2, dest[0]);
                dest += stride;

                vis_mul8x16au(REF_S0_1, CONST_256, TMP2);
                vis_pmerge(ZERO,     REF_S0,     TMP0);

                vis_pmerge(ZERO,     REF_S2,     TMP24);
                vis_mul8x16au(REF_S2_1, CONST_256, TMP6);

                vis_padd16(TMP0, CONST_3, TMP0);
                vis_mul8x16au(REF_S4, CONST_256, TMP8);

                vis_padd16(TMP2, CONST_3, TMP2);
                vis_mul8x16au(REF_S4_1, CONST_256, TMP10);

                vis_padd16(TMP0, TMP24, TMP0);
                vis_mul8x16au(REF_S6, CONST_256, TMP12);

                vis_padd16(TMP2, TMP6, TMP2);
                vis_mul8x16au(REF_S6_1, CONST_256, TMP14);

                vis_padd16(TMP8, CONST_3, TMP8);
                vis_mul8x16al(DST_0,   CONST_512, TMP16);

                vis_padd16(TMP10, CONST_3, TMP10);
                vis_mul8x16al(DST_1,   CONST_512, TMP18);

                vis_padd16(TMP8, TMP12, TMP8);
                vis_mul8x16al(TMP4/*DST_2*/, CONST_512, TMP20);

                vis_mul8x16al(TMP5/*DST_3*/, CONST_512, TMP22);
                vis_padd16(TMP0, TMP16, TMP0);

                vis_padd16(TMP2, TMP18, TMP2);
                vis_pack16(TMP0, DST_0);

                vis_padd16(TMP10, TMP14, TMP10);
                vis_pack16(TMP2, DST_1);
                vis_st64(DST_0, dest[0]);
                dest += stride;

                vis_padd16(TMP8, TMP20, TMP8);

                vis_padd16(TMP10, TMP22, TMP10);
                vis_pack16(TMP8, DST_2);

                vis_pack16(TMP10, DST_3);
                vis_st64(DST_2, dest[0]);
                dest += stride;
        } while (--height);
}

static void MC_put_y_16_vis (uint8_t * dest, const uint8_t * _ref,
                             const int stride, int height)
{
        uint8_t *ref = (uint8_t *) _ref;

        ref = vis_alignaddr(ref);
        vis_ld64(ref[0], TMP0);

        vis_ld64_2(ref, 8, TMP2);

        vis_ld64_2(ref, 16, TMP4);
        ref += stride;

        vis_ld64(ref[0], TMP6);
        vis_faligndata(TMP0, TMP2, REF_0);

        vis_ld64_2(ref, 8, TMP8);
        vis_faligndata(TMP2, TMP4, REF_4);

        vis_ld64_2(ref, 16, TMP10);
        ref += stride;

        vis_ld64(constants_fe[0], MASK_fe);
        vis_faligndata(TMP6, TMP8, REF_2);

        vis_ld64(constants_7f[0], MASK_7f);
        vis_faligndata(TMP8, TMP10, REF_6);

        vis_ld64(constants128[0], CONST_128);
        height = (height >> 1) - 1;
        do {    /* 24 cycles */
                vis_ld64(ref[0], TMP0);
                vis_xor(REF_0, REF_2, TMP12);

                vis_ld64_2(ref, 8, TMP2);
                vis_xor(REF_4, REF_6, TMP16);

                vis_ld64_2(ref, 16, TMP4);
                ref += stride;
                vis_or(REF_0, REF_2, TMP14);

                vis_ld64(ref[0], TMP6);
                vis_or(REF_4, REF_6, TMP18);

                vis_ld64_2(ref, 8, TMP8);
                vis_faligndata(TMP0, TMP2, REF_0);

                vis_ld64_2(ref, 16, TMP10);
                ref += stride;
                vis_faligndata(TMP2, TMP4, REF_4);

                vis_and(TMP12, MASK_fe, TMP12);

                vis_and(TMP16, MASK_fe, TMP16);
                vis_mul8x16(CONST_128, TMP12, TMP12);

                vis_mul8x16(CONST_128, TMP16, TMP16);
                vis_xor(REF_0, REF_2, TMP0);

                vis_xor(REF_4, REF_6, TMP2);

                vis_or(REF_0, REF_2, TMP20);

                vis_and(TMP12, MASK_7f, TMP12);

                vis_and(TMP16, MASK_7f, TMP16);

                vis_psub16(TMP14, TMP12, TMP12);
                vis_st64(TMP12, dest[0]);

                vis_psub16(TMP18, TMP16, TMP16);
                vis_st64_2(TMP16, dest, 8);
                dest += stride;

                vis_or(REF_4, REF_6, TMP18);

                vis_and(TMP0, MASK_fe, TMP0);

                vis_and(TMP2, MASK_fe, TMP2);
                vis_mul8x16(CONST_128, TMP0, TMP0);

                vis_faligndata(TMP6, TMP8, REF_2);
                vis_mul8x16(CONST_128, TMP2, TMP2);

                vis_faligndata(TMP8, TMP10, REF_6);

                vis_and(TMP0, MASK_7f, TMP0);

                vis_and(TMP2, MASK_7f, TMP2);

                vis_psub16(TMP20, TMP0, TMP0);
                vis_st64(TMP0, dest[0]);

                vis_psub16(TMP18, TMP2, TMP2);
                vis_st64_2(TMP2, dest, 8);
                dest += stride;
        } while (--height);

        vis_ld64(ref[0], TMP0);
        vis_xor(REF_0, REF_2, TMP12);

        vis_ld64_2(ref, 8, TMP2);
        vis_xor(REF_4, REF_6, TMP16);

        vis_ld64_2(ref, 16, TMP4);
        vis_or(REF_0, REF_2, TMP14);

        vis_or(REF_4, REF_6, TMP18);

        vis_faligndata(TMP0, TMP2, REF_0);

        vis_faligndata(TMP2, TMP4, REF_4);

        vis_and(TMP12, MASK_fe, TMP12);

        vis_and(TMP16, MASK_fe, TMP16);
        vis_mul8x16(CONST_128, TMP12, TMP12);

        vis_mul8x16(CONST_128, TMP16, TMP16);
        vis_xor(REF_0, REF_2, TMP0);

        vis_xor(REF_4, REF_6, TMP2);

        vis_or(REF_0, REF_2, TMP20);

        vis_and(TMP12, MASK_7f, TMP12);

        vis_and(TMP16, MASK_7f, TMP16);

        vis_psub16(TMP14, TMP12, TMP12);
        vis_st64(TMP12, dest[0]);

        vis_psub16(TMP18, TMP16, TMP16);
        vis_st64_2(TMP16, dest, 8);
        dest += stride;

        vis_or(REF_4, REF_6, TMP18);

        vis_and(TMP0, MASK_fe, TMP0);

        vis_and(TMP2, MASK_fe, TMP2);
        vis_mul8x16(CONST_128, TMP0, TMP0);

        vis_mul8x16(CONST_128, TMP2, TMP2);

        vis_and(TMP0, MASK_7f, TMP0);

        vis_and(TMP2, MASK_7f, TMP2);

        vis_psub16(TMP20, TMP0, TMP0);
        vis_st64(TMP0, dest[0]);

        vis_psub16(TMP18, TMP2, TMP2);
        vis_st64_2(TMP2, dest, 8);
}

static void MC_put_y_8_vis (uint8_t * dest, const uint8_t * _ref,
                            const int stride, int height)
{
        uint8_t *ref = (uint8_t *) _ref;

        ref = vis_alignaddr(ref);
        vis_ld64(ref[0], TMP0);

        vis_ld64_2(ref, 8, TMP2);
        ref += stride;

        vis_ld64(ref[0], TMP4);

        vis_ld64_2(ref, 8, TMP6);
        ref += stride;

        vis_ld64(constants_fe[0], MASK_fe);
        vis_faligndata(TMP0, TMP2, REF_0);

        vis_ld64(constants_7f[0], MASK_7f);
        vis_faligndata(TMP4, TMP6, REF_2);

        vis_ld64(constants128[0], CONST_128);
        height = (height >> 1) - 1;
        do {    /* 12 cycles */
                vis_ld64(ref[0], TMP0);
                vis_xor(REF_0, REF_2, TMP4);

                vis_ld64_2(ref, 8, TMP2);
                ref += stride;
                vis_and(TMP4, MASK_fe, TMP4);

                vis_or(REF_0, REF_2, TMP6);
                vis_mul8x16(CONST_128, TMP4, TMP4);

                vis_faligndata(TMP0, TMP2, REF_0);
                vis_ld64(ref[0], TMP0);

                vis_ld64_2(ref, 8, TMP2);
                ref += stride;
                vis_xor(REF_0, REF_2, TMP12);

                vis_and(TMP4, MASK_7f, TMP4);

                vis_and(TMP12, MASK_fe, TMP12);

                vis_mul8x16(CONST_128, TMP12, TMP12);
                vis_or(REF_0, REF_2, TMP14);

                vis_psub16(TMP6, TMP4, DST_0);
                vis_st64(DST_0, dest[0]);
                dest += stride;

                vis_faligndata(TMP0, TMP2, REF_2);

                vis_and(TMP12, MASK_7f, TMP12);

                vis_psub16(TMP14, TMP12, DST_0);
                vis_st64(DST_0, dest[0]);
                dest += stride;
        } while (--height);

        vis_ld64(ref[0], TMP0);
        vis_xor(REF_0, REF_2, TMP4);

        vis_ld64_2(ref, 8, TMP2);
        vis_and(TMP4, MASK_fe, TMP4);

        vis_or(REF_0, REF_2, TMP6);
        vis_mul8x16(CONST_128, TMP4, TMP4);

        vis_faligndata(TMP0, TMP2, REF_0);

        vis_xor(REF_0, REF_2, TMP12);

        vis_and(TMP4, MASK_7f, TMP4);

        vis_and(TMP12, MASK_fe, TMP12);

        vis_mul8x16(CONST_128, TMP12, TMP12);
        vis_or(REF_0, REF_2, TMP14);

        vis_psub16(TMP6, TMP4, DST_0);
        vis_st64(DST_0, dest[0]);
        dest += stride;

        vis_and(TMP12, MASK_7f, TMP12);

        vis_psub16(TMP14, TMP12, DST_0);
        vis_st64(DST_0, dest[0]);
}

static void MC_avg_y_16_vis (uint8_t * dest, const uint8_t * _ref,
                             const int stride, int height)
{
        uint8_t *ref = (uint8_t *) _ref;
        int stride_8 = stride + 8;
        int stride_16 = stride + 16;

        vis_set_gsr(5 << VIS_GSR_SCALEFACT_SHIFT);

        ref = vis_alignaddr(ref);

        vis_ld64(ref[ 0], TMP0);
        vis_fzero(ZERO);

        vis_ld64(ref[ 8], TMP2);

        vis_ld64(ref[16], TMP4);

        vis_ld64(constants3[0], CONST_3);
        vis_faligndata(TMP0, TMP2, REF_2);

        vis_ld64(constants256_512[0], CONST_256);
        vis_faligndata(TMP2, TMP4, REF_6);
        height >>= 1;

        do {    /* 31 cycles */
                vis_ld64_2(ref, stride, TMP0);
                vis_pmerge(ZERO,       REF_2,     TMP12);
                vis_mul8x16au(REF_2_1, CONST_256, TMP14);

                vis_ld64_2(ref, stride_8, TMP2);
                vis_pmerge(ZERO,       REF_6,     TMP16);
                vis_mul8x16au(REF_6_1, CONST_256, TMP18);

                vis_ld64_2(ref, stride_16, TMP4);
                ref += stride;

                vis_ld64(dest[0], DST_0);
                vis_faligndata(TMP0, TMP2, REF_0);

                vis_ld64_2(dest, 8, DST_2);
                vis_faligndata(TMP2, TMP4, REF_4);

                vis_ld64_2(ref, stride, TMP6);
                vis_pmerge(ZERO,     REF_0,     TMP0);
                vis_mul8x16au(REF_0_1, CONST_256, TMP2);

                vis_ld64_2(ref, stride_8, TMP8);
                vis_pmerge(ZERO,     REF_4,     TMP4);

                vis_ld64_2(ref, stride_16, TMP10);
                ref += stride;

                vis_ld64_2(dest, stride, REF_S0/*DST_4*/);
                vis_faligndata(TMP6, TMP8, REF_2);
                vis_mul8x16au(REF_4_1, CONST_256, TMP6);

                vis_ld64_2(dest, stride_8, REF_S2/*DST_6*/);
                vis_faligndata(TMP8, TMP10, REF_6);
                vis_mul8x16al(DST_0,   CONST_512, TMP20);

                vis_padd16(TMP0, CONST_3, TMP0);
                vis_mul8x16al(DST_1,   CONST_512, TMP22);

                vis_padd16(TMP2, CONST_3, TMP2);
                vis_mul8x16al(DST_2,   CONST_512, TMP24);

                vis_padd16(TMP4, CONST_3, TMP4);
                vis_mul8x16al(DST_3,   CONST_512, TMP26);