/*

 * Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

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

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#import "ImageSurfaceData.h"

#import "java_awt_Transparency.h"

#import "java_awt_image_BufferedImage.h"

#import "sun_awt_image_BufImgSurfaceData.h"

#import "sun_java2d_OSXOffScreenSurfaceData.h"

#import "jni_util.h"

#import <JavaNativeFoundation/JavaNativeFoundation.h>

#import "BufImgSurfaceData.h"

//#define DEBUG 1

#if defined DEBUG

    #define IMAGE_SURFACE_INLINE

    #define PRINT(msg) {fprintf(stderr, "%s\n", msg);fflush(stderr);}

#else

    #define IMAGE_SURFACE_INLINE static inline

    #define PRINT(msg) {}

#endif

// same value as defined in Sun's own code

#define XOR_ALPHA_CUTOFF 128

// for vImage framework headers

#include <Accelerate/Accelerate.h>

static ContextInfo sDefaultContextInfo[sun_java2d_OSXOffScreenSurfaceData_TYPE_3BYTE_RGB+1] =

{

    {YES,    YES,    8,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_CUSTOM            // special case

    {YES,    YES,    8,        4,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,        NULL},    // TYPE_INT_RGB

    {YES,    YES,    8,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_INT_ARGB

    {YES,    YES,    8,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_INT_ARGB_PRE

    {YES,    YES,    8,        4,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,        NULL},    // TYPE_INT_BGR

    {YES,    NO,        8,        4,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,        NULL},    // TYPE_3BYTE_BGR        // use the default ARGB_PRE context synce we have to sync by hand anyway

    {YES,    YES,    8,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_4BYTE_ABGR

    {YES,    YES,    8,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_4BYTE_ABGR_PRE

#ifdef __LITTLE_ENDIAN__

    {YES,    YES,    5,        2,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder16Host,        NULL},    // TYPE_USHORT_565_RGB

    {YES,    YES,    5,        2,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder16Host,        NULL},    // TYPE_USHORT_555_RGB

#else

    {YES,    YES,    5,        2,        0,        kCGImageAlphaNoneSkipFirst,                                    NULL},    // TYPE_USHORT_565_RGB

    {YES,    YES,    5,        2,        0,        kCGImageAlphaNoneSkipFirst,                                    NULL},    // TYPE_USHORT_555_RGB

#endif

    {YES,    YES,    8,        1,        0,        kCGImageAlphaNone,                                            NULL},    // TYPE_BYTE_GRAY

    {YES,    NO,        8,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_USHORT_GRAY        // use the default ARGB_PRE context synce we have to sync by hand anyway

    {NO,    NO,        8,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_BYTE_BINARY        mapped to TYPE_CUSTOM

    {YES,    NO,        8,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_BYTE_INDEXED    // use the default ARGB_PRE context synce we have to sync by hand anyway

    {YES,    NO,        8,        4,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,        NULL},    // TYPE_3BYTE_RGB

};

static ImageInfo sDefaultImageInfo[sun_java2d_OSXOffScreenSurfaceData_TYPE_3BYTE_RGB+1] =

{

    {8,        32,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_CUSTOM

    {8,        32,        4,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,        NULL},    // TYPE_INT_RGB

    {8,        32,        4,        0,        kCGImageAlphaFirst | kCGBitmapByteOrder32Host,                NULL},    // TYPE_INT_ARGB

    {8,        32,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_INT_ARGB_PRE

    {8,        32,        4,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,        NULL},    // TYPE_INT_BGR

    {8,        32,        4,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,        NULL},    // TYPE_3BYTE_BGR

    {8,        32,        4,        0,        kCGImageAlphaFirst | kCGBitmapByteOrder32Host,                NULL},    // TYPE_4BYTE_ABGR

    {8,        32,        4,        0,        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,    NULL},    // TYPE_4BYTE_ABGR_PRE

#ifdef __LITTLE_ENDIAN__

    {5,        16,        2,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder16Host,        NULL},    // TYPE_USHORT_565_RGB

    {5,        16,        2,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder16Host,        NULL},    // TYPE_USHORT_555_RGB

#else

    {5,        16,        2,        0,        kCGImageAlphaNoneSkipFirst,                                    NULL},    // TYPE_USHORT_565_RGB

    {5,        16,        2,        0,        kCGImageAlphaNoneSkipFirst,                                    NULL},    // TYPE_USHORT_555_RGB

#endif

    {8,        8,        1,        0,        kCGImageAlphaNone,                                            NULL},    // TYPE_BYTE_GRAY

    {16,    16,        2,        0,        kCGImageAlphaNone | kCGBitmapByteOrder16Host,                NULL},    // TYPE_USHORT_GRAY

    {0,        0,        0,        0,        -1,                                                            NULL},    // TYPE_BYTE_BINARY        mapped to TYPE_CUSTOM

    {8,        32,        4,        0,        kCGImageAlphaFirst | kCGBitmapByteOrder32Host,                NULL},    // TYPE_BYTE_INDEXED  // Fully OPAQUE INDEXED images will use kCGImageAlphaNoneSkipFirst for performance reasosn. see <rdar://4224874>

    {8,        32,        4,        0,        kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host,        NULL},    // TYPE_3BYTE_RGB

};

static jfieldID        rgbID;

static jfieldID        mapSizeID;

static jfieldID        CMpDataID;

static jfieldID        allGrayID;

static JNF_CLASS_CACHE(jc_OSXOffScreenSurfaceData, "sun/java2d/OSXOffScreenSurfaceData");

static JNF_MEMBER_CACHE(jm_syncFromCustom, jc_OSXOffScreenSurfaceData, "syncFromCustom", "()V");

static JNF_MEMBER_CACHE(jm_syncToCustom, jc_OSXOffScreenSurfaceData, "syncToCustom", "()V");

static JNF_CLASS_CACHE(jc_BufferedImage, "java/awt/image/BufferedImage");

static JNF_MEMBER_CACHE(jm_SurfaceData, jc_BufferedImage, "sData", "Lsun/java2d/SurfaceData;");

static JNF_CLASS_CACHE(jc_IndexColorModel, "java/awt/image/IndexColorModel");

static JNF_MEMBER_CACHE(jm_rgb, jc_IndexColorModel, "rgb", "[I");

static JNF_MEMBER_CACHE(jm_transparency, jc_IndexColorModel, "transparency", "I");

static JNF_MEMBER_CACHE(jm_transparent_index, jc_IndexColorModel, "transparent_index", "I");

CGColorSpaceRef gColorspaceRGB = NULL;

CGColorSpaceRef gColorspaceGray = NULL;

IMAGE_SURFACE_INLINE void PrintImageInfo(ImageSDOps* isdo)

{

    fprintf(stderr, "\n");

    fprintf(stderr, "PrintImageInfo:\n");

    fprintf(stderr, "\t \n");

    //fprintf(stderr, "\t magicID=%d\n", (jint)isdo->magicID);

    //fprintf(stderr, "\n");

    fprintf(stderr, "\t isdo=%p\n", isdo);

    fprintf(stderr, "\t \n");

    fprintf(stderr, "\t contextInfo:\n");

    fprintf(stderr, "\t        useWindowContextReference=%d\n", isdo->contextInfo.useWindowContextReference);

    fprintf(stderr, "\t        canUseJavaPixelsAsContext=%d\n", isdo->contextInfo.canUseJavaPixelsAsContext);

    fprintf(stderr, "\t        bitsPerComponent=%ld\n", (long)isdo->contextInfo.bitsPerComponent);

    fprintf(stderr, "\t        bytesPerPixel=%ld\n", (long)isdo->contextInfo.bytesPerPixel);

    fprintf(stderr, "\t        bytesPerRow=%ld\n", (long)isdo->contextInfo.bytesPerRow);

    fprintf(stderr, "\t        alphaInfo=%ld\n", (long)isdo->contextInfo.alphaInfo);

    fprintf(stderr, "\t \n");

    fprintf(stderr, "\t imageInfo:\n");

    fprintf(stderr, "\t        bitsPerComponent=%ld\n", (long)isdo->imageInfo.bitsPerComponent);

    fprintf(stderr, "\t        bitsPerPixel=%ld\n", (long)isdo->imageInfo.bitsPerPixel);

    fprintf(stderr, "\t        bytesPerPixel=%ld\n", (long)isdo->imageInfo.bytesPerPixel);

    fprintf(stderr, "\t        bytesPerRow=%ld\n", (long)isdo->imageInfo.bytesPerRow);

    fprintf(stderr, "\t        alphaInfo=%ld\n", (long)isdo->imageInfo.alphaInfo);

    fprintf(stderr, "\t \n");

    fprintf(stderr, "\t isSubImage=%d\n", isdo->isSubImage);

    fprintf(stderr, "\t \n");

    fprintf(stderr, "\t java info:\n");

    fprintf(stderr, "\t        array=%p\n", isdo->array);

    fprintf(stderr, "\t        offset=%d\n", (int)isdo->offset);

    fprintf(stderr, "\t        width=%d\n", (int)isdo->width);

    fprintf(stderr, "\t        height=%d\n", (int)isdo->height);

    fprintf(stderr, "\t        javaPixelBytes=%d\n", (int)isdo->javaPixelBytes);

    fprintf(stderr, "\t        javaPixelsBytesPerRow=%d\n", (int)isdo->javaPixelsBytesPerRow);

    fprintf(stderr, "\t        icm=%p\n", isdo->icm);

    fprintf(stderr, "\t        type=%d\n", (int)isdo->type);

    fprintf(stderr, "\n");

    fprintf(stderr, "\t cgRef=%p\n", isdo->qsdo.cgRef);

    fprintf(stderr, "\t nsRef=%p\n", isdo->nsRef);

    fprintf(stderr, "\n");

    fprintf(stderr, "\t pixelsLocked=%p\n", isdo->pixelsLocked);

    fprintf(stderr, "\t pixels=%p\n", isdo->pixels);

    fprintf(stderr, "\n");

    fprintf(stderr, "\t indexedColorTable=%p\n", isdo->indexedColorTable);

    fprintf(stderr, "\t lutData=%p\n", isdo->lutData);

    fprintf(stderr, "\t lutDataSize=%u\n", (unsigned)isdo->lutDataSize);

    fprintf(stderr, "\n");

    fprintf(stderr, "\t nrOfPixelsOwners=%u\n", (unsigned)isdo->nrOfPixelsOwners);

    fprintf(stderr, "\n");

}

// if there is no image created for isdo.imgRef, it creates and image using the isdo.dataProvider

// If there is an image present, this is a no-op

void makeSureImageIsCreated(ImageSDOps* isdo)

{

    if (isdo->imgRef == NULL)  // create the image

    {

        isdo->imgRef = CGImageCreate(isdo->width,

                                      isdo->height,

                                      isdo->contextInfo.bitsPerComponent,

                                      isdo->contextInfo.bytesPerPixel * 8,

                                      isdo->contextInfo.bytesPerRow,

                                      isdo->contextInfo.colorSpace,

                                      isdo->contextInfo.alphaInfo,

                                      isdo->dataProvider,

                                      NULL,

                                      NO,

                                      kCGRenderingIntentDefault);

    }

}

IMAGE_SURFACE_INLINE void customPixelsFromJava(JNIEnv *env, ImageSDOps *isdo)

{

PRINT("    customPixelsFromJava")

    SurfaceDataOps *sdo = (SurfaceDataOps*)isdo;

    JNFCallVoidMethod(env, sdo->sdObject, jm_syncFromCustom); // AWT_THREADING Safe (known object)

}

IMAGE_SURFACE_INLINE void copyBits(jint w, jint h, jint javaPixelsBytesPerRow, Pixel8bit *pixelsSrc, jint dstPixelsBytesPerRow, Pixel8bit *pixelsDst)

{

PRINT("    copyBits")

    if (javaPixelsBytesPerRow == dstPixelsBytesPerRow)

    {

        memcpy(pixelsDst, pixelsSrc, h*javaPixelsBytesPerRow);

    }

    else

    {

        register jint y;

        for (y=0; y<h; y++)

        {

            memcpy(pixelsDst, pixelsSrc, dstPixelsBytesPerRow);

            pixelsSrc += javaPixelsBytesPerRow;

            pixelsDst += dstPixelsBytesPerRow;

        }

    }

}

IMAGE_SURFACE_INLINE void copySwapRandB_32bit_TYPE_4BYTE(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc, Pixel32bit *pixelsDst, size_t extraBytesPerRow)

{

PRINT("    copySwapRandB_32bit_TYPE_4BYTE")

    register Pixel8bit *p8Bit = NULL;

    register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units

    register Pixel32bit pixel, red, blue;

    register jint x, y;

    for (y=0; y<h; y++)

    {

        for (x=0; x<w; x++)

        {

            pixel = *pixelsSrc++;

#ifdef __LITTLE_ENDIAN__

            pixel = CFSwapInt32BigToHost(pixel);   // the jint is in big endian format, we need to swap the bits

#endif

            red        = (pixel & 0x00ff0000) >> 16; // get original red and shift to new position

            blue    = (pixel & 0x000000ff) << 16; // get original blue and shift to new position

            pixel    = (pixel & 0xff00ff00); // erase original red&blue

            pixel    = pixel | red | blue; // construct new pixel

            *pixelsDst++ = pixel;

        }

        pixelsSrc += skip;

        p8Bit = (Pixel8bit *) pixelsDst;

        p8Bit += extraBytesPerRow;

        pixelsDst = (Pixel32bit *) p8Bit;

    }

}

IMAGE_SURFACE_INLINE void copySwapRandB_32bit_TYPE_INT(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc, Pixel32bit *pixelsDst, size_t extraBytesPerRow)

{

PRINT("    copySwapRandB_32bit_TYPE_INT")

    register Pixel8bit *p8Bit = NULL;

    register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units

    register Pixel32bit pixel, red, blue;

    register jint x, y;

    for (y=0; y<h; y++)

    {

        for (x=0; x<w; x++)

        {

            pixel = *pixelsSrc++;

            red        = (pixel & 0x00ff0000) >> 16; // get original red and shift to new position

            blue    = (pixel & 0x000000ff) << 16; // get original blue and shift to new position

            pixel    = (pixel & 0xff00ff00); // erase original red&blue

            pixel    = pixel | red | blue; // construct new pixel

            *pixelsDst++ = pixel;

        }

        pixelsSrc += skip;

        p8Bit = (Pixel8bit *) pixelsDst;

        p8Bit += extraBytesPerRow;

        pixelsDst = (Pixel32bit *) p8Bit;

    }

}

IMAGE_SURFACE_INLINE void copyBGR_24bitToXRGB_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsSrc, Pixel32bit *pixelsDst, size_t extraBytesPerRow)

{

PRINT("    copyBGR_24bitToXRGB_32bit")

    register Pixel8bit *p8Bit = NULL;

    register jint skip = ((javaPixelsBytesPerRow/javaPixelBytes)-w)*javaPixelBytes; // in pixelsSrc units

    register Pixel32bit red, green, blue, pixel;

    register jint x, y;

    for (y=0; y<h; y++)

    {

        for (x=0; x<w; x++)

        {

            pixel        = *pixelsSrc++;

            blue        = pixel << 0;

            pixel        = *pixelsSrc++;

            green        = pixel << 8;

            pixel        = *pixelsSrc++;

            red            = pixel << 16;

            *pixelsDst    = red | green | blue;

            *pixelsDst = 0xff000000 | *pixelsDst;

            pixelsDst++;

        }

        pixelsSrc += skip;

        p8Bit = (Pixel8bit *) pixelsDst;

        p8Bit += extraBytesPerRow;

        pixelsDst = (Pixel32bit *) p8Bit;

    }

}

IMAGE_SURFACE_INLINE void copyRGB_24bitToXRGB_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsSrc, Pixel32bit *pixelsDst, size_t extraBytesPerRow)

{

PRINT("    copyRGB_24bitToXRGB_32bit")

    register Pixel8bit *p8Bit = NULL;

    register jint skip = ((javaPixelsBytesPerRow/javaPixelBytes)-w)*javaPixelBytes; // in pixelsSrc units

    register Pixel32bit red, green, blue, pixel;

    register jint x, y;

    for (y=0; y<h; y++)

    {

        for (x=0; x<w; x++)

        {

            pixel        = *pixelsSrc++;

            red            = pixel << 16;

            pixel        = *pixelsSrc++;

            green        = pixel << 8;

            pixel        = *pixelsSrc++;

            blue        = pixel << 0;

            *pixelsDst    = red | green | blue;

            *pixelsDst = 0xff000000 | *pixelsDst;

            pixelsDst++;

        }

        pixelsSrc += skip;

        p8Bit = (Pixel8bit *) pixelsDst;

        p8Bit += extraBytesPerRow;

        pixelsDst = (Pixel32bit *) p8Bit;

    }

}

IMAGE_SURFACE_INLINE void copyIndexed_8bitToARGB_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsSrc,

                                                        Pixel32bit* lutdata, Pixel32bit *pixelsDst, size_t extraBytesPerRow)

{

PRINT("    copyIndexed_8bitToARGB_32bit")

    //gznote: how is the performance if the extraBytesPerRow != 0 ?

    const vImage_Buffer src = {pixelsSrc, h, w, javaPixelsBytesPerRow};

    const vImage_Buffer dest = {pixelsDst, h, w, w*sizeof(Pixel32bit)+extraBytesPerRow};

    vImage_Error err = vImageLookupTable_Planar8toPlanarF(&src, &dest, (Pixel_F*)lutdata, kvImageDoNotTile);

    if (err != kvImageNoError)

    {

        fprintf(stderr, "Error in copyIndexed_8bitToARGB_32bit: vImageLookupTable_Planar8toPlanarF returns %ld\n", (long)err);

        register Pixel8bit *p8Bit = NULL;

        register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units

        register jint x, y;

        for (y=0; y<h; y++)

        {

            for (x=0; x<w; x++)

            {

                *pixelsDst++ = lutdata[*pixelsSrc++];        // case 1

                //*pixelsDst++ = *(lutdata + *pixelsSrc++);    // case 2: at best ~1% better than case 1

            }

            pixelsSrc += skip;

            p8Bit = (Pixel8bit *) pixelsDst;

            p8Bit += extraBytesPerRow;

            pixelsDst = (Pixel32bit *) p8Bit;

        }

    }

}

IMAGE_SURFACE_INLINE void copy565_16bitTo555_16bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel16bit *pixelsSrc, Pixel16bit *pixelsDst, size_t extraBytesPerRow)

{

PRINT("    copy565_16bitTo555_16bit")

    register Pixel8bit *p8Bit = NULL;

    register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units

    register jint green;

    register Pixel16bit pixel;

    register jint x, y;

    for (y=0; y<h; y++)

    {

        for (x=0; x<w; x++)

        {

            pixel = *pixelsSrc++;

            green = ((pixel >> 5) & 63);  // rrrrrggggggbbbbb => shift 5 right = 00000rrrrrgggggg => and 63 = 0000000000gggggg

            green = ((jint) (((CGFloat) green / 63.0f) * 31.0f)) & 31; // first normalize to value between 0 and 1 and then un-normalize to 5 bit (31 = 0000000000011111)

            *pixelsDst++ = ((pixel&0xf800)>>1) | (green << 5) | (pixel&0x01f);

        }

        pixelsSrc += skip;

        p8Bit = (Pixel8bit *) pixelsDst;

        p8Bit += extraBytesPerRow;

        pixelsDst = (Pixel16bit *) p8Bit;

    }

}

IMAGE_SURFACE_INLINE void customPixelsToJava(JNIEnv *env, ImageSDOps *isdo)

{

PRINT("    customPixelsToJava")

    SurfaceDataOps *sdo = (SurfaceDataOps*)isdo;

    JNFCallVoidMethod(env, sdo->sdObject, jm_syncToCustom); // AWT_THREADING Safe (known object)

}

IMAGE_SURFACE_INLINE void removeAlphaPre_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc)

{

PRINT("    removeAlphaPre_32bit")

    register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units

    register Pixel32bit pixel, alpha, red, green, blue;

    register jint x, y;

    for (y=0; y<h; y++)

    {

        for (x=0; x<w; x++)

        {

            pixel = *pixelsSrc;

            alpha        = (pixel >> 24) & 0xff;

            if (alpha != 0)

            {

                // get color components

                red            = (pixel >> 16) & 0xff;

                green        = (pixel >> 8) & 0xff;

                blue        = (pixel >> 0) & 0xff;

                // remove alpha pre

                red            = ((red * 0xff) + 0x7f) / alpha;

                green        = ((green * 0xff) + 0x7f) / alpha;

                blue        = ((blue * 0xff) + 0x7f) / alpha;

                // clamp

                red            = (red <= 0xff) ? red : 0xff;

                green        = (green <= 0xff) ? green : 0xff;

                blue        = (blue <= 0xff) ? blue : 0xff;

                *pixelsSrc++ = (alpha<<24) | (red<<16) | (green<<8) | blue; // construct new pixel

            }

            else

            {

                *pixelsSrc++ = 0;

            }

        }

        pixelsSrc += skip;

    }

}

IMAGE_SURFACE_INLINE void swapRandBAndRemoveAlphaPre_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc)

{

PRINT("    swapRandBAndRemoveAlphaPre_32bit")

    register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units

    register Pixel32bit pixel, alpha, red, green, blue;

    register jint x, y;

    for (y=0; y<h; y++)

    {

        for (x=0; x<w; x++)

        {

            pixel = *pixelsSrc;

            alpha        = (pixel & 0xff000000) >> 24;

            if (alpha != 0)

            {

                // get color components

                red            = (pixel & 0x00ff0000) >> 16;

                green        = (pixel & 0x0000ff00) >> 8;

                blue        = (pixel & 0x000000ff) >> 0;

                // remove alpha pre

                red            = ((red * 0xff) + 0x7f) / alpha;

                green        = ((green * 0xff) + 0x7f) / alpha;

                blue        = ((blue * 0xff) + 0x7f) / alpha;

                // clamp

                red            = (red <= 0xff) ? red : 0xff;

                green        = (green <= 0xff) ? green : 0xff;

                blue        = (blue <= 0xff) ? blue : 0xff;

                pixel = (alpha<<24) | (blue<<16) | (green<<8) | red; // construct new pixel

#ifdef __LITTLE_ENDIAN__

                pixel = CFSwapInt32HostToBig(pixel);  // the jint is little endian, we need to swap the bits before we send it back to Java

#endif

                *pixelsSrc++ = pixel;

            }

            else

            {

                *pixelsSrc++ = 0;

            }

        }

        pixelsSrc += skip;

    }

}

IMAGE_SURFACE_INLINE void swapRandB_32bit_TYPE_INT(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc)

{

PRINT("    swapRandB_32bit_TYPE_INT")