diff -r 000000000000 -r d46562c3d99d svgtopt/VGRenderer/HWVG/src/HWVGSurfaceImpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/svgtopt/VGRenderer/HWVG/src/HWVGSurfaceImpl.cpp Thu Jan 07 16:19:02 2010 +0200 @@ -0,0 +1,353 @@ +/* +* 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 + +#ifdef DEBUG_RENDERER +#include +#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 + }