/* 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 "ColorDescriptor.h"
#include "eglInternal.h"

CColorDescriptor::CColorDescriptor(EGLint red, EGLint green, EGLint blue, 
                             EGLint luminance, bool nonlinear, EGLint alpha, bool premultiplied,
                             EGLint alphaMask, EGLint bpp) :
    m_bpp( bpp ),
    m_redSize( red ),
    m_greenSize( green ),
    m_blueSize( blue ),
    m_luminanceSize( luminance ),
    m_alphaSize( alpha ),
    m_alphaMaskSize( alphaMask )
    {
    unsigned int f  = 0;

    if (nonlinear)
        f |= NONLINEAR;
   
    if (premultiplied)
        f |= PREMULTIPLIED;
   
    if ( luminance )
        f |= LUMINANCE;

    m_format = (ColorFormat)f;

    }

void CColorDescriptor::Set( int red, int green, int blue, int luminance,
                           bool nonlinear, int alpha, bool premultiplied, int alphaMask, int bpp)
    {
    m_bpp = bpp;
    m_redSize = red;
    m_greenSize = green;
    m_blueSize = blue;
    m_luminanceSize = luminance;
    m_alphaSize = alpha;
    m_alphaMaskSize = alphaMask;

    unsigned int f  = 0;
    if (nonlinear)
        f |= NONLINEAR;
   
    if (premultiplied)
        f |= PREMULTIPLIED;
   
    if ( luminance )
        f |= LUMINANCE;

    m_format = (ColorFormat)f;
    }

void CColorDescriptor::SetAttribute( EGLint attribute, EGLint value )
    {
    switch( attribute )
        {
        case EGL_BUFFER_SIZE:
            {
            m_bpp = value;
            break;
            }
        case EGL_RED_SIZE:
            {
            m_redSize = value;
            break;
            }
        case EGL_GREEN_SIZE:
            {
            m_greenSize = value;
            break;
            }
        case EGL_BLUE_SIZE:
            {
            m_blueSize = value;
            break;
            }
        case EGL_LUMINANCE_SIZE:
            {
            m_luminanceSize = value;
            break;
            }
        case EGL_ALPHA_SIZE:
            {
            m_alphaSize = value;
            break;
            }
        case EGL_ALPHA_MASK_SIZE:
            {
            m_alphaMaskSize = value;
            break;
            }
        case EGL_COLOR_BUFFER_TYPE:
            {
            SetColorBufferType(value);
            break;
            }
        case EGL_SURFACE_TYPE:
            SetSurfaceType(value);
            break;
        default:
            EGLI_ASSERT( false );
        }
    }

EGLint CColorDescriptor::GetAttribute( EGLint attribute ) const
    {
    switch( attribute )
        {
        case EGL_RED_SIZE:
            {
            return m_redSize;
            }
        case EGL_GREEN_SIZE:
            {
            return m_greenSize;
            }
        case EGL_BLUE_SIZE:
            {
            return m_blueSize;
            }
        case EGL_LUMINANCE_SIZE:
            {
            return m_luminanceSize;
            }
        case EGL_ALPHA_SIZE:
            {
            return m_alphaSize;
            }
        case EGL_ALPHA_MASK_SIZE:
            {
            return m_alphaMaskSize;
            }
        case EGL_COLOR_BUFFER_TYPE:
            {
            if( isLuminance() )
                return EGL_LUMINANCE_BUFFER;
            else
                return EGL_RGB_BUFFER;
            }
        case EGL_SURFACE_TYPE:
            return GetSurfaceType();
            break;
        default:
            EGLI_ASSERT( false );
            return 0;
        }
    }

/**
 * \brief Set alpha type and color space using bits
 * \note  Be careful not to mix with enumerations. Use the two-parameter version
 *        to set from enums.
 */
void CColorDescriptor::SetSurfaceType(EGLint surfaceType)
{
    unsigned int f = m_format;

    f &= ~PREMULTIPLIED;

    if (surfaceType & EGL_VG_ALPHA_FORMAT_PRE_BIT)
        f |= PREMULTIPLIED;     

    f &= ~NONLINEAR;
    if (!(surfaceType & EGL_VG_COLORSPACE_LINEAR_BIT))
        f |= NONLINEAR;

    m_format = (ColorFormat)f;    
}

/**
 * \brief Set alpha type and color space using enumerations.
 */
void CColorDescriptor::SetSurfaceType(EGLint colorSpace, EGLint alphaType)
{
    unsigned int f = m_format;

    f &= ~PREMULTIPLIED;

    if (alphaType == EGL_VG_ALPHA_FORMAT_PRE)
        f |= PREMULTIPLIED;     

    f &= ~NONLINEAR;
    if (colorSpace == EGL_VG_COLORSPACE_sRGB)
        f |= NONLINEAR;

    m_format = (ColorFormat)f;    
}


EGLint CColorDescriptor::GetSurfaceType() const
{
    EGLint ret = 0;

    if (!(m_format & NONLINEAR))
        ret |= EGL_VG_COLORSPACE_LINEAR_BIT;

    if (m_format & PREMULTIPLIED)
        ret |= EGL_VG_ALPHA_FORMAT_PRE_BIT;

    return ret;
}

void CColorDescriptor::SetColorBufferType( EGLint colorBufferType )
{
    unsigned int f = m_format & (~LUMINANCE);

    switch(colorBufferType)
    {
    case EGL_LUMINANCE_BUFFER:
        f |= LUMINANCE;
        break;
    default:
        EGLI_ASSERT(colorBufferType == EGL_RGB_BUFFER);
        break;
    }

    m_format = (ColorFormat)f;
}

CColorDescriptor& CColorDescriptor::operator=( const CColorDescriptor& rhs )
    {
    if( this == &rhs ) return *this;
    m_bpp = rhs.m_bpp;
    m_redSize = rhs.m_redSize;
    m_greenSize = rhs.m_greenSize;
    m_blueSize = rhs.m_blueSize;
    m_luminanceSize = rhs.m_luminanceSize;
    m_alphaSize = rhs.m_alphaSize;
    m_alphaMaskSize = rhs.m_alphaMaskSize;
    m_format = rhs.m_format;
    return *this;
    }

bool CColorDescriptor::operator==( const CColorDescriptor& rhs ) const
    {
    if( this == &rhs ) return true;
    
    if( isNonlinear() != rhs.isNonlinear() ) return false;
    if( isPremultiplied() != rhs.isPremultiplied() ) return false;

    if( m_alphaSize != rhs.m_alphaSize ) return false;
    if( m_alphaMaskSize != rhs.m_alphaMaskSize ) return false;
    
    if( isLuminance() && rhs.isLuminance()  )
        {
        if( m_luminanceSize != rhs.m_luminanceSize ) return false;        
        }
    else
        {
        if( m_bpp != rhs.m_bpp ) return false;
        if( m_redSize != rhs.m_redSize ) return false;
        if( m_greenSize != rhs.m_greenSize ) return false;
        if( m_blueSize != rhs.m_blueSize ) return false;
        }
    return true;
    }

bool CColorDescriptor::operator!=( const CColorDescriptor& rhs ) const
    {
    return !(operator==(rhs));
    }

bool CColorDescriptor::MatchBitDepth( const CColorDescriptor& desc ) const
    {
    if( m_alphaSize != desc.m_alphaSize ) return false;
    if( isPremultiplied() != desc.isPremultiplied() ) return false;
    if( isLuminance() )
        {
        if( !desc.isLuminance() || (m_luminanceSize != desc.m_luminanceSize ) ) return false;
        }
    else
        {
        if( m_redSize != desc.m_redSize ) return false;
        if( m_greenSize != desc.m_greenSize ) return false;
        if( m_blueSize != desc.m_blueSize ) return false;
        if( isNonlinear() != desc.isNonlinear() ) return false;
        }
    return true;
    }