/* 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.

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

#include "EGLConfig.h"

#include "ColorDescriptor.h"

#include "TransparentColor.h"

const int KPbufferHeight = 16384;       

const int KPbufferWidth = 16384;

const int KPbufferPixels = KPbufferHeight * KPbufferWidth;

CEGLConfig::CEGLConfig(void) :

    m_nativeVisualId( NULL )

    {

    }

CEGLConfig::CEGLConfig( CColorDescriptor&   colorDescriptor,        

                        EGLBoolean          bindToTexRGB,           /* EGL_BIND_TO_TEXTURE_RGB*/

                        EGLBoolean          bindToTexRGBA,          /* EGL_BIND_TO_TEXTURE_RGBA */

                        EGLenum             configCaveat,           /* EGL_CONFIG_CAVEAT */

                        EGLint              configId,               /* EGL_CONFIG_ID */

                        EGLint              conformant,             /* EGL_CONFORMANT */

                        EGLint              depthSize,              /* EGL_DEPTH_SIZE */

                        EGLint              level,                  /* EGL_LEVEL */

                        EGLint              maxSwapInterval,        /* EGL_MAX_SWAP_INTERVAL */

                        EGLint              minSwapInterval,        /* EGL_MIN_SWAP_INTERVAL */

                        EGLBoolean          nativeRenderable,       /* EGL_NATIVE_RENDERABLE */

                        EGLint              nativeVisualType,       /* EGL_NATIVE_VIDUAL_TYPE */

                        EGLint              renderableType,         /* EGL_RENDERABLE_TYPE */

                        EGLint              sampleBuffers,          /* EGL_SAMPLE_BUFFERS */

                        EGLint              samples,                /* EGL_SAMPLES */

                        EGLint              stencilSize,            /* EGL_STENCIL_SIZE */

                        EGLint              surfaceType,

                        CTransparentColor*  transparentColor) :

    m_bindToTexRGB( bindToTexRGB ),

    m_bindToTexRGBA( bindToTexRGBA ),

    m_configCaveat( configCaveat ),

    m_configId( configId ),

    m_conformant( conformant ),

    m_depthSize( depthSize ),

    m_level( level ),

    m_maxPbufferWidth( KPbufferWidth ),

    m_maxPbufferHeight( KPbufferHeight ),

    m_maxPbufferPixels( KPbufferPixels ),

    m_maxSwapInterval( maxSwapInterval ),

    m_minSwapInterval( minSwapInterval ),

    m_nativeRenderable( nativeRenderable ),

    m_nativeVisualId( NULL ),

    m_nativeVisualType( nativeVisualType ),

    m_renderableType( renderableType ),

    m_sampleBuffers( samples > 1 ? 1 : 0 ),

    m_samples( samples ),

    m_stencilSize( stencilSize ),

    m_surfaceType( surfaceType )

    {

    m_colorDescriptor = colorDescriptor;

    if( m_colorDescriptor.isLuminance() )

        {

        m_bufferSize = m_colorDescriptor.LuminanceSize() + m_colorDescriptor.AlphaSize();

        }

    else

        {

        m_bufferSize = m_colorDescriptor.RedSize() +

            m_colorDescriptor.GreenSize() +

            m_colorDescriptor.BlueSize() +

            m_colorDescriptor.AlphaSize();

        }

    if( transparentColor )

        {

        m_transparentColor = *transparentColor;

        }

    }

CEGLConfig::~CEGLConfig(void)

    {

    }

EGLint CEGLConfig::SetUpConfig( EGLint red, EGLint green, EGLint blue, 

                                EGLint luminance, EGLint alpha, 

                                EGLint alphaMask, EGLint samples, EGLint bpp, EGLint id )

    {

    int ret = EGL_SUCCESS;

    int rgb = red + green + blue;

    if( luminance && rgb )

        {

        return EGL_BAD_PARAMETER;

        }

    m_colorDescriptor.Set( red, green, blue, luminance, false, alpha, true, alphaMask, bpp );

    //m_colorDescriptor = EGLI_NEW CColorDescriptor( red, green, blue, luminance, false, alpha, true, alphaMask, bpp );

    m_configId = id;

    if( m_colorDescriptor.isLuminance() )

        {

        m_bufferSize = luminance + alpha;

        }

    else

        {

        m_bufferSize = red + green + blue + alpha;  

        }

    if( rgb )

        {

        m_bindToTexRGB = EGL_TRUE;

        m_bindToTexRGBA = EGL_TRUE;

        }

    else

        {

        m_bindToTexRGB = EGL_FALSE;

        m_bindToTexRGBA = EGL_FALSE;

        }

    /*

    The EGL_CONFIG_CAVEAT attribute may be set to one of the following values:

    EGL_NONE, EGL_SLOW_CONFIG or EGL_NON_CONFORMANT_CONFIG. If the

    attribute is set to EGL_NONE then the configuration has no caveats; if it is set to

    EGL_SLOW_CONFIG then rendering to a surface with this configuration may run at

    reduced performance (for example, the hardware may not support the color buffer

    depths described by the configuration); if it is set to EGL_NON_CONFORMANT_-

    CONFIG then rendering to a surface with this configuration will not pass the required

    OpenGL ES conformance tests (note that EGL_NON_CONFORMANT_CONFIG

    is obsolete, and the same information can be obtained from the EGL_CONFORMANT

    attribute on a per-client-API basis, not just for OpenGL ES ).

    */

    m_configCaveat = EGL_NONE;

    /*

    Same as EGL_RENDERABLE_TYPE:

    EGL_OPENGL_ES_BIT,

    EGL_OPENVG_BIT,

    EGL_OPENGL_ES2_BIT,

    EGL_OPENGL_BIT

    */

    m_conformant = EGL_OPENGL_ES2_BIT;//0;

    m_renderableType = EGL_OPENVG_BIT | EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT;

    /*

    The Depth Buffer

    The depth buffer is shared by OpenGL and OpenGL ES . It contains fragment

    depth (Z) information generated during rasterization. EGL_DEPTH_SIZE indicates

    the depth of this buffer in bits.

    */

    m_depthSize = 0;

    /*

     EGL_LEVEL is the framebuffer overlay or underlay level in which an

     EGLSurface created with eglCreateWindowSurface will be placed. Level zero

     indicates the default layer. The behavior of windows placed in overlay and under-

     lay levels depends on the underlying native window system.

    */

    m_level = 0;

    /*

    EGL_MAX_PBUFFER_WIDTH and EGL_MAX_PBUFFER_HEIGHT indicate the

    maximum width and height that can be passed into eglCreatePbufferSurface,

    and EGL_MAX_PBUFFER_PIXELS indicates the maximum number of pixels (width

    times height) for a pbuffer surface. Note that an implementation may return a value

    for EGL_MAX_PBUFFER_PIXELS that is less than the maximum width times the

    maximum height. The value for EGL_MAX_PBUFFER_PIXELS is static and assumes

    that no other pbuffers or native resources are contending for the framebuffer

    memory. Thus it may not be possible to allocate a pbuffer of the size given by

    EGL_MAX_PBUFFER_PIXELS.

    */

    m_maxPbufferHeight = KPbufferHeight;       

    m_maxPbufferWidth = KPbufferWidth;

    m_maxPbufferPixels = KPbufferPixels;   

    /*

    EGL_MAX_SWAP_INTERVAL is the maximum value that can be passed to

    eglSwapInterval, and indicates the number of swap intervals that will elapse before

    a buffer swap takes place after calling eglSwapBuffers. Larger values will be

    silently clamped to this value.

    */

    m_maxSwapInterval = 1;

    /*

    EGL_MIN_SWAP_INTERVAL is the minimum value that can be passed to

    eglSwapInterval, and indicates the number of swap intervals that will elapse before

    a buffer swap takes place after calling eglSwapBuffers. Smaller values will

    be silently clamped to this value.

    */

    m_minSwapInterval = 1;

    /*

    EGL_NATIVE_RENDERABLE is an EGLBoolean indicating whether the native

    window system can be used to render into a surface created with the EGLConfig.

    */

    m_nativeRenderable = EGL_FALSE;

    /*

    If an EGLConfig supports windows then it may have an associated native visual.

    EGL_NATIVE_VISUAL_ID specifies an identifier for this visual, and EGL_-

    NATIVE_VISUAL_TYPE specifies its type. If an EGLConfig does not support

    windows, or if there is no associated native visual type, then querying EGL_-

    NATIVE_VISUAL_ID will return 0 and querying EGL_NATIVE_VISUAL_TYPE

    will return EGL_NONE.

    The interpretation of the native visual identifier and type is platform-dependent.

    For example, if the native window system is X, then the identifier will be the XID

    of an X Visual.

    */

    m_nativeVisualId = 0;

    m_nativeVisualType = EGL_NONE;    

    /*

    EGL_SAMPLE_BUFFERS indicates the number of multisample buffers, which

    must be zero or one. EGL_SAMPLES gives the number of samples per pixel; if

    EGL_SAMPLE_BUFFERS is zero, then EGL_SAMPLES will also be zero. If EGL_-

    SAMPLE_BUFFERS is one, then the number of color, depth, and stencil bits for each

    sample in the multisample buffer are as specified by the EGL_*_SIZE attributes.

    There are no single-sample depth or stencil buffers for a multisample

    EGLConfig; the only depth and stencil buffers are those in the multisample

    buffer. If the color samples in the multisample buffer store fewer bits than are

    stored in the color buffers, this fact will not be reported accurately. Presumably a

    compression scheme is being employed, and is expected to maintain an aggregate

    resolution equal to that of the color buffers.

    */

    m_samples = samples; 

    m_sampleBuffers = samples > 1 ? 1 : 0;   

    /*

    The stencil buffer is shared by OpenGL and OpenGL ES . It contains fragment

    stencil information generated during rasterization. EGL_STENCIL_SIZE indicates

    the depth of this buffer in bits.

    */

    m_stencilSize = 0;

    /*

    EGL_SURFACE_TYPE is a mask indicating capabilities of surfaces that can be

    created with the corresponding EGLConfig (the config is said to support these

    surface types).

    EGL_SURFACE_TYPE is a mask indicating capabilities of surfaces that can be

    created with the corresponding EGLConfig (the config is said to support these

    surface types). The valid bit settings are shown in Table 3.2.

    For example, an EGLConfig for which the value of the EGL_SURFACE_TYPE

    attribute is

    EGL_WINDOW_BIT j EGL_PIXMAP_BIT j EGL_PBUFFER_BIT

    can be used to create any type of EGL surface, while an EGLConfig for which this

    attribute value is EGL_WINDOW_BIT cannot be used to create a pbuffer or pixmap.

    If EGL_MULTISAMPLE_RESOLVE_BOX_BIT is set in EGL_SURFACE_TYPE,

    then the EGL_MULTISAMPLE_RESOLVE attribute of a surface can be specified as a

    box filter with eglSurfaceAttrib (see section 3.5.6).

    If EGL_SWAP_BEHAVIOR_PRESERVED_BIT is set in EGL_SURFACE_TYPE,

    then the EGL_SWAP_BEHAVIOR attribute of a surface can be specified to preserve

    color buffer contents using eglSurfaceAttrib (see section 3.5.6).

    If EGL_VG_COLORSPACE_LINEAR_BIT is set in EGL_SURFACE_TYPE, then

    the EGL_VG_COLORSPACE attribute may be set to EGL_VG_COLORSPACE_-

    LINEAR when creating a window, pixmap, or pbuffer surface (see section 3.5).

    If EGL_VG_ALPHA_FORMAT_PRE_BIT is set in EGL_SURFACE_TYPE, then the

    EGL_VG_ALPHA_FORMAT attribute may be set to EGL_VG_ALPHA_FORMAT_PRE

    when creating a window, pixmap, or pbuffer surface (see section 3.5).

    */

    m_surfaceType = EGL_WINDOW_BIT |

                    EGL_PBUFFER_BIT | 

                    //EGL_VG_COLORSPACE_LINEAR_BIT |

                    EGL_VG_ALPHA_FORMAT_PRE_BIT |

                    EGL_SWAP_BEHAVIOR_PRESERVED_BIT;

    m_colorDescriptor.SetSurfaceType( m_surfaceType );

    m_surfaceType |= EGL_VG_COLORSPACE_LINEAR_BIT;

    /*

    If EGL_TRANSPARENT_TYPE is EGL_NONE, then the values for EGL_-

    TRANSPARENT_RED_VALUE, EGL_TRANSPARENT_GREEN_VALUE, and EGL_-

    TRANSPARENT_BLUE_VALUE are undefined. Otherwise, they are interpreted as

    integer framebuffer values between 0 and the maximum framebuffer value for the

    component. For example, EGL_TRANSPARENT_RED_VALUE will range between 0

    and 2EGL_RED_SIZE 1.

    */

    return ret;

    }

EGLBoolean CEGLConfig::SetAttribute( EGLint attribute, EGLint value )

    {

    EGLBoolean ret = EGL_FALSE;

    switch( attribute )

        {

        case EGL_BUFFER_SIZE:

            {

            if( value == EGL_DONT_CARE ||

                value >= 0 )

                {

                m_bufferSize = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_BLUE_SIZE:

        case EGL_GREEN_SIZE:

        case EGL_RED_SIZE:

        case EGL_LUMINANCE_SIZE:

        case EGL_ALPHA_SIZE:

        case EGL_ALPHA_MASK_SIZE:

            {

            if( (value == EGL_DONT_CARE ||

                 value >= 0) )

                {

                m_colorDescriptor.SetAttribute( attribute, value );

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_COLOR_BUFFER_TYPE:

            {

            if( (value == EGL_DONT_CARE ||

                 value == EGL_RGB_BUFFER ||

                 value == EGL_LUMINANCE_BUFFER) )

                {

                m_colorDescriptor.SetAttribute( attribute, value );

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_DEPTH_SIZE:

            {

            if( value == EGL_DONT_CARE ||

                value >= 0 )

                {

                m_depthSize = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_STENCIL_SIZE:

            {

            if( value == EGL_DONT_CARE ||

                value >= 0 )

                {

                m_stencilSize = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_CONFIG_CAVEAT:

            {

            if( value == EGL_DONT_CARE ||

                value == EGL_NONE ||

                value == EGL_SLOW_CONFIG ||

                value == EGL_NON_CONFORMANT_CONFIG )

                {

                m_configCaveat = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_CONFIG_ID:

            {

            if( value == EGL_DONT_CARE ||

                value > 0 )

                {

                m_configId = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_LEVEL:

            {

            // \todo validate value

            m_level = value;

            ret = EGL_TRUE;

            break;

            }

        case EGL_NATIVE_VISUAL_ID:

        case EGL_MAX_PBUFFER_HEIGHT:

        case EGL_MAX_PBUFFER_PIXELS:

        case EGL_MAX_PBUFFER_WIDTH:

            {

            // \todo?

            break;

            }

        case EGL_NATIVE_RENDERABLE:

            {

            if( value == EGL_DONT_CARE ||

                value == EGL_TRUE ||

                value == EGL_FALSE )

                {

                m_nativeRenderable = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_NATIVE_VISUAL_TYPE:

            {

            if( value == EGL_DONT_CARE ||

                value >= 0 )

                {

                m_nativeVisualType = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_SAMPLES:

            {

            if( value == EGL_DONT_CARE ||

                value >= 0 )

                {

                m_samples = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_SAMPLE_BUFFERS:

            {

            if( value == EGL_DONT_CARE ||

                value >= 0 )

                {

                m_sampleBuffers = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_SURFACE_TYPE:

            {

            if( (value == EGL_DONT_CARE ||

                !(value & ~(EGL_WINDOW_BIT |

                            EGL_PIXMAP_BIT |

                            EGL_PBUFFER_BIT |

                            EGL_MULTISAMPLE_RESOLVE_BOX_BIT |

                            EGL_SWAP_BEHAVIOR_PRESERVED_BIT |

                            EGL_VG_COLORSPACE_LINEAR_BIT |

                            EGL_VG_ALPHA_FORMAT_PRE_BIT))) )

                {

                m_colorDescriptor.SetSurfaceType(value);

                m_surfaceType = value;

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_TRANSPARENT_TYPE:

            {

            if( (value == EGL_DONT_CARE ||

                 value == EGL_NONE ||

                 value == EGL_TRANSPARENT_RGB) )

                {

                m_transparentColor.SetAttribute( attribute, value );

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_TRANSPARENT_BLUE_VALUE:

        case EGL_TRANSPARENT_GREEN_VALUE:

        case EGL_TRANSPARENT_RED_VALUE:

            {

            if( value == EGL_DONT_CARE ||

                value >= 0 )

                {

                // \todo If EGL_TRANSPARENT_TYPE is EGL_NONE, then the values for EGL_-

                //       TRANSPARENT_RED_VALUE, EGL_TRANSPARENT_GREEN_VALUE, and EGL_-

                //       TRANSPARENT_BLUE_VALUE are undefined. Otherwise, they are interpreted as

                //       integer framebuffer values between 0 and the maximum framebuffer value for the

                //       component. For example, EGL_TRANSPARENT_RED_VALUE will range between 0

                //       and 2^EGL_RED_SIZE - 1.

                m_transparentColor.SetAttribute( attribute, value );

                ret = EGL_TRUE;

                }

            break;

            }

        case EGL_BIND_TO_TEXTURE_RGB:

            {

            if( value == EGL_DONT_CARE ||