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

 *

 * EGL 1.3

 * -------

 *

 * Copyright (c) 2007 The Khronos Group Inc.

 * Portions copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and /or associated documentation files

 * (the "Materials "), to deal in the Materials without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Materials,

 * and to permit persons to whom the Materials are furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Materials.

 *

 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

 * THE USE OR OTHER DEALINGS IN THE MATERIALS.

 *

 *//**

 * \file

 * \brief	Simple implementation of EGL 1.3

 * \note	caveats:

            - always renders into the backbuffer and blits it to window (no single buffered rendering)

            - no native Windows or Mac OS X pixmap support

            - no power management events

            - no support for swap interval

 * \todo	what happens in egl functions when eglTerminate has been called but the context and surface are still in use?

 * \todo	OSDeinitMutex should be called in case getEGL fails.

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

#include "EGL/egl.h"

#include "openvg.h"

#include "riArray.h"

#include "riMath.h"

#include "riContext.h"

#include "riImage.h"

#include "riEGLOS.h"

// Temp: A blitter is kept in the egl context for surface copies, but it will

// be placed into the EGL to VG interface in the future.

#ifndef __SFDYNAMICBLITTER_H

#   include "sfDynamicBlitter.h"

#endif

//==============================================================================================

namespace OpenVGRI

{

#if 0

void* OSGetCurrentThreadID(void);

void OSAcquireMutex(void);

void OSReleaseMutex(void);

void OSDeinitMutex(void);

EGLDisplay OSGetDisplay(EGLNativeDisplayType display_id);

void* OSCreateWindowContext(EGLNativeWindowType window);

void OSDestroyWindowContext(void* context);

bool OSIsWindow(const void* context);

void OSGetWindowSize(const void* context, int& width, int& height);

void OSBlitToWindow(void* context, const Drawable* drawable);

#else

#endif

/*-------------------------------------------------------------------*//*!

* \brief

* \param

* \return

* \note

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

class RIEGLConfig

{

public:

    RIEGLConfig() : m_desc(Color::formatToDescriptor(VG_sRGBA_8888)), m_configID(0)	{}

    ~RIEGLConfig()							{}

    void		set(int r, int g, int b, int a, int l, int bpp, int samples, int maskBits, int ID)

    {

        Color::Shape shape;

        m_desc.redBits = r;

        m_desc.greenBits = g;

        m_desc.blueBits = b;

        m_desc.alphaBits = a;

        m_desc.luminanceBits = l;

#if !defined(_WIN32) && 0

        m_desc.alphaShift = 0;

        m_desc.luminanceShift = 0;

        m_desc.blueShift = b ? a : 0;

        m_desc.greenShift = g ? a + b : 0;

        m_desc.redShift = r ? a + b + g : 0;

#else

        m_desc.luminanceShift = 0;

        m_desc.redShift = 0;

        m_desc.greenShift = g ? r : 0;

        m_desc.blueShift = b ? r + g : 0;

        m_desc.alphaShift = a ? r + g + b : 0;

#endif

        m_desc.internalFormat = l ? (a ? Color::sLA : Color::lLA) : ((r || g || b ) ? Color::sRGBA : Color::lRGBA);

        m_desc.bitsPerPixel = bpp;

        m_desc.bytesPerPixel = bpp / 8;

        {

            // Determine shape

            if (m_desc.hasAlpha())

            {

                if (m_desc.redBits > 0)

                    shape = Color::SHAPE_ARGB;

                else if (m_desc.isLuminance())

                    shape = Color::SHAPE_AL;

                else

                {

                    RI_ASSERT(m_desc.isAlphaOnly());

                    shape = Color::SHAPE_A;

                }

            } else

            {

                if (m_desc.redBits > 0)

                {

                    if (m_desc.bitsPerPixel == 32)

                        shape = Color::SHAPE_XRGB;

                    else

                    {

                        RI_ASSERT(m_desc.bitsPerPixel == 24 || m_desc.bitsPerPixel == 16);

                        shape = Color::SHAPE_RGB;

                    }

                } else if (m_desc.isLuminance())

                {

                    shape = Color::SHAPE_L;

                } else

                {

                    RI_ASSERT(false);

                }

            }

        }

        m_desc.shape = shape;

        //m_desc.format = Color::descriptorToVGImageFormat(m_desc);

        m_desc.vgFormat = (VGImageFormat)-1;

        RI_ASSERT(Color::isValidDescriptor(m_desc));

        m_samples = samples;

        m_maskBits = maskBits;

        m_configID = ID;

        m_config = (EGLConfig)ID;

    }

    Color::Descriptor configToDescriptor(bool sRGB, bool premultiplied) const

    {

        Color::Descriptor desc = m_desc;

        unsigned int f = m_desc.luminanceBits ? Color::LUMINANCE : 0;

        f |= sRGB ? Color::NONLINEAR : 0;

        f |= premultiplied ? Color::PREMULTIPLIED : 0;

        desc.internalFormat = (Color::InternalFormat)f;

        return desc;

    }

    //EGL RED SIZE bits of Red in the color buffer

    //EGL GREEN SIZE bits of Green in the color buffer

    //EGL BLUE SIZE bits of Blue in the color buffer

    //EGL ALPHA SIZE bits of Alpha in the color buffer

    //EGL LUMINANCE SIZE bits of Luminance in the color buffer

    Color::Descriptor	m_desc;

    int					m_samples;

    int                 m_maskBits;

    EGLint				m_configID;			//EGL CONFIG ID unique EGLConfig identifier

    EGLConfig           m_config;

    //EGL BUFFER SIZE depth of the color buffer (sum of channel bits)

    //EGL ALPHA MASK SIZE number alpha mask bits (always 8)

    //EGL BIND TO TEXTURE RGB boolean True if bindable to RGB textures. (always EGL_FALSE)

    //EGL BIND TO TEXTURE RGBA boolean True if bindable to RGBA textures. (always EGL_FALSE)

    //EGL COLOR BUFFER TYPE enum color buffer type (EGL_RGB_BUFFER, EGL_LUMINANCE_BUFFER)

    //EGL CONFIG CAVEAT enum any caveats for the configuration (always EGL_NONE)

    //EGL DEPTH SIZE integer bits of Z in the depth buffer (always 0)

    //EGL LEVEL integer frame buffer level (always 0)

    //EGL MAX PBUFFER WIDTH integer maximum width of pbuffer (always INT_MAX)

    //EGL MAX PBUFFER HEIGHT integer maximum height of pbuffer (always INT_MAX)

    //EGL MAX PBUFFER PIXELS integer maximum size of pbuffer (always INT_MAX)

    //EGL MAX SWAP INTERVAL integer maximum swap interval (always 1)

    //EGL MIN SWAP INTERVAL integer minimum swap interval (always 1)

    //EGL NATIVE RENDERABLE boolean EGL TRUE if native rendering APIs can render to surface (always EGL_FALSE)

    //EGL NATIVE VISUAL ID integer handle of corresponding native visual (always 0)

    //EGL NATIVE VISUAL TYPE integer native visual type of the associated visual (always EGL_NONE)

    //EGL RENDERABLE TYPE bitmask which client rendering APIs are supported. (always EGL_OPENVG_BIT)

    //EGL SAMPLE BUFFERS integer number of multisample buffers (always 0)

    //EGL SAMPLES integer number of samples per pixel (always 0)

    //EGL STENCIL SIZE integer bits of Stencil in the stencil buffer (always 0)

    //EGL SURFACE TYPE bitmask which types of EGL surfaces are supported. (always EGL WINDOW BIT | EGL PIXMAP BIT | EGL PBUFFER BIT)

    //EGL TRANSPARENT TYPE enum type of transparency supported (always EGL_NONE)

    //EGL TRANSPARENT RED VALUE integer transparent red value (undefined)

    //EGL TRANSPARENT GREEN VALUE integer transparent green value (undefined)

    //EGL TRANSPARENT BLUE VALUE integer transparent blue value (undefined)

};

/*-------------------------------------------------------------------*//*!

* \brief

* \param

* \return

* \note

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

class RIEGLContext

{

public:

    RIEGLContext(OpenVGRI::VGContext* vgctx, const EGLConfig config);

    ~RIEGLContext();

    void	addReference()				{ m_referenceCount++; }

    int		removeReference()			{ m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }

    VGContext*      getVGContext() const      { return m_vgContext; }

    EGLConfig       getConfig() const         { return m_config; }

    DynamicBlitter& getBlitter()              { return m_blitter; }

private:

    RIEGLContext(const RIEGLContext&);

    RIEGLContext& operator=(const RIEGLContext&);

    VGContext*		m_vgContext;

    const EGLConfig	m_config;

    int				m_referenceCount;

    DynamicBlitter  m_blitter;

};

RIEGLContext::RIEGLContext(OpenVGRI::VGContext* vgctx, const EGLConfig config) :

    m_vgContext(vgctx),

    m_config(config),

    m_referenceCount(0)

{

}

RIEGLContext::~RIEGLContext()

{

    RI_ASSERT(m_referenceCount == 0);

    RI_DELETE(m_vgContext);

}

/*-------------------------------------------------------------------*//*!

* \brief

* \param

* \return

* \note

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

class RIEGLSurface

{

public:

    RIEGLSurface(void* OSWindowContext, const EGLConfig config, Drawable* drawable, bool largestPbuffer, int renderBuffer);

    ~RIEGLSurface();

    void	addReference()				{ m_referenceCount++; }

    int		removeReference()			{ m_referenceCount--; RI_ASSERT(m_referenceCount >= 0); return m_referenceCount; }

    void*           getOSWindowContext() const { return m_OSWindowContext; }

    EGLConfig       getConfig() const          { return m_config; }

    Drawable*       getDrawable() const        { return m_drawable; }

    bool            isLargestPbuffer() const   { return m_largestPbuffer; }

    int             getRenderBuffer() const    { return m_renderBuffer; }

private:

    RIEGLSurface(const RIEGLSurface&);

    RIEGLSurface& operator=(const RIEGLSurface&);

    void*            m_OSWindowContext;

    const EGLConfig	 m_config;

    Drawable*        m_drawable;

    bool			 m_largestPbuffer;

    int				 m_renderBuffer;		//EGL_BACK_BUFFER or EGL_SINGLE_BUFFER

    int				 m_referenceCount;

};

RIEGLSurface::RIEGLSurface(void* OSWindowContext, const EGLConfig config, Drawable* drawable, bool largestPbuffer, int renderBuffer) :

    m_OSWindowContext(OSWindowContext),

    m_config(config),

    m_drawable(drawable),

    m_largestPbuffer(largestPbuffer),

    m_renderBuffer(renderBuffer),

    m_referenceCount(0)

{

    RI_ASSERT(m_renderBuffer == EGL_BACK_BUFFER);   //only back buffer rendering is supported

    m_drawable->addReference();

}

RIEGLSurface::~RIEGLSurface()

{

    RI_ASSERT(m_referenceCount == 0);

    OSDestroyWindowContext((OSWindowContext*)m_OSWindowContext);

    if(m_drawable)

    {

        if(!m_drawable->removeReference())

            RI_DELETE(m_drawable);

    }

}

/*-------------------------------------------------------------------*//*!

* \brief

* \param

* \return

* \note

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

#define EGL_NUMCONFIGS		5

class RIEGLDisplay

{

public:

    RIEGLDisplay(EGLDisplay id);

    ~RIEGLDisplay();

    int                getNumConfigs() const              { return EGL_NUMCONFIGS; }

    const RIEGLConfig& getConfig(int i) const             { RI_ASSERT(i >= 0 && i < EGL_NUMCONFIGS); return m_configs[i]; }

    const RIEGLConfig& getConfig(const EGLConfig config) const        { for(int i=0;i<EGL_NUMCONFIGS;i++) { if(m_configs[i].m_config == config) return m_configs[i]; } RI_ASSERT(0); return m_configs[0]; }

    EGLDisplay         getID() const                       { return m_id; }

    void              addContext(RIEGLContext* ctx)       { RI_ASSERT(ctx); m_contexts.push_back(ctx); }  //throws bad_alloc

    void              removeContext(RIEGLContext* ctx)    { RI_ASSERT(ctx); bool res = m_contexts.remove(ctx); RI_ASSERT(res); RI_UNREF(res); }

    void              addSurface(RIEGLSurface* srf)       { RI_ASSERT(srf); m_surfaces.push_back(srf); }  //throws bad_alloc

    void              removeSurface(RIEGLSurface* srf)    { RI_ASSERT(srf); bool res = m_surfaces.remove(srf); RI_ASSERT(res); RI_UNREF(res); }

    EGLBoolean        contextExists(const EGLContext ctx) const;

    EGLBoolean        surfaceExists(const EGLSurface srf) const;

    EGLBoolean        configExists(const EGLConfig cfg) const;

private:

    RIEGLDisplay(const RIEGLDisplay& t);

    RIEGLDisplay& operator=(const RIEGLDisplay&t);

    EGLDisplay              m_id;

    Array<RIEGLContext*>	m_contexts;

    Array<RIEGLSurface*>	m_surfaces;

    RIEGLConfig             m_configs[EGL_NUMCONFIGS];

};

RIEGLDisplay::RIEGLDisplay(EGLDisplay id) :

    m_id(id),

    m_contexts(),

    m_surfaces()

{

    //sorted by RGB/LUMINANCE (exact), larger total number of color bits (at least), buffer size (at least), config ID (exact)

    //NOTE: 16 bit configs need to be sorted on the fly if the request ignores some channels

    //NOTE: config IDs start from 1

    //                 R  B  G  A  L  bpp samples maskBits ID

    int i = 0;

    m_configs[i].set(8, 8, 8, 8, 0, 32, 1, 8, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 32

    m_configs[i].set(8, 8, 8, 0, 0, 32, 1, 8, i+1); i++;    // RGBX

    m_configs[i].set(5, 6, 5, 0, 0, 16, 1, 8, i+1); i++;	// 565

    m_configs[i].set(0, 0, 0, 0, 8, 8,  1, 8, i+1); i++;	// L8

    m_configs[i].set(0, 0, 0, 8, 0, 8,  1, 8, i+1); i++;	// A8

    // \note The reference implementation does not support LA16 config, so it is currently

    // not possible to test it. See if the format fits the specification.

    //m_configs[i].set(0, 0, 0, 8, 8, 16,  1, 8, i+1); i++;	// LA16

#if 0

    m_configs[i].set(8, 8, 8, 8, 0, 32, 1, 8, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 32

    m_configs[i].set(8, 8, 8, 0, 0, 32, 1, 8, i+1); i++;    // RGBX

    m_configs[i].set(8, 8, 8, 0, 0, 32, 1, 8, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 24

    //m_configs[i].set(5, 5, 5, 1, 0, 16, 1, 4, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 16

    m_configs[i].set(5, 6, 5, 0, 0, 16, 1, 4, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 16

    //m_configs[i].set(4, 4, 4, 4, 0, 16, 1, 4, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 16

    m_configs[i].set(0, 0, 0, 8, 0, 8,  1, 8, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 8

    m_configs[i].set(0, 0, 0, 4, 0, 4,  1, 4, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 8

    m_configs[i].set(0, 0, 0, 1, 0, 1,  1, 1, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 8

    m_configs[i].set(0, 0, 0, 0, 8, 8,  1, 8, i+1); i++;	//EGL_LUMINANCE_BUFFER, buffer size = 8

    //m_configs[i].set(0, 0, 0, 0, 1, 1,  1, 1, i+1); i++;	//EGL_LUMINANCE_BUFFER, buffer size = 1

    //configs without mask

    m_configs[i].set(8, 8, 8, 8, 0, 32, 1, 0, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 32

    m_configs[i].set(8, 8, 8, 0, 0, 32, 1, 0, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 24

    //m_configs[i].set(5, 5, 5, 1, 0, 16, 1, 0, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 16

    m_configs[i].set(5, 6, 5, 0, 0, 16, 1, 0, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 16

    //m_configs[i].set(4, 4, 4, 4, 0, 16, 1, 0, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 16

    m_configs[i].set(0, 0, 0, 8, 0, 8,  1, 0, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 8

    m_configs[i].set(0, 0, 0, 4, 0, 4,  1, 0, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 8

    m_configs[i].set(0, 0, 0, 1, 0, 1,  1, 0, i+1); i++;	//EGL_RGB_BUFFER, buffer size = 8

    m_configs[i].set(0, 0, 0, 0, 8, 8,  1, 0, i+1); i++;	//EGL_LUMINANCE_BUFFER, buffer size = 8

    //m_configs[i].set(0, 0, 0, 0, 1, 1,  1, 0, 20);	//EGL_LUMINANCE_BUFFER, buffer size = 1

#endif

    RI_ASSERT(EGL_NUMCONFIGS == i);

/*

attrib                default        criteria order   priority

--------------------------------------------------------------

EGL_COLOR_BUFFER_TYPE EGL_RGB_BUFFER Exact    None    2

EGL_RED_SIZE          0              AtLeast  Special 3

EGL_GREEN_SIZE        0              AtLeast  Special 3

EGL_BLUE_SIZE         0              AtLeast  Special 3

EGL_LUMINANCE_SIZE    0              AtLeast  Special 3

EGL_ALPHA_SIZE        0              AtLeast  Special 3

EGL_BUFFER_SIZE       0              AtLeast  Smaller 4

EGL_ALPHA_MASK_SIZE   0              AtLeast  Smaller 9

EGL_CONFIG_ID         EGL_DONT_CARE  Exact    Smaller 11

*/

}

RIEGLDisplay::~RIEGLDisplay()

{

    //mark everything for deletion, but don't delete the current context and surface

    for(int i=0;i<m_contexts.size();i++)

    {

        if(!m_contexts[i]->removeReference())

            RI_DELETE(m_contexts[i]);

    }

    m_contexts.clear();	//remove all contexts from the list (makes further references to the current contexts invalid)

    for(int i=0;i<m_surfaces.size();i++)

    {

        if(!m_surfaces[i]->removeReference())

            RI_DELETE(m_surfaces[i]);

    }

    m_surfaces.clear();	//remove all surfaces from the list (makes further references to the current surfaces invalid)

}

EGLBoolean RIEGLDisplay::contextExists(const EGLContext ctx) const

{

    for(int i=0;i<m_contexts.size();i++)

    {

        if(m_contexts[i] == ctx)

            return EGL_TRUE;

    }

    return EGL_FALSE;

}

EGLBoolean RIEGLDisplay::surfaceExists(const EGLSurface surf) const

{

    for(int i=0;i<m_surfaces.size();i++)

    {

        if(m_surfaces[i] == surf)

            return EGL_TRUE;

    }

    return EGL_FALSE;

}

EGLBoolean RIEGLDisplay::configExists(const EGLConfig config) const

{

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

    {

        if(m_configs[i].m_config == config)

        return EGL_TRUE;

    }

    return EGL_FALSE;

}

/*-------------------------------------------------------------------*//*!

* \brief

* \param

* \return

* \note

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

class RIEGLThread

{

public:

    RIEGLThread(void* currentThreadID);

    ~RIEGLThread();

    void*           getThreadID() const       { return m_threadID; }

    void            makeCurrent(RIEGLContext* c, RIEGLSurface* s)       { m_context = c; m_surface = s; }

    RIEGLContext*	getCurrentContext() const   { return m_context; }

    RIEGLSurface*	getCurrentSurface() const   { return m_surface; }

    void            setError(EGLint error)      { m_error = error; }

    EGLint          getError() const            { return m_error; }

    void            bindAPI(EGLint api)         { m_boundAPI = api; }

    EGLint          getBoundAPI() const         { return m_boundAPI; }

private:

    RIEGLThread(const RIEGLThread&);

    RIEGLThread operator=(const RIEGLThread&);

    RIEGLContext*		m_context;

    RIEGLSurface*		m_surface;

    EGLint              m_error;

    void*               m_threadID;

    EGLint              m_boundAPI;

};

RIEGLThread::RIEGLThread(void* currentThreadID) :

    m_context(NULL),

    m_surface(NULL),

    m_error(EGL_SUCCESS),

    m_threadID(currentThreadID),