/*

* 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: EGL rendering context management functions

*

*/

/*!

 * \internal

 * \file

 * \brief EGL rendering context management functions

 */

#if defined(M3G_NGL_CONTEXT_API)

#   error This file is for the OES API only

#endif

#include <GLES/egl.h>

#include "m3g_image.h"

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

 * Private functions

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

/*!

 * \internal

 * \brief Queries for an EGL configuration matching given M3G format

 * parameters

 */

static EGLConfig m3gQueryEGLConfig(M3Genum format,

                                   M3Gbitmask bufferBits,

                                   EGLint surfaceBits)

{

    struct { int attrib, value; } attribs[9];

    int samples;

    /* Determine color depth */

    attribs[0].attrib = EGL_RED_SIZE;

    attribs[1].attrib = EGL_GREEN_SIZE;

    attribs[2].attrib = EGL_BLUE_SIZE;

    attribs[3].attrib = EGL_ALPHA_SIZE;

    switch (format) {

    case M3G_RGB4:

        attribs[0].value = 4;

        attribs[1].value = 4;

        attribs[2].value = 4;

        attribs[3].value = 0;

        break;

    case M3G_RGB565:

        attribs[0].value = 5;

        attribs[1].value = 6;

        attribs[2].value = 5;

        attribs[3].value = 0;

        break;

    case M3G_RGB8:

    case M3G_BGR8_32:

        attribs[0].value = 8;

        attribs[1].value = 8;

        attribs[2].value = 8;

        attribs[3].value = 0;

        break;

    case M3G_RGBA8:

    case M3G_BGRA8:

        attribs[0].value = 8;

        attribs[1].value = 8;

        attribs[2].value = 8;

        attribs[3].value = 8;

        break;

    default:

        return NULL;

    }

    /* Set up the depth buffer */

    attribs[4].attrib = EGL_DEPTH_SIZE;

    attribs[4].value = (bufferBits & M3G_DEPTH_BUFFER_BIT) ? 16 : 0;

    /* Set target surface type mask */

    attribs[5].attrib = EGL_SURFACE_TYPE;

    attribs[5].value = surfaceBits;

    /* Try to get multisampling if requested */

    attribs[6].attrib = EGL_SAMPLE_BUFFERS;

    attribs[7].attrib = EGL_SAMPLES;

    attribs[8].attrib = EGL_NONE;

    /* Try 4 samples if multisampling enabled, then 2, then 1 */

    samples = (bufferBits & M3G_MULTISAMPLE_BUFFER_BIT) ? 4 : 1;

    for ( ; samples > 0; samples >>= 1) {

        if (samples > 1) {

            attribs[6].value = 1;

            attribs[7].value = samples;

        }

        else {

            attribs[6].value = EGL_FALSE;

            attribs[7].value = 0;

        }

        /* Get the first matching config; according to EGL sorting

         * rules, this should be an accelerated one if possible */

        {

            EGLConfig config;

            int numConfigs;

            eglChooseConfig(eglGetDisplay(EGL_DEFAULT_DISPLAY),

                            (const int *) attribs,

                            &config, 1,

                            &numConfigs);

            M3G_ASSERT(eglGetError() == EGL_SUCCESS);

            /* If we got a config, return that; otherwise, drop the

             * number of multisampling samples and try again, or

             * return NULL for no config if we already have zero

             * samples */

            if (numConfigs > 0) {

                M3G_LOG1(M3G_LOG_RENDERING, "Selected EGL config #%d\n", config);

                return config;

            }

            if (samples == 2) {

                M3G_LOG(M3G_LOG_WARNINGS, "Warning: multisampling not available\n");

            }

        }

    }

    /* No matching configuration found */

    return NULL;

}

/*!

 * \internal

 * \brief Initializes EGL

 */

static void m3gInitializeEGL(void)

{

    M3G_LOG(M3G_LOG_INTERFACE, "Initializing EGL\n");

    eglInitialize(eglGetDisplay(EGL_DEFAULT_DISPLAY), NULL, NULL);

}

/*!

 * \internal

 * \brief Terminates EGL

 */

static void m3gTerminateEGL(void)

{

    M3G_LOG(M3G_LOG_INTERFACE, "Shutting down EGL\n");

    eglTerminate(eglGetDisplay(EGL_DEFAULT_DISPLAY));

}

/*!

 * \internal

 * \brief Creates a new EGL context

 */

static EGLContext m3gCreateGLContext(M3Genum format,

                                     M3Gbitmask bufferBits,

                                     M3Gbitmask reqSurfaceBits,

                                     EGLContext share,

                                     M3Gbitmask *outSurfaceBits)

{

    EGLContext ctx;

    EGLConfig config;

    M3G_ASSERT((reqSurfaceBits & ~(EGL_PIXMAP_BIT|EGL_PBUFFER_BIT|EGL_WINDOW_BIT)) == 0);

    config = m3gQueryEGLConfig(format, bufferBits, reqSurfaceBits);

    if (!config || !eglGetConfigAttrib(eglGetDisplay(EGL_DEFAULT_DISPLAY),

                                       config,

                                       EGL_SURFACE_TYPE,

                                       (EGLint *) outSurfaceBits)) {

        return NULL;

    }

    ctx = eglCreateContext(eglGetDisplay(EGL_DEFAULT_DISPLAY),

                           config,

                           share,

                           NULL);

#   if defined(M3G_DEBUG)

    {

        EGLint err = eglGetError();

        M3G_ASSERT(err == EGL_SUCCESS || err == EGL_BAD_ALLOC);

    }

#   endif

    M3G_LOG1(M3G_LOG_OBJECTS, "New GL context 0x%08X\n", (unsigned) ctx);

    return ctx;

}

/*!

 * \internal

 * \brief Deletes an EGL context

 */

static void m3gDeleteGLContext(EGLContext ctx)

{

    eglDestroyContext(eglGetDisplay(EGL_DEFAULT_DISPLAY), ctx);

#   if defined(M3G_DEBUG)

    {

        EGLint err = eglGetError();

        if (err != EGL_SUCCESS) {

            M3G_LOG1(M3G_LOG_FATAL_ERRORS, "EGL error 0x%08X\n", (unsigned) err);

        }

        M3G_ASSERT(err == EGL_SUCCESS);

    }

#   endif

    M3G_LOG1(M3G_LOG_OBJECTS, "Destroyed GL context 0x%08X\n",

             (unsigned) ctx);

}

/*!

 * \internal

 * \brief Creates a new EGL window surface

 */

static EGLSurface m3gCreateWindowSurface(M3Genum format,

                                         M3Gbitmask bufferBits,

                                         M3GNativeWindow wnd)

{

    EGLSurface surf;

    EGLConfig config = m3gQueryEGLConfig(format, bufferBits, EGL_WINDOW_BIT);

    if (!config) {

        return NULL;

    }

    surf = eglCreateWindowSurface(eglGetDisplay(EGL_DEFAULT_DISPLAY),

                                  config,

                                  (NativeWindowType) wnd,

                                  NULL);

#   if defined(M3G_DEBUG)

    {

        EGLint err = eglGetError();

        M3G_ASSERT(err == EGL_SUCCESS || err == EGL_BAD_ALLOC);

    }

#   endif

    if (surf != EGL_NO_SURFACE) {

        M3G_LOG1(M3G_LOG_OBJECTS, "New GL window surface 0x%08X\n",

                 (unsigned) surf);

        return surf;

    }

    return NULL;

}

/*!

 * \internal

 * \brief Creates a new EGL pixmap surface

 */

static EGLSurface m3gCreateBitmapSurface(M3Genum format,

                                         M3Gbitmask bufferBits,

                                         M3GNativeBitmap bmp)

{

    EGLSurface surf;

    EGLConfig config = m3gQueryEGLConfig(format, bufferBits, EGL_PIXMAP_BIT);

    if (!config) {

        return NULL;

    }

    surf = eglCreatePixmapSurface(eglGetDisplay(EGL_DEFAULT_DISPLAY),

                                  config,

                                  (NativePixmapType) bmp,

                                  NULL);

#   if defined(M3G_DEBUG)

    {

        EGLint err = eglGetError();

        M3G_ASSERT(err == EGL_SUCCESS || err == EGL_BAD_ALLOC);

    }

#   endif

    if (surf != EGL_NO_SURFACE) {

        M3G_LOG1(M3G_LOG_OBJECTS, "New GL pixmap surface 0x%08X\n",

                 (unsigned) surf);

        return surf;

    }

    return NULL;

}

/*!

 * \internal

 * \brief Creates a new PBuffer

 */

static EGLSurface m3gCreatePBufferSurface(M3Genum format,

                                          M3Gbitmask bufferBits,

                                          M3Gint width, M3Gint height)

{

    EGLSurface surf;

    EGLConfig config;

    EGLint attrib[5];

    attrib[0] = EGL_WIDTH;

    attrib[1] = width;

    attrib[2] = EGL_HEIGHT;

    attrib[3] = height;

    attrib[4] = EGL_NONE;

    config = m3gQueryEGLConfig(format, bufferBits, EGL_PBUFFER_BIT);

    if (!config) {

        return NULL;

    }

    surf = eglCreatePbufferSurface(eglGetDisplay(EGL_DEFAULT_DISPLAY),

                                   config,

                                   attrib);

#   if defined(M3G_DEBUG)

    {

        EGLint err = eglGetError();

        M3G_ASSERT(err == EGL_SUCCESS || err == EGL_BAD_ALLOC);

    }

#   endif

    if (surf != EGL_NO_SURFACE) {

        M3G_LOG1(M3G_LOG_OBJECTS, "New GL pbuffer surface 0x%08X\n",

                 (unsigned) surf);

        return surf;

    }

    return NULL;

}

/*!

 * \internal

 * \brief Deletes an EGL surface

 */

static void m3gDeleteGLSurface(EGLSurface surface)

{

    eglDestroySurface(eglGetDisplay(EGL_DEFAULT_DISPLAY), surface);

#   if defined(M3G_DEBUG)

    {

        EGLint err = eglGetError();

        M3G_ASSERT(err == EGL_SUCCESS);

    }

#   endif

    M3G_LOG1(M3G_LOG_OBJECTS, "Destroyed GL surface 0x%08X\n",

             (unsigned) surface);

}

/*!

 * \brief Swap buffers on a rendering surface

 */

static M3Gbool m3gSwapBuffers(EGLSurface surface)

{

    EGLBoolean success = eglSwapBuffers(eglGetDisplay(EGL_DEFAULT_DISPLAY),

                                        surface);

#   if defined(M3G_DEBUG)

    EGLint err = eglGetError();

    M3G_ASSERT(err == EGL_SUCCESS);

#   endif

    return (M3Gbool) success;

}

/*!

 * \brief Does a sub-blit of a frame buffer blit operation

 */

static void m3gBlitFrameBufferPixels2(RenderContext *ctx,

                                      M3Gint xOffset, M3Gint yOffset,

                                      M3Gint width, M3Gint height,

                                      M3GPixelFormat internalFormat,

                                      M3Gsizei stride,

                                      const M3Gubyte *pixels)

{

#   define MAX_TEMP_TEXTURES    8

    GLuint glFormat;

    static const int MAX_TILE_SIZE = 256; /* -> 256 KB temp buffer(s) */

    static const M3Gbyte tc[8] = { 0, 0, 0, 1, 1, 0, 1, 1 };

    GLshort pos[8];

    int tileWidth = MAX_TILE_SIZE, tileHeight = MAX_TILE_SIZE;

    M3Gbool mustConvert = M3G_FALSE;

    M3Gubyte *tempPixels = 0; /* initialize to avoid compiler warnings */

    GLuint tempTexObj[MAX_TEMP_TEXTURES];

    GLint tempTexCount;

    M3G_VALIDATE_OBJECT(ctx);

    M3G_ASSERT_GL;

    /* Analyze source and destination formats for possible conversion */

    glFormat = m3gGetGLFormat(internalFormat);

    if (!glFormat) {

        M3G_ASSERT(M3G_FALSE);  /* internal format not supported in GL */

        return;

    }

    if (internalFormat == M3G_RGB8_32) {

        glFormat = GL_RGBA;

    }

    if (internalFormat == M3G_BGR8_32) {

        glFormat = GL_RGBA;

        mustConvert = M3G_TRUE;

    }

    /* Tweak tile size to avoid using excessive amounts of memory for

     * portions outside the blit area */

    M3G_ASSERT((width > 0) && (height > 0));

    while (tileWidth >= width * 2) {

        tileWidth >>= 1;

        tileHeight <<= 1;

    }

    while (tileHeight >= height * 2) {

        tileHeight >>= 1;

    }

    /* Allocate temp memory for conversion or adjust tile size for

     * optimal direct download to GL */

    if (mustConvert) {

        tempPixels = m3gAllocTemp(M3G_INTERFACE(ctx),

                                  tileWidth * tileHeight * 4);

        if (!tempPixels) {

            return; /* out of memory */

        }

    }

    else {

        /* Attempt to adjust the tile size so that we can copy

         * complete scanlines at a time -- this is because OpenGL ES

         * is missing PixelStore settings that could be used for

         * stride control during image uploading */

        M3Gint maxWidth;

        glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxWidth);

        while (tileWidth < width &&

               tileWidth < maxWidth &&

               tileHeight > 1) {

            tileWidth <<= 1;

            tileHeight >>= 1;

        }

    }

    /* Load default images into the temp texture objects */

    glActiveTexture(GL_TEXTURE0);

    glEnable(GL_TEXTURE_2D);

    {

        int ti;

        tempTexCount = ((width + tileWidth - 1) / tileWidth)

            * ((height + tileHeight - 1) / tileHeight);

        tempTexCount = m3gMinInt(tempTexCount, MAX_TEMP_TEXTURES);

        glGenTextures(tempTexCount, tempTexObj);

        for (ti = 0; ti < tempTexCount; ++ti) {

            glBindTexture(GL_TEXTURE_2D, tempTexObj[ti]);

            glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

            glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

            glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

            M3G_ASSERT_GL;

            glTexImage2D(GL_TEXTURE_2D, 0,

                         glFormat,

                         tileWidth, tileHeight,

                         0,

                         glFormat,

                         GL_UNSIGNED_BYTE, NULL);

            /* Raise out-of-memory if OpenGL ran out of resources */

            {

                GLint err = glGetError();

                if (err == GL_OUT_OF_MEMORY) {

                    m3gRaiseError(M3G_INTERFACE(ctx), M3G_OUT_OF_MEMORY);

                    goto CleanUpAndExit;

                }

                else if (err != GL_NO_ERROR) {

                    M3G_ASSERT(M3G_FALSE);

                }

            }

        }

    }

    /* Set up texture and vertex coordinate arrays for the image tiles */

    glClientActiveTexture(GL_TEXTURE0);

    glTexCoordPointer(2, GL_BYTE, 0, tc);

    glEnableClientState(GL_TEXTURE_COORD_ARRAY);

    glVertexPointer(2, GL_SHORT, 0, pos);

    glEnableClientState(GL_VERTEX_ARRAY);

    glMatrixMode(GL_TEXTURE);

    glLoadIdentity();

    glMatrixMode(GL_MODELVIEW);

    M3G_ASSERT_GL;

    /* Load each image tile into a texture and draw */

    {

        M3Gint nextTexTile = 0;

        M3Gint x, y, bpp;

        bpp = m3gBytesPerPixel(internalFormat);

        if (stride == 0) {

            stride = bpp * width;

        }

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

            for (x = 0; x < width; x += tileWidth) {

                M3Gint w, h;

                w = M3G_MIN(tileWidth, width - x);

                h = M3G_MIN(tileHeight, height - y);