/* NEON optimized code (C) COPYRIGHT 2009 Motorola
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

/*
 * Modifications done in-house at Motorola
 *
 * this is a clone of SkBitmapProcState_matrix.h
 * and has been tuned to work with the NEON unit.
 *
 * Still going back and forth between whether this approach
 * (clone the entire SkBitmapProcState_matrix.h file or
 * if I should put just the modified routines in here and
 * then use a construct like #define DONT_DO_THIS_FUNCTION or
 * something like that...
 *
 * This is for the RepeatX_RepeatY part of the world
 */


#include <arm_neon.h>

/*
 * This has been modified on the knowledge that (at the time)
 * we had the following macro definitions in the parent file
 *
 * #define MAKENAME(suffix)        RepeatX_RepeatY ## suffix
 * #define TILEX_PROCF(fx, max)    (((fx) & 0xFFFF) * ((max) + 1) >> 16)
 * #define TILEY_PROCF(fy, max)    (((fy) & 0xFFFF) * ((max) + 1) >> 16)
 * #define TILEX_LOW_BITS(fx, max) ((((fx) & 0xFFFF) * ((max) + 1) >> 12) & 0xF)
 * #define TILEY_LOW_BITS(fy, max) ((((fy) & 0xFFFF) * ((max) + 1) >> 12) & 0xF)
 */

/* SkClampMax(val,max) -- bound to 0..max */

#define SCALE_NOFILTER_NAME     MAKENAME(_nofilter_scale)
#define SCALE_FILTER_NAME       MAKENAME(_filter_scale)
#define AFFINE_NOFILTER_NAME    MAKENAME(_nofilter_affine)
#define AFFINE_FILTER_NAME      MAKENAME(_filter_affine)
#define PERSP_NOFILTER_NAME     MAKENAME(_nofilter_persp)
#define PERSP_FILTER_NAME       MAKENAME(_filter_persp)

#define PACK_FILTER_X_NAME  MAKENAME(_pack_filter_x)
#define PACK_FILTER_Y_NAME  MAKENAME(_pack_filter_y)

#ifndef PREAMBLE
    #define PREAMBLE(state)
    #define PREAMBLE_PARAM_X
    #define PREAMBLE_PARAM_Y
    #define PREAMBLE_ARG_X
    #define PREAMBLE_ARG_Y
#endif

static void SCALE_NOFILTER_NAME(const SkBitmapProcState& s,
                                uint32_t xy[], int count, int x, int y) {
    SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
                             SkMatrix::kScale_Mask)) == 0);

    PREAMBLE(s);
    // we store y, x, x, x, x, x

    const unsigned maxX = s.fBitmap->width() - 1;
    SkFixed fx;
    {
        SkPoint pt;
        s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
                                 SkIntToScalar(y) + SK_ScalarHalf, &pt);
        fx = SkScalarToFixed(pt.fY);
        const unsigned maxY = s.fBitmap->height() - 1;
        *xy++ = TILEY_PROCF(fx, maxY);
        fx = SkScalarToFixed(pt.fX);
    }

    if (0 == maxX) {
        // all of the following X values must be 0
        memset(xy, 0, count * sizeof(uint16_t));
        return;
    }

    const SkFixed dx = s.fInvSx;

#ifdef CHECK_FOR_DECAL
    // test if we don't need to apply the tile proc
    if ((unsigned)(fx >> 16) <= maxX &&
        (unsigned)((fx + dx * (count - 1)) >> 16) <= maxX) {
        decal_nofilter_scale_neon(xy, fx, dx, count);
    } else
#endif
    {
        int i;

    /* RBE: very much like done in decal_nofilter ,
     * but some processing of the 'fx' information
         * TILEX_PROCF(fx, max)    (((fx) & 0xFFFF) * ((max) + 1) >> 16)
     */
    if (count >= 8) {
        /* SkFixed is 16.16 fixed point */
        SkFixed dx2 = dx+dx;
        SkFixed dx4 = dx2+dx2;
        SkFixed dx8 = dx4+dx4;

        /* now build fx/fx+dx/fx+2dx/fx+3dx */
        SkFixed fx1, fx2, fx3;
        int32x4_t lbase, hbase;
        int16_t *dst16 = (int16_t *)xy;

        fx1 = fx+dx;
        fx2 = fx1+dx;
        fx3 = fx2+dx;

        lbase = vdupq_n_s32(fx);
        lbase = vsetq_lane_s32(fx1, lbase, 1);
        lbase = vsetq_lane_s32(fx2, lbase, 2);
        lbase = vsetq_lane_s32(fx3, lbase, 3);
        hbase = vaddq_s32(lbase, vdupq_n_s32(dx4));

        /* store & bump */
        do
        {
            int32x4_t lout;
        int32x4_t hout;
        int16x8_t hi16;

             /* TILEX_PROCF(fx, max) (((fx)&0xFFFF)*((max)+1)>> 16) */
        /* mask to low 16 [would like to use uzp tricks) */
            lout = vandq_s32(lbase, vdupq_n_s32(0xffff));
            hout = vandq_s32(hbase, vdupq_n_s32(0xffff));
        /* bare multiplication, not SkFixedMul */
        lout = vmulq_s32(lout, vdupq_n_s32(maxX+1));
        hout = vmulq_s32(hout, vdupq_n_s32(maxX+1));

        /* extraction, using uzp */
        /* this is ok -- we want all hi(lout)s then all hi(hout)s */
        asm ("vuzpq.16 %q0, %q1" : "+w" (lout), "+w" (hout));
        hi16 = vreinterpretq_s16_s32(hout);
        vst1q_s16(dst16, hi16);

        /* bump our base on to the next */
        lbase = vaddq_s32 (lbase, vdupq_n_s32(dx8));
        hbase = vaddq_s32 (hbase, vdupq_n_s32(dx8));
        dst16 += 8;
        count -= 8;
        fx += dx8;
        } while (count >= 8);
        xy = (uint32_t *) dst16;
    }
        uint16_t* xx = (uint16_t*)xy;
        for (i = count; i > 0; --i) {
            *xx++ = TILEX_PROCF(fx, maxX); fx += dx;
        }
    }
}

// note: we could special-case on a matrix which is skewed in X but not Y.
// this would require a more general setup thatn SCALE does, but could use
// SCALE's inner loop that only looks at dx


static void AFFINE_NOFILTER_NAME(const SkBitmapProcState& s,
                                 uint32_t xy[], int count, int x, int y) {
    SkASSERT(s.fInvType & SkMatrix::kAffine_Mask);
    SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
                             SkMatrix::kScale_Mask |
                             SkMatrix::kAffine_Mask)) == 0);

    PREAMBLE(s);
    SkPoint srcPt;
    s.fInvProc(s.fInvMatrix,
               SkIntToScalar(x) + SK_ScalarHalf,
               SkIntToScalar(y) + SK_ScalarHalf, &srcPt);

    SkFixed fx = SkScalarToFixed(srcPt.fX);
    SkFixed fy = SkScalarToFixed(srcPt.fY);
    SkFixed dx = s.fInvSx;
    SkFixed dy = s.fInvKy;
    int maxX = s.fBitmap->width() - 1;
    int maxY = s.fBitmap->height() - 1;

#if 0
    int ocount = count;
    uint32_t *oxy = xy;
    SkFixed bfx = fx, bfy=fy, bdx=dx, bdy=dy;
#endif


    if (0) { extern void rbe(void); rbe(); }

    /* RBE: benchmarks show this eats up time; can we neonize it? */
    /* RBE: very much like done in decal_nofilter ,
     * but some processing of the 'fx' information
         * TILEX_PROCF(fx, max)    (((fx) & 0xFFFF) * ((max) + 1) >> 16)
     */
    if (count >= 4) {
        /* SkFixed is 16.16 fixed point */
        SkFixed dx4 = dx*4;
        SkFixed dy4 = dy*4;

        /* now build fx/fx+dx/fx+2dx/fx+3dx */
        int32x4_t xbase, ybase;
        int16_t *dst16 = (int16_t *)xy;

        /* synthesize 4x for both X and Y */
        xbase = vdupq_n_s32(fx);
        xbase = vsetq_lane_s32(fx+dx, xbase, 1);
        xbase = vsetq_lane_s32(fx+dx+dx, xbase, 2);
        xbase = vsetq_lane_s32(fx+dx+dx+dx, xbase, 3);

        ybase = vdupq_n_s32(fy);
        ybase = vsetq_lane_s32(fy+dy, ybase, 1);
        ybase = vsetq_lane_s32(fy+dy+dy, ybase, 2);
        ybase = vsetq_lane_s32(fy+dy+dy+dy, ybase, 3);

        /* store & bump */
        do {
            int32x4_t xout;
            int32x4_t yout;
            int16x8_t hi16;

             /* TILEX_PROCF(fx, max) (((fx)&0xFFFF)*((max)+1)>> 16) */
        /* mask to low 16 [would like to use uzp tricks) */
            xout = vandq_s32(xbase, vdupq_n_s32(0xffff));
            yout = vandq_s32(ybase, vdupq_n_s32(0xffff));
        /* bare multiplication, not SkFixedMul */
        xout = vmulq_s32(xout, vdupq_n_s32(maxX+1));
        yout = vmulq_s32(yout, vdupq_n_s32(maxY+1));

        /* put hi16 from xout over low16 from yout */
        yout = vsriq_n_s32(yout, xout, 16);

        /* and then yout has the interleaved upper 16's */
        hi16 = vreinterpretq_s16_s32(yout);
        vst1q_s16(dst16, hi16);

        /* bump preserved base & on to the next */
        xbase = vaddq_s32 (xbase, vdupq_n_s32(dx4));
        ybase = vaddq_s32 (ybase, vdupq_n_s32(dy4));
        dst16 += 8;    /* 8 x16 aka 4x32 */
        count -= 4;
        fx += dx4;
        fy += dy4;
        } while (count >= 4);
        xy = (uint32_t *) dst16;
    }

#if 0
    /* diagnostics... see whether we agree with the NEON code */
    int bad = 0;
    uint32_t *myxy = oxy;
    int myi = (-1);
    SkFixed ofx = bfx, ofy= bfy, odx= bdx, ody= bdy;
    for (myi = ocount; myi > 0; --myi) {
    uint32_t val = (TILEY_PROCF(ofy, maxY) << 16) | TILEX_PROCF(ofx, maxX);
    if (val != *myxy++) {
        bad++;
        break;
    }
        ofx += odx; ofy += ody;
    }
    if (bad) {
        SkDebugf("repeat-nofilter-affine fails\n");
        SkDebugf("count %d myi %d\n", ocount, myi);
        SkDebugf(" bfx %08x, bdx %08x, bfy %08x bdy %08x\n",
                bfx, bdx, bfy, bdy);
        SkDebugf("maxX %08x maxY %08x\n", maxX, maxY);
    }
#endif

    for (int i = count; i > 0; --i) {
    /* fx, fy, dx, dy are all 32 bit 16.16 fixed point */
    /* (((fx) & 0xFFFF) * ((max) + 1) >> 16) */
        *xy++ = (TILEY_PROCF(fy, maxY) << 16) | TILEX_PROCF(fx, maxX);
        fx += dx; fy += dy;
    }
}

static void PERSP_NOFILTER_NAME(const SkBitmapProcState& s,
                                uint32_t* SK_RESTRICT xy,
                                int count, int x, int y) {
    SkASSERT(s.fInvType & SkMatrix::kPerspective_Mask);

    PREAMBLE(s);
    int maxX = s.fBitmap->width() - 1;
    int maxY = s.fBitmap->height() - 1;

    SkPerspIter   iter(s.fInvMatrix,
                       SkIntToScalar(x) + SK_ScalarHalf,
                       SkIntToScalar(y) + SK_ScalarHalf, count);

    while ((count = iter.next()) != 0) {
        const SkFixed* SK_RESTRICT srcXY = iter.getXY();

    /* RBE: */
    /* TILEX_PROCF(fx, max) (((fx) & 0xFFFF) * ((max) + 1) >> 16) */
    /* it's a little more complicated than what I did for the
     * clamp case -- where I could immediately snip to the top
     * 16 bits and do my min/max games there.
     * ... might only be able to get 4x unrolling here
     */

    /* vld2 to get a set of 32x4's ... */
    /* do the tile[xy]_procf operations */
    /* which includes doing vuzp to get hi16's */
    /* store it */
    /* -- inner loop (other than vld2) can be had from above */

    /* srcXY is a batch of 32 bit numbers X0,Y0,X1,Y1...
     * but we immediately discard the low 16 bits...
     * so what we're going to do is vld4, which will give us
     * xlo,xhi,ylo,yhi distribution and we can ignore the 'lo'
     * parts....
     */
    if (0) { extern void rbe(void); rbe(); }
    if (count >= 8) {
        int32_t *mysrc = (int32_t *) srcXY;
        int16_t *mydst = (int16_t *) xy;
        do {
        int32x4_t x, y, x2, y2;
        int16x8_t hi, hi2;

        /* read array of x,y,x,y,x,y */
            /* vld2 does the de-interleaving for us */
        /* isolate reg-bound scopes; gcc will minimize register
         * motion if possible; this ensures that we don't lose
         * a register across a debugging call because it happens
         * to be bound into a call-clobbered register
         */
        {
            register int32x4_t q0 asm("q0");
            register int32x4_t q1 asm("q1");
            asm ("vld2.32    {q0-q1},[%2]  /* x=%q0 y=%q1 */"
                : "=w" (q0), "=w" (q1)
                : "r" (mysrc)
                );
            x = q0; y = q1;
        }

        /* offset == 256 bits == 32 bytes == 8 longs */
        {
            register int32x4_t q2 asm("q2");
            register int32x4_t q3 asm("q3");
            asm ("vld2.32    {q2-q3},[%2]  /* x=%q0 y=%q1 */"
                : "=w" (q2), "=w" (q3)
                : "r" (mysrc+8)
                );
            x2 = q2; y2 = q3;
        }

             /* TILEX_PROCF(fx, max) (((fx)&0xFFFF)*((max)+1)>> 16) */
        /* mask to low 16 [would like to use uzp tricks) */
        /* bare multiplication, not SkFixedMul */
            x = vandq_s32(x, vdupq_n_s32(0xffff));
        x = vmulq_s32(x, vdupq_n_s32(maxX+1));
            y = vandq_s32(y, vdupq_n_s32(0xffff));
        y = vmulq_s32(y, vdupq_n_s32(maxY+1));

            x2 = vandq_s32(x2, vdupq_n_s32(0xffff));
        x2 = vmulq_s32(x2, vdupq_n_s32(maxX+1));
            y2 = vandq_s32(y2, vdupq_n_s32(0xffff));
        y2 = vmulq_s32(y2, vdupq_n_s32(maxY+1));

        /* now collect interleaved high 16's */
        /* (hi-x, hi-y)4  (hi-x2; hi-y2)4 */

        /* extraction, using uzp, leaves hi16's in y */
        y = vsriq_n_s32(y, x, 16);
        hi = vreinterpretq_s16_s32(y);
        vst1q_s16(mydst, hi);

        /* and likewise for the second 8 entries */
        y2 = vsriq_n_s32(y2, x2, 16);
        hi2 = vreinterpretq_s16_s32(y2);
        vst1q_s16(mydst+8, hi2);

        /* XXX: gcc isn't interleaving these with the NEON ops
         * but i think that all the scoreboarding works out */
        count -= 8;    /* 8 iterations */
        mysrc += 16;    /* 16 longs */
        mydst += 16;    /* 16 shorts, aka 8 longs */
        } while (count >= 8);
        /* get xy and srcXY fixed up */
        srcXY = (const SkFixed *) mysrc;
        xy = (uint32_t *) mydst;
    }
        while (--count >= 0) {
            *xy++ = (TILEY_PROCF(srcXY[1], maxY) << 16) |
                     TILEX_PROCF(srcXY[0], maxX);
            srcXY += 2;
        }
    }
}

//////////////////////////////////////////////////////////////////////////////

static inline uint32_t PACK_FILTER_Y_NAME(SkFixed f, unsigned max,
                                          SkFixed one PREAMBLE_PARAM_Y) {
    unsigned i = TILEY_PROCF(f, max);
    i = (i << 4) | TILEY_LOW_BITS(f, max);
    return (i << 14) | (TILEY_PROCF((f + one), max));
}

static inline uint32_t PACK_FILTER_X_NAME(SkFixed f, unsigned max,
                                          SkFixed one PREAMBLE_PARAM_X) {
    unsigned i = TILEX_PROCF(f, max);
    i = (i << 4) | TILEX_LOW_BITS(f, max);
    return (i << 14) | (TILEX_PROCF((f + one), max));
}

static void SCALE_FILTER_NAME(const SkBitmapProcState& s,
                              uint32_t xy[], int count, int x, int y) {
    SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
                             SkMatrix::kScale_Mask)) == 0);
    SkASSERT(s.fInvKy == 0);

    PREAMBLE(s);

    const unsigned maxX = s.fBitmap->width() - 1;
    const SkFixed one = s.fFilterOneX;
    const SkFractionalInt dx = s.fInvSxFractionalInt;
    SkFractionalInt fx;

    {
        SkPoint pt;
        s.fInvProc(s.fInvMatrix, SkIntToScalar(x) + SK_ScalarHalf,
                                 SkIntToScalar(y) + SK_ScalarHalf, &pt);
        const SkFixed fy = SkScalarToFixed(pt.fY) - (s.fFilterOneY >> 1);
        const unsigned maxY = s.fBitmap->height() - 1;
        // compute our two Y values up front
        *xy++ = PACK_FILTER_Y_NAME(fy, maxY, s.fFilterOneY PREAMBLE_ARG_Y);
        // now initialize fx
        fx = SkScalarToFractionalInt(pt.fX) - (SkFixedToFractionalInt(one) >> 1);
    }

#ifdef CHECK_FOR_DECAL
    // test if we don't need to apply the tile proc
    if (can_truncate_to_fixed_for_decal(fx, dx, count, maxX)) {
        decal_filter_scale_neon(xy, SkFractionalIntToFixed(fx),
                                SkFractionalIntToFixed(dx), count);
    } else
#endif
    {
        do {
            SkFixed fixedFx = SkFractionalIntToFixed(fx);
            *xy++ = PACK_FILTER_X_NAME(fixedFx, maxX, one PREAMBLE_ARG_X);
            fx += dx;
        } while (--count != 0);
    }
}

static void AFFINE_FILTER_NAME(const SkBitmapProcState& s,
                               uint32_t xy[], int count, int x, int y) {
    SkASSERT(s.fInvType & SkMatrix::kAffine_Mask);
    SkASSERT((s.fInvType & ~(SkMatrix::kTranslate_Mask |
                             SkMatrix::kScale_Mask |
                             SkMatrix::kAffine_Mask)) == 0);

    PREAMBLE(s);
    SkPoint srcPt;
    s.fInvProc(s.fInvMatrix,
               SkIntToScalar(x) + SK_ScalarHalf,
               SkIntToScalar(y) + SK_ScalarHalf, &srcPt);

    SkFixed oneX = s.fFilterOneX;
    SkFixed oneY = s.fFilterOneY;
    SkFixed fx = SkScalarToFixed(srcPt.fX) - (oneX >> 1);
    SkFixed fy = SkScalarToFixed(srcPt.fY) - (oneY >> 1);
    SkFixed dx = s.fInvSx;
    SkFixed dy = s.fInvKy;
    unsigned maxX = s.fBitmap->width() - 1;
    unsigned maxY = s.fBitmap->height() - 1;

    do {
        *xy++ = PACK_FILTER_Y_NAME(fy, maxY, oneY PREAMBLE_ARG_Y);
        fy += dy;
        *xy++ = PACK_FILTER_X_NAME(fx, maxX, oneX PREAMBLE_ARG_X);
        fx += dx;
    } while (--count != 0);
}

static void PERSP_FILTER_NAME(const SkBitmapProcState& s,
                              uint32_t* SK_RESTRICT xy, int count,
                              int x, int y) {
    SkASSERT(s.fInvType & SkMatrix::kPerspective_Mask);

    extern void rbe(void);

    PREAMBLE(s);
    unsigned maxX = s.fBitmap->width() - 1;
    unsigned maxY = s.fBitmap->height() - 1;
    SkFixed oneX = s.fFilterOneX;
    SkFixed oneY = s.fFilterOneY;


    SkPerspIter   iter(s.fInvMatrix,
                       SkIntToScalar(x) + SK_ScalarHalf,
                       SkIntToScalar(y) + SK_ScalarHalf, count);

    while ((count = iter.next()) != 0) {
        const SkFixed* SK_RESTRICT srcXY = iter.getXY();
        do {
            *xy++ = PACK_FILTER_Y_NAME(srcXY[1] - (oneY >> 1), maxY,
                                       oneY PREAMBLE_ARG_Y);
            *xy++ = PACK_FILTER_X_NAME(srcXY[0] - (oneX >> 1), maxX,
                                       oneX PREAMBLE_ARG_X);
            srcXY += 2;
        } while (--count != 0);
    }
}

const SkBitmapProcState::MatrixProc MAKENAME(_Procs)[] = {
    SCALE_NOFILTER_NAME,
    SCALE_FILTER_NAME,
    AFFINE_NOFILTER_NAME,
    AFFINE_FILTER_NAME,
    PERSP_NOFILTER_NAME,
    PERSP_FILTER_NAME
};

#undef MAKENAME
#undef TILEX_PROCF
#undef TILEY_PROCF
#ifdef CHECK_FOR_DECAL
    #undef CHECK_FOR_DECAL
#endif

#undef SCALE_NOFILTER_NAME
#undef SCALE_FILTER_NAME
#undef AFFINE_NOFILTER_NAME
#undef AFFINE_FILTER_NAME
#undef PERSP_NOFILTER_NAME
#undef PERSP_FILTER_NAME

#undef PREAMBLE
#undef PREAMBLE_PARAM_X
#undef PREAMBLE_PARAM_Y
#undef PREAMBLE_ARG_X
#undef PREAMBLE_ARG_Y

#undef TILEX_LOW_BITS
#undef TILEY_LOW_BITS