// Copyright (c) 2008-2009 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: Owns, hides, and provides an interface to the OpenWFC compositor for use by the final (display) render stage.

#include "openwfcwrapper.h"

#include "panic.h"

#include "utils.h"

#include <WF/wfc.h>

#include "elementwrapper.h"

#include <graphics/compositionsurfaceupdate.h>

#include <graphics/symbianstream.h>

#include "openwfcpanics.h"

#include "openwfcjobmanager.h"

#include <graphics/eglsynchelper.h>

#define KRgbaBlack       0x000000FF

void Panic(TOpenWfcPanic aPanic)

    {

    _LIT(KPanic, "OpenWFC");

    User::Panic(KPanic, aPanic);

    }

class COpenWfcWrapper::OffScreenComposeGuard

    {

    public:

        OffScreenComposeGuard(TRequestStatus*& aRequestStatus);

        void SetOffScreenNativeStream(WFCNativeStreamType aNativeStream);

        void SetTargetNativeStream(WFCNativeStreamType aNativeStream);

        void SetSync(EGLSyncKHR aSync, EGLDisplay aDpy);

        void SetDeviceAndContext(WFCDevice aDevice, WFCContext aContext);

        void Close();

        void LogRequestStatusError(TInt aRequestStatusError);

    private:

        TRequestStatus*& iRequestStatus;

        EGLSyncKHR iSync;

        EGLDisplay iEGLDisplay;

        WFCDevice iDevice;

        WFCContext iContext;

        TInt    iRequestStatusError;

    };

COpenWfcWrapper::OffScreenComposeGuard::OffScreenComposeGuard(TRequestStatus*& aRequestStatus):

iRequestStatus(aRequestStatus),

iSync(EGL_NO_SYNC_KHR),

iDevice(WFC_INVALID_HANDLE),

iContext(WFC_INVALID_HANDLE),

iRequestStatusError(KErrNone)

    {}

void COpenWfcWrapper::OffScreenComposeGuard::SetSync(EGLSyncKHR aSync, EGLDisplay aDpy)

    {

    iSync = aSync;

    iEGLDisplay = aDpy;

    }

void COpenWfcWrapper::OffScreenComposeGuard::SetDeviceAndContext(WFCDevice aDevice, WFCContext aContext)

    {

    iContext = aContext; 

    iDevice = aDevice;

    }

void COpenWfcWrapper::OffScreenComposeGuard::LogRequestStatusError(TInt aRequestStatusError)

    {

    iRequestStatusError=aRequestStatusError;

    }

void COpenWfcWrapper::OffScreenComposeGuard::Close()

    {

    if (iContext != WFC_INVALID_HANDLE)

        {

        DestroyAllContextElements(iDevice, iContext);

        wfcDestroyContext(iDevice, iContext);

        }

    if (iSync != EGL_NO_SYNC_KHR)

        {

        eglDestroySyncKHR(iEGLDisplay, iSync);

        }

    if (iRequestStatus)

        {

        User::RequestComplete(iRequestStatus, iRequestStatusError);

        }

    }

TEMPLATE_SPECIALIZATION class RHashTableBase::Defaults<TSurfaceId, RHashTableBase::EDefaultSpecifier_Normal>

    {

public:

    inline static TGeneralHashFunction32 Hash();

    inline static TGeneralIdentityRelation Id();

    };

inline TGeneralHashFunction32 RHashTableBase::Defaults<TSurfaceId, RHashTableBase::EDefaultSpecifier_Normal>::Hash()

    {return (TGeneralHashFunction32)&DefaultHash::Integer;}

inline TGeneralIdentityRelation RHashTableBase::Defaults<TSurfaceId, RHashTableBase::EDefaultSpecifier_Normal>::Id()

    {return (TGeneralIdentityRelation)&DefaultIdentity::Integer;}

TUint32 COpenWfcWrapper::HashFunction(const TSurfaceId& aHashKey)

    {

    TPckgC<TSurfaceId> pckg(aHashKey);

    return DefaultHash::Des8(pckg);

    }

COpenWfcWrapper* COpenWfcWrapper::NewL(TInt aScreenNo, CDisplayPolicy* aDisplayPolicy)

	{

	COpenWfcWrapper* wrapper = new (ELeave) COpenWfcWrapper(aDisplayPolicy);

	CleanupStack::PushL(wrapper);

	wrapper->ConstructL(aScreenNo);

	CleanupStack::Pop(wrapper);

	return wrapper;

	}

COpenWfcWrapper::COpenWfcWrapper(CDisplayPolicy* aDisplayPolicy)

	: iUiSurface(TSurfaceId::CreateNullId()), iDisplayPolicy(aDisplayPolicy),

	iSourceMap(THashFunction32<TSurfaceId>(COpenWfcWrapper::HashFunction), TIdentityRelation<TSurfaceId>()),

	iDevice(WFC_INVALID_HANDLE),

	iOnScreenContext(WFC_INVALID_HANDLE),

	iScreenNumber(-1),

	iJobManager(NULL),

	iRotation(MWsScene::ESceneAntiClockwise0),

	iAutonomousCompositionInitiated(EFalse)

	{

	}

void COpenWfcWrapper::ConstructL(TInt aScreenId)

	{

    _LIT(KOpenWfcLog, "+ COpenWfcWrapper::ConstructL");

    RDebug::Print(KOpenWfcLog);

    iScreenNumber = aScreenId;

    WFCint filterList[] = { WFC_DEVICE_FILTER_SCREEN_NUMBER, iScreenNumber, WFC_NONE};

    iEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    eglInitialize(iEGLDisplay, NULL, NULL);

    WFCint dev = 0;

    if ((wfcEnumerateDevices(&dev, 1, filterList) == 1) &&

        (dev != WFC_INVALID_HANDLE))

        {

        // clean previous errors

        wfcGetError(iDevice);

        // Let's get the device handle, opening in the same time the device

        iDevice = wfcCreateDevice(dev, NULL);

        if (iDevice==NULL)

            {

            //Not enough information to deduce why the device could not be created. Report as memory failure

            User::Leave(KErrNoMemory);

            }

        //Can't clean previous errors until we have a device, and the errors should be none if it created successfully.

        OPENWFC_ASSERT_DEBUG(!wfcGetError(iDevice),EPanicWfcStartupErrorUnexpected);

        iOnScreenContext = wfcCreateOnScreenContext(iDevice, iScreenNumber, NULL);

        if (iOnScreenContext==NULL)

            {

            TInt err = wfcGetError(iDevice);

            OPENWFC_ASSERT_DEBUG(err==WFC_ERROR_OUT_OF_MEMORY,EPanicWfcContextNotCreated);

            User::Leave((err==WFC_ERROR_OUT_OF_MEMORY)?KErrNoMemory:KErrUnknown);

            }

        wfcSetContextAttribi(iDevice, iOnScreenContext, WFC_CONTEXT_ROTATION, WFC_ROTATION_0);

        wfcSetContextAttribi(iDevice, iOnScreenContext, WFC_CONTEXT_BG_COLOR, KRgbaBlack);

        iContextDisplayControl = NULL;

        User::LeaveIfNull(iJobManager = COpenWfcJobManger::NewL(*this, iDevice, iOnScreenContext, iScreenNumber));

        }

    else

        {

        // we cannot continue because we cannot find a device for the given screenId

        // Not enough information to get detailed error! Report as parameter not accepted.

        User::Leave(KErrArgument);

        }

    iSurfaceManager.Open();

    iSourceMap.Reserve(iInitialSourceMapSize);

    }

COpenWfcWrapper::~COpenWfcWrapper()

	{

	iUiElement1 = NULL;

	iUiElement2 = NULL;

    if(!iUiSurface.IsNull())

        UnregisterSurface(iUiSurface);

    if (iJobManager)

        {

        PauseComposition();

        delete iJobManager;

        }

    //destroy all the elements, which should remove all the element references.

    while (iCleanupElementList)

        {

        CElementWrapper* cleanupElement = iCleanupElementList;

        delete cleanupElement;

        OPENWFC_ASSERT_DEBUG(cleanupElement != iCleanupElementList,EPanicWfcElementNotRemovedOnShutdown);

        if (cleanupElement == iCleanupElementList)

            {

            break;  //can't keep cleaning up the same front item

            }

        }

    THashMapIter<TSurfaceId, SourceAndRef> iter(iSourceMap);

    const TSurfaceId* nextKey = iter.NextKey();

    while (nextKey)

        {

        const SourceAndRef* pSource = NULL;

        //destroy any remaining registered surfaces

        pSource = iter.CurrentValue();

        OPENWFC_ASSERT_DEBUG(pSource && pSource->elementRef == 0,EPanicWfcElementNotRemovedOnShutdown);

        wfcDestroySource(iDevice,pSource->source);

        nextKey = iter.NextKey();

        }

    iSourceMap.Close();

    iSurfaceManager.Close();

    eglTerminate(iEGLDisplay);

    // Destroying the context should take care of any sources or masks

    wfcDestroyContext(iDevice, iOnScreenContext);

    wfcDestroyDevice(iDevice);

	}

class CBaseExtension: public CBase

    {

    public:

        virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)

            {   return CBase::Extension_(aExtensionId,a0,a1);   }

    };

TInt COpenWfcWrapper::Extension_(TUint aExtensionId, TAny*& aRetPtr, TAny* aExtra)

    {

#ifndef _DEBUG

    (void) aExtra;

#endif

    switch (aExtensionId)

        {

#ifdef _DEBUG

        case EExtensionDebugBackendGuid:

            return KErrNotSupported;

        case EExtensionDebugContextGuid:

            aRetPtr=(TAny*)OnScreenContext();

            return KErrNone;

        case EExtensionDebugDeviceGuid:

            aRetPtr=(TAny*)Device();

            return KErrNone;

        case EExtensionDebugElementGuid:

            if (aExtra)

                {

                CElementWrapper* newElement=static_cast<CElementWrapper*>(aExtra);

                aRetPtr=(TAny*)newElement->Element();

                return KErrNone;

                }

            else

                {

                return KErrBadHandle;

                }

        case EExtensionDebugSourceGuid:

            if (aExtra)

                {

                TSurfaceId* surfId=static_cast<TSurfaceId*>(aExtra);

                SourceAndRef* foundSourceAndRef=iSourceMap.Find(*surfId);

                if (foundSourceAndRef)

                    {

                    aRetPtr=(TAny*)foundSourceAndRef->source;

                    return KErrNone;

                    }

                else

                    {

                    return KErrNotFound;

                    }

                }

            else

                {

                return KErrBadHandle;

                }

#endif

        case MCompositionSurfaceUpdate::ETypeId:

             {

             CBaseExtension* basePtr = NULL;

             SymbianStreamHasRegisteredScreenNotifications(iScreenNumber,reinterpret_cast<void**>(&basePtr));

             if (basePtr)

                 {

                 return basePtr->Extension_(MCompositionSurfaceUpdate::KUidCompositionSurfaceUpdate,aRetPtr,aExtra);

                 }

             else

                 {

                 return KErrNotSupported;

                 }

             }

        case MWsDisplayControl::ETypeId:

            if (iContextDisplayControl)

                {

                aRetPtr= static_cast<MWsDisplayControl*>(this);

                return KErrNone;

                }

            else

                {

                return KErrNotSupported;

                }

        case MDisplayControlBase::ETypeId:

            if (iContextDisplayControl)

                {

                aRetPtr= static_cast<MDisplayControlBase*>(this);

                return KErrNone;

                }

            else

                {

                return KErrNotSupported;

                }

        default:

            return KErrNotSupported;

        }

    }

MWsElement* COpenWfcWrapper::CreateElementL()

	{

	CElementWrapper* element = CElementWrapper::NewL(*this,iCleanupElementList);

	return element;

	}

void COpenWfcWrapper::DestroyElement(MWsElement* aElement)

	{		

	if(aElement)

	    {	    

	    CElementWrapper* element=static_cast<CElementWrapper*>(aElement);

	    RemoveElementFromSceneList(element);

	    if (!(element->UpdateFlags()&CElementWrapper::EUpdate_SceneCommited))

	          {

	             delete element;

	          }

	    }

	}

void COpenWfcWrapper::Compose(TRequestStatus* aCompleted)

	{

	STD_ASSERT_DEBUG(CompositionDue(), EPluginPanicCompositionSequenceError);

	OPENWFC_ASSERT_DEBUG(iJobManager, EPanicWfcThreadManagerNotInitialised);

    if (!iAutonomousCompositionInitiated)

        {

        ResumeComposition();

        }

    iJobManager->ComposeRequest(aCompleted);

	iCompositionModified = EFalse;

	ResumeCompositorIfPaused();

	}

TSize COpenWfcWrapper::ScreenSize() const

	{

    // clean previous errors

    #ifdef _DEBUG

    (void)wfcGetError(iDevice);

    #endif

    TInt height = wfcGetContextAttribi(iDevice, iOnScreenContext, WFC_CONTEXT_TARGET_HEIGHT);

    OPENWFC_ASSERT_DEBUG(TranslateOpenWfcError(wfcGetError(iDevice)) == KErrNone, EPanicWfcBadAttribute);

    TInt width = wfcGetContextAttribi(iDevice, iOnScreenContext, WFC_CONTEXT_TARGET_WIDTH);

    OPENWFC_ASSERT_DEBUG(TranslateOpenWfcError(wfcGetError(iDevice)) == KErrNone, EPanicWfcBadAttribute);

    WFCint rotation = wfcGetContextAttribi(iDevice, iOnScreenContext, WFC_CONTEXT_ROTATION);

    OPENWFC_ASSERT_DEBUG(TranslateOpenWfcError(wfcGetError(iDevice)) == KErrNone, EPanicWfcBadAttribute);

    return rotation == WFC_ROTATION_0 || rotation == WFC_ROTATION_180 ? TSize(width, height) : TSize(height, width);

	}

TInt COpenWfcWrapper::RegisterSurface (const TSurfaceId& aSurface)

    {

    // clean previous errors

    wfcGetError(iDevice);

    //check surface id not null

    if (aSurface.IsNull())

        {

        return KErrArgument;

        }

    if (!IsValidSurface(aSurface))

        {

        return KErrBadHandle;

        } 

    //look for surface being registered

    SourceAndRef* sourceAndRef = iSourceMap.Find(aSurface);

    if (sourceAndRef)

        {

        //if registered increase ref count and return

        sourceAndRef->sourceRef++;

        return KErrNone;

        }

    // Surface not currently registered so do so now.

    // Initialise struct. Could be handled via. constructor.

    SourceAndRef newSourceAndRef;

    newSourceAndRef.source = NULL;

    newSourceAndRef.sourceRef = 1;    //Surface reference count

    newSourceAndRef.elementRef = 0;   //Element reference count

    //No need to acquire stream as public NativeStream handle is TSurfaceId

    WFCNativeStreamType stream = reinterpret_cast<WFCNativeStreamType>(&aSurface);

    //create source

    newSourceAndRef.source = wfcCreateSourceFromStream(iDevice,iOnScreenContext,stream,NULL);

    //check for valid surface size should be performed by compositor in CreateSource.

    if (newSourceAndRef.source == WFC_INVALID_HANDLE)

        {

        return TranslateOpenWfcError(wfcGetError(iDevice));

        }

    //add to list

    TInt err = iSourceMap.Insert(aSurface,newSourceAndRef);

    if (err != KErrNone)

        {

        wfcDestroySource(iDevice,newSourceAndRef.source);

        return KErrNoMemory;

        }

    return KErrNone;

    }

TInt COpenWfcWrapper::UnregisterSurface (const TSurfaceId& aSurface)

    {

    //check surface id not null

    if (aSurface.IsNull())

        {

        return KErrArgument;

        }

    if (!IsValidSurface(aSurface))

        {

        return KErrArgument;

        }   

    SourceAndRef* sourceAndRef = iSourceMap.Find(aSurface);

    if (sourceAndRef && sourceAndRef->sourceRef == 0)

        {

        sourceAndRef = NULL;

        }

    if (sourceAndRef)

        {

        if (sourceAndRef->sourceRef <= 1)

            {

            sourceAndRef->sourceRef = 0;

            if (sourceAndRef->elementRef > 0)

                {

                //if elements are currently in use

                return KErrInUse;

                }

            wfcDestroySource(iDevice,sourceAndRef->source); //removing source reference on the stream

            //destroy entry

            iSourceMap.Remove(aSurface);

            return KErrNone;

            }

        sourceAndRef->sourceRef--;

        return KErrNone;

        }

    return KErrBadHandle;

    }

TBool COpenWfcWrapper::IsValidSurface(const TSurfaceId& aSurface)

    {

    if (aSurface.Type() != TSurfaceId::EScreenSurface)

        {

        RSurfaceManager::TInfoBuf buff;

        TInt err = SurfaceManager().SurfaceInfo(aSurface, buff);

        if (err == KErrArgument)

            {

            return EFalse;

            }     

        } 

    return ETrue;

    }

/** 

 * Finds the source for a registered surface ID and increments its "element" reference count

 * @return registered source handle or WFC_INVALID_HANDLE if not registered

 **/

WFCSource COpenWfcWrapper::IncEltRefRegSource(const TSurfaceId& aHashKey)

    {

    SourceAndRef* foundSourceAndRef=iSourceMap.Find(aHashKey);

    if (foundSourceAndRef && foundSourceAndRef->sourceRef)

        {   //still registered

        foundSourceAndRef->elementRef++;

        return foundSourceAndRef->source;

        }

    return WFC_INVALID_HANDLE;

    }

/** 

 * Finds the source for a registered surface ID and decrements the "element" reference count.

 * If all counts are zero then the source is unregistered and the mapping removed   

 * @return positive if not destroyed, 0 if destroyed

 *         or KErrBadHandle if bad surface id or surface has no element reference count

 **/

TInt COpenWfcWrapper::DecEltRefRegSource(const TSurfaceId& aHashKey)

    {

    SourceAndRef* foundSourceAndRef=iSourceMap.Find(aHashKey);

    if (foundSourceAndRef && foundSourceAndRef->elementRef>0)

        {

        TInt retRefs=((--foundSourceAndRef->elementRef)+foundSourceAndRef->sourceRef);

        if (retRefs==0)

            {

            wfcDestroySource(iDevice,foundSourceAndRef->source);

            iSourceMap.Remove(aHashKey);

            }

        return retRefs;

        }

    return KErrBadHandle;

    }