/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: Image implementation

*

*/

/*!

 * \internal

 * \file

 * \brief Image implementation

 *

 */

#ifndef M3G_CORE_INCLUDE

#   error included by m3g_core.c; do not compile separately.

#endif

#include "m3g_image.h"

#include "m3g_texture.h"

/* Declare prototypes for some of the helper functions called from the

 * platform-dependent code included below */

static M3Gint  m3gBytesPerPixel(M3GPixelFormat format);

static M3Gint  m3gGetNumMipmapLevels(M3Gint w, M3Gint h);

static void m3gDownsample(M3GPixelFormat format, const M3Gubyte *srcPixels, M3Gint *pw, M3Gint *ph, M3Gubyte *dstPixels);

static void m3gFreeImageData(Image *img);

/* Include platform-dependent functionality */

#include "m3g_image.inl"

/* Size of the buffer used in pixel format conversions; this should be

 * an even number */

#define SPAN_BUFFER_SIZE 32

M3G_CT_ASSERT((SPAN_BUFFER_SIZE & 1) == 0);

/*----------------------------------------------------------------------

 * Private functions

 *--------------------------------------------------------------------*/

/*!

 * \internal

 * \brief Destroys this Image object.

 *

 * \param obj Image object

 */

static void m3gDestroyImage(Object *obj)

{

    Image *image = (Image*)obj;

    Interface *m3g = M3G_INTERFACE(image);

    M3G_VALIDATE_OBJECT(image);

    if (!image->copyOf) {

        m3gFreeObject(m3g, image->data);

        m3gFreeObject(m3g, image->mipData);

    }

    M3G_ASSIGN_REF(image->copyOf, NULL);

    if (image->powerOfTwo != image) {

        M3G_ASSIGN_REF(image->powerOfTwo, NULL);

    }

#   if !defined(M3G_NGL_TEXTURE_API)

    if (image->texObject) {

        m3gDeleteGLTextures(m3g, 1, &image->texObject);

    }

    if (image->large != NULL) {

        m3gDestroyLargeImage(image);

    }

#   endif

    m3gDestroyObject(obj);

}

/*--------------------------------------------------------------------*/

#define RED(argb)   (((argb) >> 16) & 0xFFu)

#define GREEN(argb) (((argb) >>  8) & 0xFFu)

#define BLUE(argb)  ( (argb)        & 0xFFu)

#define ALPHA(argb) (((argb) >> 24) & 0xFFu)

#define RGBSUM(argb) (0x4CB2u * RED(argb) +     \

                      0x9691u * GREEN(argb) +   \

                      0x1D3Eu * BLUE(argb))

/*!

 * \internal \brief ARGB -> A

 */

static void convertARGBToA8(const M3Guint *src, M3Gsizei count, M3Gubyte *dst)

{

    while (count--) {

        *dst++ = (M3Gubyte) ALPHA(*src++);

    }

}

/*!

 * \internal \brief ARGB -> L

 */

static void convertARGBToL8(const M3Guint *src, M3Gsizei count, M3Gubyte *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        M3Guint sum = RGBSUM(argb);

        *dst++ = (M3Gubyte)(sum >> 16);

    }

}

/*!

 * \internal \brief ARGB -> LA */

static void convertARGBToLA4(const M3Guint *src, M3Gsizei count, M3Gubyte *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        M3Guint sum = RGBSUM(argb);

        *dst++ = (M3Gubyte)(((sum >> 16) & 0xF0) | ((argb >> 28) & 0x0F));

    }

}

/*!

 * \internal \brief ARGB -> LA8

 */

static void convertARGBToLA8(const M3Guint *src, M3Gsizei count, M3Gubyte *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        M3Guint sum = RGBSUM(argb);

        *dst++ = (M3Gubyte)(sum >> 16);       /* L */

        *dst++ = (M3Gubyte) ALPHA(argb);

    }

}

/*!

 * \internal \brief ARGB -> RGB

 */

static void convertARGBToRGB8(const M3Guint *src, M3Gsizei count, M3Gubyte *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        *dst++ = (M3Gubyte) RED(argb);

        *dst++ = (M3Gubyte) GREEN(argb);

        *dst++ = (M3Gubyte) BLUE(argb);

    }

}

/*!

 * \internal \brief ARGB -> RGB565

 */

static void convertARGBToRGB565(const M3Guint *src, M3Gsizei count, M3Gubyte *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        *(M3Gushort*)dst = (M3Gushort)(((argb >> 8) & 0xF800u)|

                                       ((argb >> 5) & 0x07E0u)|

                                       ((argb >> 3) & 0x001Fu));

        dst += 2;

    }

}

/*!

 * \internal \brief ARGB -> RGBA

 */

static void convertARGBToRGBA8(const M3Guint *src, M3Gsizei count, M3Gubyte *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        *dst++ = (M3Gubyte) RED(argb);

        *dst++ = (M3Gubyte) GREEN(argb);

        *dst++ = (M3Gubyte) BLUE(argb);

        *dst++ = (M3Gubyte) ALPHA(argb);

    }

}

/*!

 * \internal \brief ARGB -> BGRA

 */

static void convertARGBToBGRA8(const M3Guint *src, M3Gsizei count, M3Gubyte *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        *dst++ = (M3Gubyte) BLUE(argb);

        *dst++ = (M3Gubyte) GREEN(argb);

        *dst++ = (M3Gubyte) RED(argb);

        *dst++ = (M3Gubyte) ALPHA(argb);

    }

}

#undef RED

#undef GREEN

#undef BLUE

#undef ALPHA

/*!

 * \internal

 * \brief Converts a span of ARGB pixels to another format

 *

 * \param src   source pixels

 * \param count pixel count

 * \param dstFormat destination format

 * \param dst destination pixels

 */

static void convertFromARGB(const M3Guint *src,

                            M3Gsizei count,

                            M3GPixelFormat dstFormat,

                            M3Gubyte *dst)

{

    switch (dstFormat) {

    case M3G_L8:

        convertARGBToL8(src, count, dst);

        break;

    case M3G_A8:

        convertARGBToA8(src, count, dst);

        break;

    case M3G_LA4:

        convertARGBToLA4(src, count, dst);

        break;

    case M3G_LA8:

        convertARGBToLA8(src, count, dst);

        break;

    case M3G_RGB8:

        convertARGBToRGB8(src, count, dst);

        break;

    case M3G_RGB565:

        convertARGBToRGB565(src, count, dst);

        break;

    case M3G_RGBA8:

    case M3G_RGB8_32:

        convertARGBToRGBA8(src, count, dst);

        break;

    case M3G_BGRA8:

    case M3G_BGR8_32:

        convertARGBToBGRA8(src, count, dst);

        break;

    default:

        M3G_ASSERT(M3G_FALSE);  /* conversion not supported */

    }

}

/*--------------------------------------------------------------------*/

/*!

 * \internal \brief A8 -> ARGB

 */

static void convertA8ToARGB(const M3Gubyte *src, M3Gsizei count, M3Guint *dst)

{

    while (count--) {

        M3Guint argb = M3G_RGB_MASK;

        argb |= ((M3Guint) *src++) << 24;

        *dst++ = argb;

    }

}

/*!

 * \internal \brief L8 -> ARGB

 */

static void convertL8ToARGB(const M3Gubyte *src, M3Gsizei count, M3Guint *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        argb |= (argb << 8) | (argb << 16);

        argb |= M3G_ALPHA_MASK;

        *dst++ = argb;

    }

}

/*!

 * \internal \brief LA8 -> ARGB

 */

static void convertLA8ToARGB(const M3Gubyte *src, M3Gsizei count, M3Guint *dst)

{

    while (count--) {

        M3Guint argb = *src++;

        argb |= (argb << 8) | (argb << 16);

        argb |= ((M3Guint) *src++) << 24;

        *dst++ = argb;

    }

}

/*!

 * \internal \brief RGB8 -> ARGB

 */

static void convertRGB8ToARGB(const M3Gubyte *src, M3Gsizei count, M3Guint *dst)

{

    while (count--) {

        M3Guint argb = M3G_ALPHA_MASK;

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

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

        argb |=  (M3Guint)(*src++);

        *dst++ = argb;

    }

}

/*!

 * \internal \brief RGB565 -> ARGB

 */

static void convertRGB565ToARGB(const M3Gubyte *src, M3Gsizei count, M3Guint *dst)

{

    while (count--) {

        M3Guint argb = M3G_ALPHA_MASK;

        const M3Guint rgb565 = *(const M3Gushort*)src;

        argb |= ((rgb565 & 0xF800u) << 8)|((rgb565 & 0xE000u) << 3);

        argb |= ((rgb565 & 0x07E0u) << 5)|((rgb565 & 0x0600u) >> 1);

        argb |= ((rgb565 & 0x001Fu) << 3)|((rgb565 & 0x001Cu) >> 2);

        *dst++ = argb;

        src += 2;

    }

}

/*!

 * \internal \brief RGBA8 -> ARGB

 */

static void convertRGBA8ToARGB(const M3Gubyte *src, M3Gsizei count, M3Guint *dst)

{

    while (count--) {

        M3Guint argb;

        argb  = ((M3Guint)(*src++)) << 16;

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

        argb |=  (M3Guint)(*src++);

        argb |= ((M3Guint)(*src++)) << 24;

        *dst++ = argb;

    }

}

/*!

 * \internal \brief BGRA8 -> ARGB

 */

static void convertBGRA8ToARGB(const M3Gubyte *src, M3Gsizei count, M3Guint *dst)

{

    while (count--) {

        M3Guint argb;

        argb  =  (M3Guint)(*src++);

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

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

        argb |= ((M3Guint)(*src++)) << 24;

        *dst++ = argb;

    }

}

/*!

 * \internal

 * \brief Converts a span of pixels to ARGB

 *

 * \param srcFormat source format

 * \param src   source pixels

 * \param count pixel count

 * \param dst destination pixels

 */

static void convertToARGB(M3GPixelFormat srcFormat,

                          const M3Gubyte *src,

                          M3Gsizei count,

                          M3Guint *dst)

{

    switch (srcFormat) {

    case M3G_A8:

        convertA8ToARGB(src, count, dst);

        break;

    case M3G_L8:

        convertL8ToARGB(src, count, dst);

        break;

    case M3G_LA8:

        convertLA8ToARGB(src, count, dst);

        break;

    case M3G_RGB8:

        convertRGB8ToARGB(src, count, dst);

        break;

    case M3G_RGB565:

        convertRGB565ToARGB(src, count, dst);

        break;

    case M3G_RGBA8:

    case M3G_RGB8_32:

        convertRGBA8ToARGB(src, count, dst);

        break;

    case M3G_BGRA8:

    case M3G_BGR8_32:

        convertBGRA8ToARGB(src, count, dst);

        break;

    default:

        M3G_ASSERT(M3G_FALSE);  /* conversion not supported */

    }

}

/*!

 * \internal

 * \brief Fast path for BGRA-to-RGBA conversion

 */

#if defined (M3G_HW_ARMV6)

__asm void fastConvertBGRAToRGBA(const M3Gubyte *src, M3Gsizei srcStride,

                                 M3Gsizei width, M3Gsizei height,

                                 M3Gubyte *dst)

{

// r0 = *src

// r1 = srcStride

// r2 = width

// r3 = height

// sp[0] = *dst

		CODE32

		CMP		r3, #0				// if height = 0, do nothing

		BXEQ	lr

  		STMFD	sp!, {r4-r12, lr} 

		LDR		r12, [sp, #(10*4)]

		SUB		r1, r1, r2, LSL #2

		MOV		r14, r2

_fastConvertBGRAToRGBA_outerLoop

		MOVS	r2, r14, ASR #2			// amount of 4x32 bit writes

		BEQ		_fastConvertBGRAToRGBA_tail

_fastConvertBGRAToRGBA_innerLoop

		LDMIA	r0!, {r4-r7}		// AARRGGBB

		SUBS	r2, #1

		REV		r4, r4				// BBGGRRAA

		REV		r5, r5

		REV		r6, r6				

		REV		r7, r7

		MOV		r8, r4, ROR #8		// AABBGGRR

		MOV		r9, r5, ROR #8

		MOV		r10, r6, ROR #8		

		MOV		r11, r7, ROR #8

		STMIA	r12!, {r8-r11}

		BNE		_fastConvertBGRAToRGBA_innerLoop

_fastConvertBGRAToRGBA_tail

		MOV 	r2, r14, ASR #2

		SUBS	r2, r14, r2, LSL #2		// number of remaining writes in the tail

_fastConvertBGRAToRGBA_tail_loop

		LDRNE	r4, [r0], #4

		REVNE	r4, r4

		MOVNE	r8, r4, ROR #8

		STRNE	r8, [r12], #4

		SUBNES	r2, #1

		BNE		_fastConvertBGRAToRGBA_tail_loop

		SUBS	r3, #1

		ADD		r0, r0, r1

		BNE		_fastConvertBGRAToRGBA_outerLoop

		LDMFD	sp!, {r4-r12, lr}

		BX		lr

}

#else /* #if defined (M3G_HW_ARMV6) */

static void fastConvertBGRAToRGBA(const M3Gubyte *src, M3Gsizei srcStride,

                                  M3Gsizei width, M3Gsizei height,

                                  M3Gubyte *dst)

{

    unsigned int pixel, pixel2;

    unsigned int temp;

    unsigned int mask = 0x00ff00ff;

    int spanwidth = (width >> 1) - 1;

    int x, y;

    unsigned int *d = (unsigned int *)dst;

    M3G_ASSERT(width > 2);

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

        unsigned int *s = (unsigned int *)(src + y*srcStride);

        pixel = *s++;

        for (x = 0; x < spanwidth; ++x) {

            pixel2 = *s++;

            temp   = pixel & mask;          /* 00RR00BB */

            pixel  = pixel - temp;          /* AA00GG00 */

            pixel  = pixel | (temp << 16);  /* AABBGG00 */

            *d++   = pixel | (temp >> 16);  /* AABBGGRR */

            pixel = *s++;

            temp   = pixel2 & mask;          /* 00RR00BB */

            pixel2 = pixel2 - temp;          /* AA00GG00 */

            pixel2 = pixel2 | (temp << 16);  /* AABBGG00 */

            *d++   = pixel2 | (temp >> 16);  /* AABBGGRR */

        }

        pixel2 = *s++;

        temp   = pixel & mask;          /* 00RR00BB */

        pixel  = pixel - temp;          /* AA00GG00 */

        pixel  = pixel | (temp << 16);  /* AABBGG00 */

        *d++   = pixel | (temp >> 16);  /* AABBGGRR */

        temp   = pixel2 & mask;          /* 00RR00BB */

        pixel2 = pixel2 - temp;          /* AA00GG00 */

        pixel2 = pixel2 | (temp << 16);  /* AABBGG00 */

        *d++   = pixel2 | (temp >> 16);  /* AABBGGRR */

    }

}

#endif /* #if defined (M3G_HW_ARMV6) */

/*--------------------------------------------------------------------*/

/*!

 * \internal

 * \brief Maps a logical image format to an internal pixel format

 *

 * \param imgFormat logical image format

 * \param paletted  paletted flag

 * \return the internal image pixel format

 */

static M3GPixelFormat getInternalFormat(M3GImageFormat imgFormat,

                                        M3Gbool paletted)

{

    if (paletted) {

        switch (imgFormat) {

        case M3G_RGB:

#           if defined(M3G_NGL_TEXTURE_API)

            return M3G_PALETTE8_RGB8_32;

#           else

            return M3G_PALETTE8_RGB8;