/*

* 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 for the OpenGL ES API

*

*/

/*!

 * \internal

 * \file

 * \brief Image implementation for the OpenGL ES API

 *

 * $Id: m3g_image.inl,v 1.11 2006/03/15 13:26:36 roimela Exp $

 */

#if defined(M3G_NGL_TEXTURE_API)

#   error This file is for the OES API only

#endif

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

 * Data types

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

/*!

 * \internal

 * \brief Additional data for a "large" image

 *

 * A large image is an image that is larger than the maximum texture

 * size.  They basically get split into a bunch of smaller textures so

 * that we can use them for drawing backgrounds via OpenGL ES.  Some

 * optimization is done to make sure we don't waste excessive amounts

 * of memory in doing so.

 */

struct LargeImageImpl

{

    M3Gsizei tilesX, tilesY;

    M3Gint tileWidth, tileHeight;

    M3Gbool dirty;

    /* The size of the tile texture name array is set dynamically upon

     * allocation, and it *must* be the last field in the

     * structure! */

    GLuint tileNames[1];

};

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

 * Private functions

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

/*!

 * \internal

 * \brief Queries whether an image can be paletted internally or not

 */

static M3Gbool m3gSupportedPaletteFormat(M3GImageFormat format)

{

    return (format == M3G_RGB || format == M3G_RGBA);

}

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

 * Internal functions

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

/*!

 * \internal

 * \brief Matches an M3G pixel format with a GL texture format

 */

static GLenum m3gGetGLFormat(M3GPixelFormat format)

{

    switch (format) {

    case M3G_A8:

        return GL_ALPHA;

    case M3G_L8:

        return GL_LUMINANCE;

    case M3G_LA8:

        return GL_LUMINANCE_ALPHA;

    case M3G_RGB8:

    case M3G_RGB8_32:

    case M3G_BGR8_32:

        return GL_RGB;

    case M3G_RGBA8:

    case M3G_BGRA8:

    case M3G_ARGB8:

        return GL_RGBA;

    case M3G_PALETTE8_RGB8:

        return GL_PALETTE8_RGB8_OES;

    case M3G_PALETTE8_RGBA8:

        return GL_PALETTE8_RGBA8_OES;

    default:

        return 0;

    }

}

/*!

 * \internal

 * \brief Destroys the additional data of a "large" image

 *

 * This can be called to save (OpenGL) memory at any time -- the data

 * will be recreated when necessary.  Performance will obviously

 * suffer, though.

 */

static void m3gDestroyLargeImage(Image *img)

{

    LargeImage *lrg = img->large;

    M3G_VALIDATE_MEMBLOCK(lrg);

    m3gDeleteGLTextures(M3G_INTERFACE(img),

                        lrg->tilesX * lrg->tilesY, lrg->tileNames);

    m3gFree(M3G_INTERFACE(img), img->large);

    img->large = NULL;

}

/*!

 * \internal

 * \brief Binds an image as an OpenGL texture object

 *

 * The image is bound to the active texture unit, which must be

 * selected outside of this function.

 */

static void m3gBindTextureObject(Image *img, M3Gbool mipmap)

{

    Interface *m3g;

    M3G_VALIDATE_OBJECT(img);

    m3g = M3G_INTERFACE(img);

    M3G_ASSERT(img->special == 0);

    M3G_ASSERT_NO_LOCK(m3g);

    M3G_ASSERT_GL;

    /* Bind the next available texture object; create a new one if it

     * doesn't exist yet. */

    {

        if (!img->texObject) {

            GLint err;

            glGenTextures(1, &img->texObject);

            err = glGetError();

            if (err == GL_OUT_OF_MEMORY) {

                m3gRaiseError(M3G_INTERFACE(img), M3G_OUT_OF_MEMORY);

                return;

            }

            M3G_ASSERT(err == GL_NO_ERROR);

            M3G_LOG1(M3G_LOG_OBJECTS, "New GL texture object 0x%08X\n",

                     (unsigned) img->texObject);

            img->dirty = M3G_TRUE;

        }

        glBindTexture(GL_TEXTURE_2D, img->texObject);

    }

    /* Upload the texture image to OpenGL if the one in the texture

     * object isn't up to date */

    if (img->dirty || (mipmap && img->mipmapsDirty)) {

        M3Gubyte *pixels = ((M3Gubyte *)m3gMapObject(m3g, img->data));

        /* Reload the level 0 image if dirty. Note that paletted

         * textures are loaded as compressed, and the mipmap dirty

         * flag is only raised for non-paletted textures. */

        if (img->dirty) {

            M3G_ASSERT_PTR(pixels);

            if (img->paletteBytes > 0) {

                M3G_ASSERT(img->glFormat == GL_PALETTE8_RGBA8_OES

                    || img->glFormat == GL_PALETTE8_RGB8_OES);

                M3G_ASSERT(mipmap == M3G_FALSE);

                glCompressedTexImage2D(GL_TEXTURE_2D,

                                       0,

                                       img->glFormat,

                                       img->width, img->height,

                                       0,

                                       img->width * img->height + img->paletteBytes,

                                       pixels);

            }

            else {

#               if defined(M3G_GL_ES_1_1)

                glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP,

                                mipmap ? GL_TRUE : GL_FALSE);

#               endif

                glTexImage2D(GL_TEXTURE_2D,

                             0,

                             img->glFormat,

                             img->width, img->height,

                             0,

                             img->glFormat,

                             GL_UNSIGNED_BYTE,

                             pixels);

#               if defined(M3G_GL_ES_1_1)

                img->mipmapsDirty = M3G_FALSE;

#               else

                img->mipmapsDirty = M3G_TRUE;

#               endif

            }

            m3gUnmapObject(m3g, img->data);

            img->dirty = M3G_FALSE;

        }

        /* Regenerate mipmap levels if necessary; also regenerate if

         * the image will never change again, as this allows us to

         * free the user memory copy of the image and keep only the

         * mipmap pyramid in OpenGL memory, saving some in total */

#       if !defined(M3G_GL_ES_1_1)

        if (img->mipmapsDirty && (mipmap || (img->flags & M3G_DYNAMIC) == 0)) {

            int i, n;

            M3Gint w, h;

            const M3Gubyte *src;

            M3Gubyte *temp;

            M3G_ASSERT(!img->dirty);

            w = img->width;

            h = img->height;

            n = m3gGetNumMipmapLevels(w, h);

            temp = m3gAllocTemp(m3g,

                                w * h * m3gBytesPerPixel(img->internalFormat));

            if (!temp) {

                return; /* automatic out of memory */

            }

            src = ((M3Gubyte *)m3gMapObject(m3g, img->data));

            for (i = 1; i < n; ++i) {

                m3gDownsample(img->internalFormat,

                              src,

                              &w, &h,

                              temp);

                glTexImage2D(GL_TEXTURE_2D,

                             i,

                             img->glFormat,

                             w, h,

                             0,

                             img->glFormat,

                             GL_UNSIGNED_BYTE,

                             temp);

                src = temp;

            }

            m3gUnmapObject(m3g, img->data);

            m3gFreeTemp(m3g);

            img->mipmapsDirty = M3G_FALSE;

        }

#       endif /* !M3G_GL_ES_1_1 */

        /* Free the pixel data if we can; we've uploaded mipmap

         * levels, so OpenGL will keep them for us for the rest of the

         * lifetime of this object */

        if (!img->pinned && !img->mipmapsDirty) {

            m3gFreeImageData(img);

        }

        /* Raise out-of-memory if the OpenGL implementation ran out of

         * resources */

        {

            GLint err = glGetError();

            if (err == GL_OUT_OF_MEMORY) {

                m3gRaiseError(M3G_INTERFACE(img), M3G_OUT_OF_MEMORY);

            }

            else if (err != GL_NO_ERROR) {

                M3G_ASSERT(M3G_FALSE);

            }

        }

    }

}

/*!

 * \internal

 * \brief Releases one of the texture objects bound for this image

 *

 * This assumes that the texture unit the image was bound to is

 * current.

 */

static void m3gReleaseTextureImage(Image *img)

{

    M3G_VALIDATE_OBJECT(img);

    M3G_UNREF(img);

    glBindTexture(GL_TEXTURE_2D, 0);

    M3G_ASSERT_GL;

}

/*!

 * \internal

 * \brief Copies an image from the bottom left corner of the frame

 * buffer

 *

 */

static void m3gCopyFrameBufferImage(Image *img)

{

    Interface *m3g;

    M3Gubyte *pixels;

    M3G_VALIDATE_OBJECT(img);

    M3G_ASSERT_GL;

    m3g = M3G_INTERFACE(img);

    {

        int row;

        M3Gsizei stride = img->width * m3gBytesPerPixel(img->internalFormat);

        /* An RGBA image we can copy straight into the user memory buffer */

        if (img->internalFormat == M3G_RGBA8) {

            pixels = m3gMapObject(m3g, img->data);

            for (row = 0; row < img->height; ++row) {

                glReadPixels(0, img->height - row - 1,

                             img->width, 1,

                             GL_RGBA, GL_UNSIGNED_BYTE,

                             pixels + row * stride);

            }

            m3gUnmapObject(m3g, img->data);

        }

        else {

            /* For non-RGBA images, we must do a format conversion from

             * the RGBA returned by ReadPixels to the destination

             * format. We do this one scanline at a time to spare memory.

             */

            M3Gubyte *temp = m3gAllocTemp(m3g, img->width * 4);

            if (!temp) {

                return; /* out of memory */

            }

            pixels = m3gMapObject(m3g, img->data);

            for (row = 0; row < img->height; ++row) {

                glReadPixels(0, img->height - row - 1,

                             img->width, 1,

                             GL_RGBA, GL_UNSIGNED_BYTE,

                             temp);

                m3gConvertPixels(M3G_RGBA8, temp,

                                 img->internalFormat, pixels + row * stride,

                                 img->width);

            }

            m3gUnmapObject(m3g, img->data);

            m3gFreeTemp(m3g);

        }

    }

    M3G_ASSERT_GL;

    m3gInvalidateImage(img);

}

/*!

 * \internal

 * \brief Draws any RGB or RGBA image into the bottom left corner of

 * the frame buffer

 */

static void m3gDrawFrameBufferImage(RenderContext *ctx, const Image *img)

{

    M3G_VALIDATE_OBJECT(img);

    {

        const M3Gubyte *pixels = m3gMapObject(M3G_INTERFACE(img), img->data);

        m3gBlitFrameBufferPixels(ctx,

                                 0, 0,

                                 img->width, img->height,

                                 img->internalFormat,

                                 m3gGetImageStride(img),

                                 pixels);

        m3gUnmapObject(M3G_INTERFACE(img), img->data);

    }

}