/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "javax_microedition_m3g_Image2D.h"

JNIEXPORT void JNICALL Java_javax_microedition_m3g_Image2D__1set

(JNIEnv* aEnv, jclass, jint aHImage2D, jint aX, jint aY, jint aWidth, jint aHeight, jbyteArray aImageArray)

{

    jbyte* imageArray = NULL;

    if (aImageArray)

    {

        imageArray = aEnv->GetByteArrayElements(aImageArray, NULL);

        if (imageArray == NULL)

        {

            M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");

            return;

        }

    }

    M3G_DO_LOCK

    m3gSetSubImage((M3GImage)aHImage2D, aX, aY, aWidth, aHeight, aImageArray ? aEnv->GetArrayLength(aImageArray) : NULL, imageArray);

    M3G_DO_UNLOCK(aEnv)

    if (imageArray)

    {

        aEnv->ReleaseByteArrayElements(aImageArray, imageArray, JNI_ABORT);

    }

}

static void getImageScanline(const ImageStruct *pImg,

                             M3Gint line,

                             M3Guint *pixels,

                             M3Gbool *trueAlpha)

{

    const CFbsBitmap *bitmap = pImg->color;

    const int width = bitmap->SizeInPixels().iWidth;

    int count = width;

    M3G_ASSERT(count >= 0);

    M3Guint *dst = pixels;

    TDisplayMode mode = bitmap->DisplayMode();

    int stride = bitmap->ScanLineLength(count, mode);

    bitmap->LockHeap();

    const void *srcAddr = ((const char *) bitmap->DataAddress()) + line * stride;

    const CFbsBitmap *mask = pImg->mask;

    // Alpha data is stored in a separate bitmap if present, so first

    // just copy the RGB image data with a default full alpha

    if (mode == EColor16MU || mode == EColor16MA)

    {

        const unsigned char *src = (const unsigned char *) srcAddr;

        while (count--)

        {

            M3Guint argb;

            argb  = (M3Guint)(*src++);  // red -- "src" is a _byte_ pointer to the FbsBitmap's DataAddress

            argb |= ((M3Guint)(*src++)) <<  8;  // green

            argb |= ((M3Guint)(*src++)) << 16;      // blue

            if (mask)

            {

                // if separate alpha bitmap is present, set full alpha and alpha informations

                // will be copied in second pass

                argb |= 0xFF000000L;    // alpha

            }

            else

            {

                // if separate alpha is NULL alpha information must be copied from alpha channel

                // of source bitmap to alpha channel of target bitmap

                argb |= ((M3Guint)(*src)) << 24;    // alpha

            }

            src++;

            *dst++ = argb;

        }

    }

    else if (mode == EColor64K)

    {

        const unsigned short *src = (const unsigned short *) srcAddr;

        while (count--)

        {

            unsigned short pixel = *src++;

            *dst++ = 0xFF000000L

                     | (((pixel & 0x001F) >> 2) | ((pixel & 0x001F) << 3))

                     | (((pixel & 0x0600) >> 1) | ((pixel & 0x07E0) << 5))

                     | (((pixel & 0xE000) << 3) | ((pixel & 0xF800) << 8));

        }

    }

    else if (mode == EColor4K)

    {

        const unsigned short *src = (const unsigned short *) srcAddr;

        while (count--)

        {

            unsigned short pixel = *src++;

            *dst++ = 0xFF000000L

                     | ((pixel & 0x000F) | ((pixel & 0x000F) << 4))

                     | (((pixel & 0x00F0) | ((pixel & 0x00F0) << 4)) << 4)

                     | (((pixel & 0x0F00) | ((pixel & 0x0F00) << 4)) << 8);

        }

    }

    else

    {

        M3G_ASSERT(M3G_FALSE);

    }

    bitmap->UnlockHeap();

    // Check for the presence of an alpha mask, and if present, do a

    // second pass to mix that into the RGB values already copied

    *trueAlpha = (mask != NULL);

    if (mask)

    {

        mask->LockHeap();

        // NOTE: we assume that if the alpha mask is using an RGBA

        // display mode as the base bitmap, the alpha value is stored

        // in the red color channel of the mask only.

        //

        dst = pixels;

        count = width;

        mode = mask->DisplayMode();

        stride = mask->ScanLineLength(mask->SizeInPixels().iWidth, mode);

        srcAddr = ((const char *) mask->DataAddress()) + line * stride;

        if (mode == EColor16MU || mode == EColor16MA)

        {

            const unsigned long *src = (const unsigned long *) srcAddr;

            while (count--)

            {

                unsigned short mask = *src++;

                *dst++ = (*dst & 0x00FFFFFF) | ((mask & 0x00FF) << 24);

            }

        }

        else if (mode == EColor64K)

        {

            const unsigned short *src = (const unsigned short *) srcAddr;

            while (count--)

            {

                unsigned short mask = *src++;

                *dst++ = (*dst & 0x00FFFFFF) |

                         ((((mask & 0x001F) >> 2) | ((mask & 0x001F) << 3)) << 24);

            }

        }

        else if (mode == EColor4K)

        {

            const unsigned short *src = (const unsigned short *) srcAddr;

            while (count--)

            {

                unsigned short mask = *src++;

                *dst++ = (*dst & 0x00FFFFFF) | (((mask & 0x000F) | ((mask & 0x000F) << 4)) << 24);

            }

        }

        else if (mode == EGray256)

        {

            const unsigned char *src = (const unsigned char *) srcAddr;

            while (count--)

            {

                *dst++ = (*dst & 0x00FFFFFF) | ((*src++) << 24);

            }

        }

        else if (mode == EGray2)

        {

            // Initialize src as byte type

            const unsigned char *src = (const unsigned char *) srcAddr;

            /* Go through each pixel in the stride one by one.

            /  Each src (EGray2 type bitmap) byte holds 8 pixels aplha mask, i.e 1 Bpp,

            /  so check each bit in the byte and set aplha for the dst bitmap either to 0xFF

            /  or to 0x00 depending source bit values 1/0.

            */

            /* Counter for the bits in one byte, i.e. 0-7 */

            int bit = 0;

            /* count = number of pixels in one stride */

            while (count)

            {

                while (bit < 8)

                {

                    *dst++ = (*dst & 0x00FFFFFF) | (((*src) & 0x01 << bit) ? 0xFF << 24 : 0x0);

                    bit++;

                    count--;

                    /* If we have processed all pixels in the image scanline,

                    /  exit and discard rest of the bits in the byte.

                    */

                    if (count <= 0) break;

                }

                /* reset bit counter as we move on to the next byte */

                bit = 0;

                *src++;

            }

        }

        else

        {

            M3G_ASSERT(M3G_FALSE);

        }

        mask->UnlockHeap();

    }

}

static void createImage(M3GInterface m3g,

                        M3GImage *img,

                        M3GImageFormat format,

                        ImageStruct *pImage)

{

    M3GImage image;

    TSize sz = pImage->color->SizeInPixels();

    M3Gint width = sz.iWidth, height = sz.iHeight;

    image = m3gCreateImage(m3g, format, width, height, 0);

    if (image == NULL)

    {

        img = NULL;

        return;    // exception automatically raised

    }

    {

        M3Gint y;

        //M3Guint *tempPixels = (M3Guint *) User::Alloc(width * 4);

        M3Guint *tempPixels = (M3Guint *) malloc(width * 4);

        if (tempPixels == NULL)

        {

            m3gDeleteObject((M3GObject) image);

            *img = NULL;

            return;

        }

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

        {

            M3Gbool trueAlpha;

            getImageScanline(pImage, y, tempPixels, &trueAlpha);

            m3gSetImageScanline(image, y, trueAlpha, tempPixels);

        }

        m3gCommitImage(image);

        //User::Free(tempPixels);

        free(tempPixels);

        *img = image;

    }

}

JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Image2D__1ctorImage

(JNIEnv* aEnv, jclass, jint aEventSourceHandle, jint aHM3g, jint aFormat, jint aImageHandle)

{

    if (aImageHandle != NULL)

    {

        ImageStruct imageStruct;

        MMIDImage* image = JavaUnhand<MMIDImage>(aImageHandle);

        MMIDBitmapImage* bitmapImage = image->BitmapImage();

        if (!bitmapImage)

        {

            return NULL;

        }

        imageStruct.color = bitmapImage->ColorBitmap();

        imageStruct.mask = bitmapImage->AlphaBitmap();

        bitmapImage->RemoveRef();

        CJavaM3GEventSource* eventSource = JavaUnhand<CJavaM3GEventSource>(aEventSourceHandle);

        M3GInterface m3g = (M3GInterface)aHM3g;

        M3GImage img;

        M3G_DO_LOCK

        eventSource->ExecuteV(&createImage,

                              m3g, &img, (M3GImageFormat) aFormat, &imageStruct);

        M3G_DO_UNLOCK(aEnv)

        return (jint)img;

    }

    return 0;

}

JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Image2D__1getFormat

(JNIEnv* aEnv, jclass, jint aHImage2D)

{

    M3G_DO_LOCK

    jint format = (jint)m3gGetFormat((M3GImage)aHImage2D);

    M3G_DO_UNLOCK(aEnv)

    return format;

}

JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Image2D__1ctorSizePixelsPalette

(JNIEnv* aEnv, jclass, jint aM3g, jint aFormat, jint aWidth, jint aHeight, jbyteArray aImage, jbyteArray aPalette)

{

    M3GImageFormat format = (M3GImageFormat)aFormat;

    int bpp = jsr184BytesPerPixel(format);

    if (validateArray(aEnv, aImage, aWidth * aHeight))

    {

        if (aPalette == NULL)

        {

            M3G_RAISE_EXCEPTION(aEnv, "java/lang/NullPointerException");

            return 0;

        }

        int paletteLen = aEnv->GetArrayLength(aPalette);

        if ((paletteLen < 256 *(unsigned)bpp) &&

                (paletteLen % (unsigned)bpp != 0))

        {

            M3G_RAISE_EXCEPTION(aEnv, "java/lang/IllegalArgumentException");

            return 0;

        }

        else

        {

            M3G_DO_LOCK

            M3GImage hImg = m3gCreateImage((M3GInterface)aM3g,

                                           format,

                                           aWidth, aHeight,

                                           M3G_PALETTED);

            if (hImg != NULL)

            {

                jbyte* palette = NULL;

                int numEntries = paletteLen / bpp;

                if (numEntries > 256)

                {

                    numEntries = 256;

                }

                jbyte* image = aEnv->GetByteArrayElements(aImage, NULL);

                if (image == NULL)

                {

                    M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");

                    return 0;

                }

                m3gSetImage(hImg, image);

                palette = aEnv->GetByteArrayElements(aPalette, NULL);

                if (palette == NULL)

                {

                    if (image)

                    {

                        aEnv->ReleaseByteArrayElements(aImage, image, JNI_ABORT);

                    }

                    M3G_RAISE_EXCEPTION(aEnv, "java/lang/OutOfMemoryError");

                    return 0;

                }

                m3gSetImagePalette(hImg, numEntries, palette);

                m3gCommitImage(hImg);

                if (image)

                {

                    aEnv->ReleaseByteArrayElements(aImage, image, JNI_ABORT);

                }

                if (palette)

                {

                    aEnv->ReleaseByteArrayElements(aPalette, palette, JNI_ABORT);

                }

            }

            M3G_DO_UNLOCK(aEnv)

            return ((unsigned) hImg);

        }

    }

    return 0;

}

JNIEXPORT jboolean JNICALL Java_javax_microedition_m3g_Image2D__1isMutable

(JNIEnv* aEnv, jclass, jint aHImage2D)

{

    M3G_DO_LOCK

    jboolean isMutable = (jboolean)m3gIsMutable((M3GImage)aHImage2D);

    M3G_DO_UNLOCK(aEnv)

    return isMutable;

}

JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Image2D__1getHeight

(JNIEnv* aEnv, jclass, jint aHImage2D)

{

    M3G_DO_LOCK

    jint height = (jint)m3gGetHeight((M3GImage)aHImage2D);

    M3G_DO_UNLOCK(aEnv)

    return height;

}

JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Image2D__1ctorSize

(JNIEnv* aEnv, jclass, jint aM3g, jint aFormat, jint aWidth, jint aHeight)

{

    M3G_DO_LOCK

    jint handle = (M3Guint) m3gCreateImage((M3GInterface)aM3g,

                                           (M3GImageFormat)aFormat,

                                           aWidth, aHeight,

                                           M3G_DYNAMIC|M3G_RENDERING_TARGET);

    M3G_DO_UNLOCK(aEnv)

    return handle;

}

JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Image2D__1getWidth

(JNIEnv* aEnv, jclass, jint aHImage2D)

{

    M3G_DO_LOCK

    jint width = (jint)m3gGetWidth((M3GImage)aHImage2D);

    M3G_DO_UNLOCK(aEnv)

    return width;

}

JNIEXPORT jint JNICALL Java_javax_microedition_m3g_Image2D__1ctorSizePixels

(JNIEnv* aEnv, jclass, jint aM3g, jint aFormat, jint aWidth, jint aHeight, jbyteArray aImage)

{

    M3GImageFormat format = (M3GImageFormat)aFormat;

    if (validateArray(aEnv, aImage, jsr184BytesPerPixel(format) * aWidth * aHeight))

    {

        M3G_DO_LOCK

        M3GImage hImg = m3gCreateImage((M3GInterface)aM3g, format, aWidth, aHeight, 0);

        if (hImg != NULL)

        {

            M3GImageFormat format = (M3GImageFormat)aFormat;

            int bpp = jsr184BytesPerPixel(format);

            jbyte* imageScanline = (jbyte*)malloc(aWidth * bpp);

            for (int i=0; i < aHeight; i++)

            {

                aEnv->GetByteArrayRegion(aImage, aWidth * i * bpp, aWidth * bpp, imageScanline);

                m3gSetSubImage(hImg, 0, i, aWidth, 1, aWidth * bpp, imageScanline);

            }

            m3gCommitImage(hImg);

            free(imageScanline);

        }

        M3G_DO_UNLOCK(aEnv)

        return (unsigned) hImg;

    }

    return 0;

}