/*
* 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 "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:  CHWVGSurfaceImpl source file
 *
*/

#include <eikenv.h>

#ifdef DEBUG_RENDERER
#include <e32debug.h>
#endif

#include "HWVGSurfaceImpl.h"

CHWVGSurfaceImpl::CHWVGSurfaceImpl(TUint8 aOption)
    : iSurfaceType (aOption)
    {
#ifdef HWRENDERER
    iEglDisplay                 = EGL_NO_DISPLAY;
    iEglSurface                 = EGL_NO_SURFACE;
    iEglPBufferSurface_Client   = EGL_NO_SURFACE;
    iEglContext                 = EGL_NO_CONTEXT;
#endif
    }

CHWVGSurfaceImpl::~CHWVGSurfaceImpl()
    {
    }

inline void CHWVGSurfaceImpl::ConstructL()
    {
    }

CHWVGSurfaceImpl* CHWVGSurfaceImpl::NewL(TUint8 aOption)
    {
    CHWVGSurfaceImpl* self = CHWVGSurfaceImpl::NewLC(aOption);
    CleanupStack::Pop();
    return self;
    }

CHWVGSurfaceImpl* CHWVGSurfaceImpl::NewLC(TUint8 aOption)
    {
    CHWVGSurfaceImpl* self = new (ELeave)CHWVGSurfaceImpl(aOption);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

TInt CHWVGSurfaceImpl::MapEGLErrorCodeToSymbian(TInt aErrorCode)
    {
    switch (aErrorCode)
        {
        case EGL_SUCCESS:
            return KErrNone;
        case EGL_NOT_INITIALIZED:
            return KErrNotReady;
        case EGL_BAD_ACCESS:
            return KErrPermissionDenied;
        case EGL_BAD_ALLOC:
            return KErrNoMemory;
        case EGL_BAD_CONTEXT:
        case EGL_BAD_CURRENT_SURFACE:
        case EGL_BAD_DISPLAY:
        case EGL_BAD_SURFACE:
        case EGL_BAD_NATIVE_PIXMAP:
        case EGL_BAD_NATIVE_WINDOW:
        case EGL_CONTEXT_LOST:
            return KErrBadHandle;
        case EGL_BAD_CONFIG:
        case EGL_BAD_PARAMETER:
        case EGL_BAD_MATCH:
        case EGL_BAD_ATTRIBUTE:
            return KErrArgument;
        default:
            return KErrUnknown;
        }
    }

TInt CHWVGSurfaceImpl::InitializeSurface(TSize aSize, TInt /*aColorSpace*/)
    {
#ifdef HWRENDERER
     if((aSize.iWidth==iSize.iWidth) && (aSize.iHeight==iSize.iHeight))
         {
         return 0;
         }
     
    if (iSurfaceType == SURFACE_PBUFFER)
        {
        iSize = aSize;
        iEglDisplay = eglGetDisplay( EGL_DEFAULT_DISPLAY );
        if ( iEglDisplay == EGL_NO_DISPLAY )
            {
            return MapEGLErrorCodeToSymbian(eglGetError());
            }
        if ( eglInitialize( iEglDisplay, 0, 0 ) == EGL_FALSE )
            {
            return MapEGLErrorCodeToSymbian(eglGetError());
            }
        if ( eglBindAPI(EGL_OPENVG_API) == EGL_FALSE)
            {
            return MapEGLErrorCodeToSymbian(eglGetError());
            }
        }
    else
        {
        return KErrNotSupported;
        }
    return KErrNone;
#else
    return KErrNotSupported;
#endif
    }

void CHWVGSurfaceImpl::SetConfiguration(TInt /*aOption*/, const TAny* /*aValue*/)
    {
    //TODO
    }

TInt CHWVGSurfaceImpl::CreateSurface(TInt aDisplayMode, RWindow */*aSurface*/, CFbsBitmap *aBitmap)
    {
#ifdef HWRENDERER
    if (iSurfaceType == SURFACE_PBUFFER)
        {
        EGLConfig *configList   = 0;
        EGLint numOfConfigs     = 0; 
        EGLint configSize       = 0;
        
        if ( eglGetConfigs( iEglDisplay, configList, configSize, &numOfConfigs ) == EGL_FALSE )
            {
            return MapEGLErrorCodeToSymbian(eglGetError());
            }
        
        configSize = numOfConfigs;
        
        configList = (EGLConfig*) User::Alloc( sizeof(EGLConfig)*configSize );
        if ( configList == NULL )
            {
            return MapEGLErrorCodeToSymbian(eglGetError());
            }
        

        TInt BufferSize = TDisplayModeUtils::NumDisplayModeBitsPerPixel(EColor16MA);// / 8;

/*        const EGLint attribList[] =
            {
            EGL_BUFFER_SIZE,            BufferSize,
            EGL_RED_SIZE,             5,
            EGL_GREEN_SIZE,           6,
            EGL_BLUE_SIZE,            5,
            EGL_ALPHA_SIZE,           0,
            EGL_RENDERABLE_TYPE,        EGL_OPENVG_BIT,
            EGL_SURFACE_TYPE,           EGL_PBUFFER_BIT,
            EGL_NONE
            };
*/

        const EGLint attribList[] = { 
                 EGL_RENDERABLE_TYPE,EGL_OPENVG_BIT,
                 EGL_SURFACE_TYPE,         EGL_PBUFFER_BIT,
                 EGL_RED_SIZE, 8,
                 EGL_GREEN_SIZE, 8,
                 EGL_BLUE_SIZE, 8,
                 EGL_ALPHA_SIZE, 8,
                 EGL_NONE 
                };

        if ( eglChooseConfig( iEglDisplay, attribList, configList, configSize, 
                              &numOfConfigs ) == EGL_FALSE )
            {
            User::Free( configList );
            return MapEGLErrorCodeToSymbian(eglGetError());
            }

        iConfig = configList[0]; 
        User::Free( configList ); 

        if ( aBitmap != 0 )
            {
            iSize = aBitmap->SizeInPixels();
            }

        return CreatePBufferSurface();
        }
    else
        {
        return KErrNotSupported;
        }
#else
    return KErrNotSupported;
#endif
    }

TInt CHWVGSurfaceImpl::CreatePBufferSurface()
    {
#ifdef HWRENDERER
    const EGLint attribList[] = { EGL_WIDTH,
                                        iSize.iWidth,
                                        EGL_HEIGHT,
                                        iSize.iHeight,
                                        EGL_NONE };

    iEglSurface = eglCreatePbufferSurface( iEglDisplay, iConfig, attribList );
    if (iEglSurface == EGL_NO_SURFACE)
        {
        return MapEGLErrorCodeToSymbian(eglGetError());
        }

    if (iEglContext == EGL_NO_CONTEXT)
        {
        iEglContext = eglCreateContext( iEglDisplay, iConfig, EGL_NO_CONTEXT, NULL );
        }

    if (iEglContext == EGL_NO_CONTEXT)
        {
        return MapEGLErrorCodeToSymbian(eglGetError());
        }
    if ( eglMakeCurrent( iEglDisplay, iEglSurface, iEglSurface, iEglContext ) == EGL_FALSE )
        {
           return MapEGLErrorCodeToSymbian(eglGetError());
        }
    return KErrNone;
#else
    return KErrNotSupported;
#endif
    }

TInt CHWVGSurfaceImpl::ResizeSurface(TSize aSize)
    {
#ifdef HWRENDERER
    if((aSize.iWidth==iSize.iWidth) && (aSize.iHeight==iSize.iHeight))
        return KErrNone;

    if (iSurfaceType == SURFACE_PBUFFER)
        {
        if (iEglDisplay)
            {
            eglMakeCurrent( iEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
            eglDestroySurface( iEglDisplay, iEglSurface ); 
            //eglDestroyContext( iEglDisplay, iEglContext );
            }

        iSize = aSize;
        return CreatePBufferSurface();
        }
    else
        {
        return KErrNotSupported;
        }
#else
    return KErrNotSupported;
#endif
    }

TInt CHWVGSurfaceImpl::CopyBitmap(TInt /*aDisplayMode*/,TInt aMaskMode, CFbsBitmap *aBitmap, CFbsBitmap */*aMask*/, TSize /*BmpSize*/)
    {
#ifdef HWRENDERER
    if (iSurfaceType == SURFACE_PBUFFER)
        {
        eglCopyBuffers( iEglDisplay, iEglSurface, aBitmap );
        }
#endif
    }

TInt CHWVGSurfaceImpl::PrepareToBindClientBuffer()
    {
    return KErrNone;
    }



TInt CHWVGSurfaceImpl::BindClientBuffer(TInt buffer)
    {
#ifdef HWRENDERER
    iEglPBufferSurface_Client = eglCreatePbufferFromClientBuffer(iEglDisplay, EGL_OPENVG_IMAGE, buffer, iConfig, 0);

    if (iEglPBufferSurface_Client == EGL_NO_SURFACE)
        {
#ifdef DEBUG_RENDERER        
        RDebug::Print(_L("eglCreatePbufferFromClientBuffer Failed %x "), eglGetError());
#endif
        return KErrGeneral;
        }

    eglMakeCurrent( iEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
    if ( eglMakeCurrent( iEglDisplay, iEglPBufferSurface_Client, iEglPBufferSurface_Client, iEglContext ) == EGL_FALSE )
        {

#ifdef DEBUG_RENDERER        
        RDebug::Print(_L("eglMakeCurrent Failed %x "), eglGetError());
#endif
        return KErrGeneral;
        }

#endif
    return KErrNone;
    }

  

TInt CHWVGSurfaceImpl::UnBindClientBuffer()
    {
#ifdef HWRENDERER

    eglMakeCurrent( iEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );

    if (iEglPBufferSurface_Client)
        {
        eglDestroySurface( iEglDisplay, iEglPBufferSurface_Client );
        iEglPBufferSurface_Client = EGL_NO_SURFACE;
        }

    if ( eglMakeCurrent( iEglDisplay, iEglSurface, iEglSurface, iEglContext ) == EGL_FALSE )
        {
        return KErrGeneral;
        }
#endif
    return KErrNone;
    }



void CHWVGSurfaceImpl::TerminateSurface()
    {
#ifdef HWRENDERER
    if (iEglDisplay != EGL_NO_DISPLAY)
        {
        eglMakeCurrent( iEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
        if (iEglSurface)
            {
            eglDestroySurface( iEglDisplay, iEglSurface );
            }

        if (iEglContext)
            {
            eglDestroyContext( iEglDisplay, iEglContext );
            }

        eglTerminate( iEglDisplay );
        iEglDisplay = EGL_NO_DISPLAY;
        }
#endif
    }