/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

#include "SDL_video.h"

#include "SDL_endian.h"

#include "SDL_cpuinfo.h"

#include "SDL_blit.h"

/* Functions to blit from N-bit surfaces to other surfaces */

#if SDL_ALTIVEC_BLITTERS

#if __MWERKS__

#pragma altivec_model on

#endif

#ifdef HAVE_ALTIVEC_H

#include <altivec.h>

#endif

#define assert(X)

#ifdef __MACOSX__

#include <sys/sysctl.h>

static size_t GetL3CacheSize( void )

{

    const char key[] = "hw.l3cachesize";

    u_int64_t result = 0;

    size_t typeSize = sizeof( result );

    int err = sysctlbyname( key, &result, &typeSize, NULL, 0 );

    if( 0 != err ) return 0;

    return result;

}

#else

static size_t GetL3CacheSize( void )

{

    /* XXX: Just guess G4 */

    return 2097152;

}

#endif /* __MACOSX__ */

#if (defined(__MACOSX__) && (__GNUC__ < 4))

    #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \

        (vector unsigned char) ( a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p )

    #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \

        (vector unsigned short) ( a,b,c,d,e,f,g,h )

#else

    #define VECUINT8_LITERAL(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) \

        (vector unsigned char) { a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p }

    #define VECUINT16_LITERAL(a,b,c,d,e,f,g,h) \

        (vector unsigned short) { a,b,c,d,e,f,g,h }

#endif

#define UNALIGNED_PTR(x) (((size_t) x) & 0x0000000F)

#define VSWIZZLE32(a,b,c,d) (vector unsigned char) \

                               ( 0x00+a, 0x00+b, 0x00+c, 0x00+d, \

                                 0x04+a, 0x04+b, 0x04+c, 0x04+d, \

                                 0x08+a, 0x08+b, 0x08+c, 0x08+d, \

                                 0x0C+a, 0x0C+b, 0x0C+c, 0x0C+d )

#define MAKE8888(dstfmt, r, g, b, a)  \

    ( ((r<<dstfmt->Rshift)&dstfmt->Rmask) | \

      ((g<<dstfmt->Gshift)&dstfmt->Gmask) | \

      ((b<<dstfmt->Bshift)&dstfmt->Bmask) | \

      ((a<<dstfmt->Ashift)&dstfmt->Amask) )

/*

 * Data Stream Touch...Altivec cache prefetching.

 *

 *  Don't use this on a G5...however, the speed boost is very significant

 *   on a G4.

 */

#define DST_CHAN_SRC 1

#define DST_CHAN_DEST 2

/* macro to set DST control word value... */

#define DST_CTRL(size, count, stride) \

    (((size) << 24) | ((count) << 16) | (stride))

#define VEC_ALIGNER(src) ((UNALIGNED_PTR(src)) \

    ? vec_lvsl(0, src) \

    : vec_add(vec_lvsl(8, src), vec_splat_u8(8)))

/* Calculate the permute vector used for 32->32 swizzling */

static vector unsigned char calc_swizzle32(const SDL_PixelFormat *srcfmt,

                                  const SDL_PixelFormat *dstfmt)

{

    /*

    * We have to assume that the bits that aren't used by other

     *  colors is alpha, and it's one complete byte, since some formats

     *  leave alpha with a zero mask, but we should still swizzle the bits.

     */

    /* ARGB */

    const static struct SDL_PixelFormat default_pixel_format = {

        NULL, 0, 0,

        0, 0, 0, 0,

        16, 8, 0, 24,

        0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,

        0, 0};

    if (!srcfmt) {

        srcfmt = &default_pixel_format;

    }

    if (!dstfmt) {

        dstfmt = &default_pixel_format;

    }

    const vector unsigned char plus = VECUINT8_LITERAL(

                                      0x00, 0x00, 0x00, 0x00,

                                      0x04, 0x04, 0x04, 0x04,

                                      0x08, 0x08, 0x08, 0x08,

                                      0x0C, 0x0C, 0x0C, 0x0C );

    vector unsigned char vswiz;

    vector unsigned int srcvec;

#define RESHIFT(X) (3 - ((X) >> 3))

    Uint32 rmask = RESHIFT(srcfmt->Rshift) << (dstfmt->Rshift);

    Uint32 gmask = RESHIFT(srcfmt->Gshift) << (dstfmt->Gshift);

    Uint32 bmask = RESHIFT(srcfmt->Bshift) << (dstfmt->Bshift);

    Uint32 amask;

    /* Use zero for alpha if either surface doesn't have alpha */

    if (dstfmt->Amask) {

        amask = ((srcfmt->Amask) ? RESHIFT(srcfmt->Ashift) : 0x10) << (dstfmt->Ashift);

    } else {    

        amask = 0x10101010 & ((dstfmt->Rmask | dstfmt->Gmask | dstfmt->Bmask) ^ 0xFFFFFFFF);

    }           

#undef RESHIFT  

    ((unsigned int *)(char*)&srcvec)[0] = (rmask | gmask | bmask | amask);

    vswiz = vec_add(plus, (vector unsigned char)vec_splat(srcvec, 0));

    return(vswiz);

}

static void Blit_RGB888_RGB565(SDL_BlitInfo *info);

static void Blit_RGB888_RGB565Altivec(SDL_BlitInfo *info) {

    int height = info->d_height;

    Uint8 *src = (Uint8 *) info->s_pixels;

    int srcskip = info->s_skip;

    Uint8 *dst = (Uint8 *) info->d_pixels;

    int dstskip = info->d_skip;

    SDL_PixelFormat *srcfmt = info->src;

    vector unsigned char valpha = vec_splat_u8(0);

    vector unsigned char vpermute = calc_swizzle32(srcfmt, NULL);

    vector unsigned char vgmerge = VECUINT8_LITERAL(

        0x00, 0x02, 0x00, 0x06,

        0x00, 0x0a, 0x00, 0x0e,

        0x00, 0x12, 0x00, 0x16,

        0x00, 0x1a, 0x00, 0x1e);

    vector unsigned short v1 = vec_splat_u16(1);

    vector unsigned short v3 = vec_splat_u16(3);

    vector unsigned short v3f = VECUINT16_LITERAL(

        0x003f, 0x003f, 0x003f, 0x003f,

        0x003f, 0x003f, 0x003f, 0x003f);

    vector unsigned short vfc = VECUINT16_LITERAL(

        0x00fc, 0x00fc, 0x00fc, 0x00fc,

        0x00fc, 0x00fc, 0x00fc, 0x00fc);

    vector unsigned short vf800 = (vector unsigned short)vec_splat_u8(-7);

    vf800 = vec_sl(vf800, vec_splat_u16(8));

    while (height--) {

        vector unsigned char valigner;

        vector unsigned char voverflow;

        vector unsigned char vsrc;

        int width = info->d_width;

        int extrawidth;

        /* do scalar until we can align... */

#define ONE_PIXEL_BLEND(condition, widthvar) \

        while (condition) { \

            Uint32 Pixel; \

            unsigned sR, sG, sB, sA; \

            DISEMBLE_RGBA((Uint8 *)src, 4, srcfmt, Pixel, \

                          sR, sG, sB, sA); \

            *(Uint16 *)(dst) = (((sR << 8) & 0x0000F800) | \

                                ((sG << 3) & 0x000007E0) | \

                                ((sB >> 3) & 0x0000001F)); \

            dst += 2; \

            src += 4; \

            widthvar--; \

        }

        ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);

        /* After all that work, here's the vector part! */

        extrawidth = (width % 8);  /* trailing unaligned stores */

        width -= extrawidth;

        vsrc = vec_ld(0, src);

        valigner = VEC_ALIGNER(src);

        while (width) {

            vector unsigned short vpixel, vrpixel, vgpixel, vbpixel;

            vector unsigned int vsrc1, vsrc2;

            vector unsigned char vdst;

            voverflow = vec_ld(15, src);

            vsrc = vec_perm(vsrc, voverflow, valigner);

            vsrc1 = (vector unsigned int)vec_perm(vsrc, valpha, vpermute);

            src += 16;

            vsrc = voverflow;

            voverflow = vec_ld(15, src);

            vsrc = vec_perm(vsrc, voverflow, valigner);

            vsrc2 = (vector unsigned int)vec_perm(vsrc, valpha, vpermute);

            /* 1555 */

            vpixel = (vector unsigned short)vec_packpx(vsrc1, vsrc2);

            vgpixel = (vector unsigned short)vec_perm(vsrc1, vsrc2, vgmerge);

            vgpixel = vec_and(vgpixel, vfc);

            vgpixel = vec_sl(vgpixel, v3);

            vrpixel = vec_sl(vpixel, v1);

            vrpixel = vec_and(vrpixel, vf800);

            vbpixel = vec_and(vpixel, v3f);

            vdst = vec_or((vector unsigned char)vrpixel, (vector unsigned char)vgpixel);

            /* 565 */

            vdst = vec_or(vdst, (vector unsigned char)vbpixel);

            vec_st(vdst, 0, dst);

            width -= 8;

            src += 16;

            dst += 16;

            vsrc = voverflow;

        }

        assert(width == 0);

        /* do scalar until we can align... */

        ONE_PIXEL_BLEND((extrawidth), extrawidth);

#undef ONE_PIXEL_BLEND

        src += srcskip;  /* move to next row, accounting for pitch. */

        dst += dstskip;

    }

}

static void Blit_RGB565_32Altivec(SDL_BlitInfo *info) {

    int height = info->d_height;

    Uint8 *src = (Uint8 *) info->s_pixels;

    int srcskip = info->s_skip;

    Uint8 *dst = (Uint8 *) info->d_pixels;

    int dstskip = info->d_skip;

    SDL_PixelFormat *srcfmt = info->src;

    SDL_PixelFormat *dstfmt = info->dst;

    unsigned alpha;

    vector unsigned char valpha;

    vector unsigned char vpermute;

    vector unsigned short vf800;

    vector unsigned int v8 = vec_splat_u32(8);

    vector unsigned int v16 = vec_add(v8, v8);

    vector unsigned short v2 = vec_splat_u16(2);

    vector unsigned short v3 = vec_splat_u16(3);

    /* 

        0x10 - 0x1f is the alpha

        0x00 - 0x0e evens are the red

        0x01 - 0x0f odds are zero

    */

    vector unsigned char vredalpha1 = VECUINT8_LITERAL(

        0x10, 0x00, 0x01, 0x01,

        0x10, 0x02, 0x01, 0x01,

        0x10, 0x04, 0x01, 0x01,

        0x10, 0x06, 0x01, 0x01

    );

    vector unsigned char vredalpha2 = (vector unsigned char) (

        vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16))

    );

    /*

        0x00 - 0x0f is ARxx ARxx ARxx ARxx

        0x11 - 0x0f odds are blue

    */

    vector unsigned char vblue1 = VECUINT8_LITERAL(

        0x00, 0x01, 0x02, 0x11,

        0x04, 0x05, 0x06, 0x13,

        0x08, 0x09, 0x0a, 0x15,

        0x0c, 0x0d, 0x0e, 0x17

    );

    vector unsigned char vblue2 = (vector unsigned char)(

        vec_add((vector unsigned int)vblue1, v8)

    );

    /*

        0x00 - 0x0f is ARxB ARxB ARxB ARxB

        0x10 - 0x0e evens are green

    */

    vector unsigned char vgreen1 = VECUINT8_LITERAL(

        0x00, 0x01, 0x10, 0x03,

        0x04, 0x05, 0x12, 0x07,

        0x08, 0x09, 0x14, 0x0b,

        0x0c, 0x0d, 0x16, 0x0f

    );

    vector unsigned char vgreen2 = (vector unsigned char)(

        vec_add((vector unsigned int)vgreen1, vec_sl(v8, v8))

    );

    assert(srcfmt->BytesPerPixel == 2);

    assert(dstfmt->BytesPerPixel == 4);

    vf800 = (vector unsigned short)vec_splat_u8(-7);

    vf800 = vec_sl(vf800, vec_splat_u16(8));

    if (dstfmt->Amask && srcfmt->alpha) {

        ((unsigned char *)&valpha)[0] = alpha = srcfmt->alpha;

        valpha = vec_splat(valpha, 0);

    } else {

        alpha = 0;

        valpha = vec_splat_u8(0);

    }

    vpermute = calc_swizzle32(NULL, dstfmt);

    while (height--) {

        vector unsigned char valigner;

        vector unsigned char voverflow;

        vector unsigned char vsrc;

        int width = info->d_width;

        int extrawidth;

        /* do scalar until we can align... */

#define ONE_PIXEL_BLEND(condition, widthvar) \

        while (condition) { \

            unsigned sR, sG, sB; \

            unsigned short Pixel = *((unsigned short *)src); \

            sR = (Pixel >> 8) & 0xf8; \

            sG = (Pixel >> 3) & 0xfc; \

            sB = (Pixel << 3) & 0xf8; \

            ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \

            src += 2; \

            dst += 4; \

            widthvar--; \

        }

        ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);

        /* After all that work, here's the vector part! */

        extrawidth = (width % 8);  /* trailing unaligned stores */

        width -= extrawidth;

        vsrc = vec_ld(0, src);

        valigner = VEC_ALIGNER(src);

        while (width) {

            vector unsigned short vR, vG, vB;

            vector unsigned char vdst1, vdst2;

            voverflow = vec_ld(15, src);

            vsrc = vec_perm(vsrc, voverflow, valigner);

            vR = vec_and((vector unsigned short)vsrc, vf800);

            vB = vec_sl((vector unsigned short)vsrc, v3);

            vG = vec_sl(vB, v2);

            vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha1);

            vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1);

            vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1);

            vdst1 = vec_perm(vdst1, valpha, vpermute);

            vec_st(vdst1, 0, dst);

            vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha2);

            vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2);

            vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2);

            vdst2 = vec_perm(vdst2, valpha, vpermute);

            vec_st(vdst2, 16, dst);

            width -= 8;

            dst += 32;

            src += 16;

            vsrc = voverflow;

        }

        assert(width == 0);

        /* do scalar until we can align... */

        ONE_PIXEL_BLEND((extrawidth), extrawidth);

#undef ONE_PIXEL_BLEND

        src += srcskip;  /* move to next row, accounting for pitch. */

        dst += dstskip;

    }

}

static void Blit_RGB555_32Altivec(SDL_BlitInfo *info) {

    int height = info->d_height;

    Uint8 *src = (Uint8 *) info->s_pixels;

    int srcskip = info->s_skip;

    Uint8 *dst = (Uint8 *) info->d_pixels;

    int dstskip = info->d_skip;

    SDL_PixelFormat *srcfmt = info->src;

    SDL_PixelFormat *dstfmt = info->dst;

    unsigned alpha;

    vector unsigned char valpha;

    vector unsigned char vpermute;

    vector unsigned short vf800;

    vector unsigned int v8 = vec_splat_u32(8);

    vector unsigned int v16 = vec_add(v8, v8);

    vector unsigned short v1 = vec_splat_u16(1);

    vector unsigned short v3 = vec_splat_u16(3);

    /* 

        0x10 - 0x1f is the alpha

        0x00 - 0x0e evens are the red

        0x01 - 0x0f odds are zero

    */

    vector unsigned char vredalpha1 = VECUINT8_LITERAL(

        0x10, 0x00, 0x01, 0x01,

        0x10, 0x02, 0x01, 0x01,

        0x10, 0x04, 0x01, 0x01,

        0x10, 0x06, 0x01, 0x01

    );

    vector unsigned char vredalpha2 = (vector unsigned char)(

        vec_add((vector unsigned int)vredalpha1, vec_sl(v8, v16))

    );

    /*

        0x00 - 0x0f is ARxx ARxx ARxx ARxx

        0x11 - 0x0f odds are blue

    */

    vector unsigned char vblue1 = VECUINT8_LITERAL(

        0x00, 0x01, 0x02, 0x11,

        0x04, 0x05, 0x06, 0x13,

        0x08, 0x09, 0x0a, 0x15,

        0x0c, 0x0d, 0x0e, 0x17

    );

    vector unsigned char vblue2 = (vector unsigned char)(

        vec_add((vector unsigned int)vblue1, v8)

    );

    /*

        0x00 - 0x0f is ARxB ARxB ARxB ARxB

        0x10 - 0x0e evens are green

    */

    vector unsigned char vgreen1 = VECUINT8_LITERAL(

        0x00, 0x01, 0x10, 0x03,

        0x04, 0x05, 0x12, 0x07,

        0x08, 0x09, 0x14, 0x0b,

        0x0c, 0x0d, 0x16, 0x0f

    );

    vector unsigned char vgreen2 = (vector unsigned char)(

        vec_add((vector unsigned int)vgreen1, vec_sl(v8, v8))

    );

    assert(srcfmt->BytesPerPixel == 2);

    assert(dstfmt->BytesPerPixel == 4);

    vf800 = (vector unsigned short)vec_splat_u8(-7);

    vf800 = vec_sl(vf800, vec_splat_u16(8));

    if (dstfmt->Amask && srcfmt->alpha) {

        ((unsigned char *)&valpha)[0] = alpha = srcfmt->alpha;

        valpha = vec_splat(valpha, 0);

    } else {

        alpha = 0;

        valpha = vec_splat_u8(0);

    }

    vpermute = calc_swizzle32(NULL, dstfmt);

    while (height--) {

        vector unsigned char valigner;

        vector unsigned char voverflow;

        vector unsigned char vsrc;

        int width = info->d_width;

        int extrawidth;

        /* do scalar until we can align... */

#define ONE_PIXEL_BLEND(condition, widthvar) \

        while (condition) { \

            unsigned sR, sG, sB; \

            unsigned short Pixel = *((unsigned short *)src); \

            sR = (Pixel >> 7) & 0xf8; \

            sG = (Pixel >> 2) & 0xf8; \

            sB = (Pixel << 3) & 0xf8; \

            ASSEMBLE_RGBA(dst, 4, dstfmt, sR, sG, sB, alpha); \

            src += 2; \

            dst += 4; \

            widthvar--; \

        }

        ONE_PIXEL_BLEND(((UNALIGNED_PTR(dst)) && (width)), width);

        /* After all that work, here's the vector part! */

        extrawidth = (width % 8);  /* trailing unaligned stores */

        width -= extrawidth;

        vsrc = vec_ld(0, src);

        valigner = VEC_ALIGNER(src);

        while (width) {

            vector unsigned short vR, vG, vB;

            vector unsigned char vdst1, vdst2;

            voverflow = vec_ld(15, src);

            vsrc = vec_perm(vsrc, voverflow, valigner);

            vR = vec_and(vec_sl((vector unsigned short)vsrc,v1), vf800);

            vB = vec_sl((vector unsigned short)vsrc, v3);

            vG = vec_sl(vB, v3);

            vdst1 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha1);

            vdst1 = vec_perm(vdst1, (vector unsigned char)vB, vblue1);

            vdst1 = vec_perm(vdst1, (vector unsigned char)vG, vgreen1);

            vdst1 = vec_perm(vdst1, valpha, vpermute);

            vec_st(vdst1, 0, dst);

            vdst2 = (vector unsigned char)vec_perm((vector unsigned char)vR, valpha, vredalpha2);

            vdst2 = vec_perm(vdst2, (vector unsigned char)vB, vblue2);

            vdst2 = vec_perm(vdst2, (vector unsigned char)vG, vgreen2);

            vdst2 = vec_perm(vdst2, valpha, vpermute);

            vec_st(vdst2, 16, dst);

            width -= 8;

            dst += 32;

            src += 16;

            vsrc = voverflow;

        }

        assert(width == 0);