// Copyright (c) 2007-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:

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "egltest_surface.h"

#include "egltest_endpoint_images.h"

#include <graphics/surfaceconfiguration.h>

#define SURF_ASSERT(x) { if (!(x)) { RDebug::Printf("ASSERT(%s) failed at %s:%d", #x, __FILE__, __LINE__); User::Panic(_L("ASSERT SURF"), __LINE__); }}

// Macros for indicating what is what.

#define SIZE(x, y) x, y

#define Buffers(x) x

#define DefaultAlignment 32  // Pick some value that is valid.

#define Alignment(x) x

#define Stride(x) x

#define DefaultStride 0

// Note: Offset to first buffer.

#define Offset(x) x

#define WindowPos(x, y)  x, y

#define WindowMode(m) m

static const TSurfaceParamsCommon KSurfaceParams[] =

{

    {

        EStandardSurface,

        SIZE(100, 100),

        Buffers(2),

        DefaultAlignment,

        DefaultStride,

        Offset(0),

        EUidPixelFormatARGB_8888_PRE,

        EFalse,

        { 0 },

        WindowPos(0, 0),

        WindowMode(EColor16MAP)

    },

    {

        EBadAttribSurface,

        SIZE(100, 100),

        Buffers(2),

        DefaultAlignment,

        DefaultStride,

        Offset(0),

        EUidPixelFormatARGB_8888_PRE,

        ETrue,

        { 1, 1, EGL_NONE },

        WindowPos(0, 0),

        WindowMode(EColor16MAP)

    },

    {

        EEmptyAttribSurface,

        SIZE(100, 100),

        Buffers(2),

        DefaultAlignment,

        DefaultStride,

        Offset(0),

        EUidPixelFormatARGB_8888_PRE,

        ETrue,

        { EGL_NONE },

        WindowPos(0, 0),

        WindowMode(EColor16MAP)

    },

    {

        EStandard128sqSurface,

        SIZE(128, 128),

        Buffers(3),

        DefaultAlignment,

        DefaultStride,

        Offset(0),

        EUidPixelFormatARGB_8888_PRE,

        EFalse,

        { 0 },

        WindowPos(20, 20),

        WindowMode(EColor16MAP)

    },

    {

        EUnusualStrideSurface,

        SIZE(167,263),

        Buffers(2),

        Alignment(8),

        Stride(167*4+64),

        Offset(200),

        EUidPixelFormatARGB_8888_PRE,

        EFalse,

        { 0 },

        WindowPos(0, 0),

        WindowMode(EColor16MAP)

    },

    {

        EUnalignedPixelSizeSurface,

        SIZE(103, 107),

        Buffers(2),

        Alignment(8),

        Stride(103*4),

        Offset(0),

        EUidPixelFormatARGB_8888_PRE,

        EFalse,

        { 0 },

        WindowPos(0, 0),

        WindowMode(EColor16MAP)

    },

    {

        ELargeSurface,

        SIZE(800, 600),

        Buffers(2),

        DefaultAlignment,

        DefaultStride,

        Offset(0),

        EUidPixelFormatARGB_8888_PRE,

        EFalse,

        { 0 },

        WindowPos(0, 0),

        WindowMode(EColor16MAP)

    },

};

TInt KSurfaceMaxIndex = sizeof(KSurfaceParams) / sizeof(KSurfaceParams[0]);

CRawSurface* CRawSurface::NewL()

    {

    CRawSurface* obj = new (ELeave) CRawSurface();

    CleanupStack::PushL(obj);

    obj->ConstructL();

    CleanupStack::Pop(obj);

    return obj;

    }

CRawSurface::CRawSurface() : iDrawBuffer(0), iBuffers(0)

    {

    }

void CRawSurface::ConstructL()

    {

    iSurfaceId = TSurfaceId::CreateNullId();

    User::LeaveIfError(iSurfaceManager.Open());

    User::LeaveIfError(iSurfaceUpdate.Connect(5));

    }

CRawSurface::~CRawSurface()

    {

    iSurfaceUpdate.Close();

    if(!iSurfaceId.IsNull())

        {

        iSurfaceManager.CloseSurface(iSurfaceId);

        }

    iSurfaceManager.Close();

    }

TInt CRawSurface::PixelSize(TUidPixelFormat aPixelFormat)

    {

    switch(aPixelFormat)

        {

        case EUidPixelFormatARGB_8888_PRE:

        case EUidPixelFormatARGB_8888:

        case EUidPixelFormatABGR_8888:

        case EUidPixelFormatABGR_8888_PRE:

            return 4;

        case EUidPixelFormatARGB_4444:

        case EUidPixelFormatRGB_565:

            return 2;

        default:

            SURF_ASSERT(0);

            break;

        }

    return 0; // Make sure no compiler moans about "not all paths return a value".

    }

void CRawSurface::GetSurfAttribs(RSurfaceManager::TSurfaceCreationAttributesBuf &aSurfaceAttribs, TInt aIndex)

    {

    SURF_ASSERT(aIndex < KSurfaceMaxIndex);

    SURF_ASSERT(aIndex == KSurfaceParams[aIndex].iIndex);

    iParamIndex = aIndex;

    aSurfaceAttribs().iSize = TSize(KSurfaceParams[aIndex].iXSize, KSurfaceParams[aIndex].iYSize);

    iBuffers = KSurfaceParams[aIndex].iBuffers;

    aSurfaceAttribs().iBuffers = iBuffers;

    aSurfaceAttribs().iPixelFormat = KSurfaceParams[aIndex].iPixelFormat;

    TInt stride = KSurfaceParams[aIndex].iStrideInBytes;

    if (stride == 0)

        {

        stride = KSurfaceParams[aIndex].iXSize * PixelSize(KSurfaceParams[aIndex].iPixelFormat);

        }

    aSurfaceAttribs().iStride = stride;

    aSurfaceAttribs().iOffsetToFirstBuffer = KSurfaceParams[aIndex].iOffsetToFirstBuffer;

    aSurfaceAttribs().iAlignment = KSurfaceParams[aIndex].iAlignment;

    aSurfaceAttribs().iContiguous = EFalse;

    aSurfaceAttribs().iCacheAttrib = RSurfaceManager::ECached;

    aSurfaceAttribs().iOffsetBetweenBuffers = 0;

    aSurfaceAttribs().iSurfaceHints = NULL;

    aSurfaceAttribs().iHintCount = 0;

    aSurfaceAttribs().iMappable = ETrue;

    }

//From CSurface.

void CRawSurface::CreateL(TInt aIndex)

    {

    RSurfaceManager::TSurfaceCreationAttributesBuf surfaceAttribs;

    GetSurfAttribs(surfaceAttribs, aIndex);

    TInt err = iSurfaceManager.CreateSurface(surfaceAttribs, iSurfaceId);

    User::LeaveIfError(err);

    }

TUint8* CRawSurface::MapSurfaceAndGetInfoLC(RSurfaceManager::TSurfaceInfoV01& aInfo)

    {

    SURF_ASSERT(!iSurfaceId.IsNull());

    User::LeaveIfError(iSurfaceManager.MapSurface(iSurfaceId, iSurfaceChunk));

    CleanupClosePushL(iSurfaceChunk);

    RSurfaceManager::TInfoBuf infoBuf;

    User::LeaveIfError(iSurfaceManager.SurfaceInfo(iSurfaceId, infoBuf));

    aInfo = infoBuf();

    TInt offset = -1000;  // So we hopefully detect when it goes horribly wrong.

    User::LeaveIfError(iSurfaceManager.GetBufferOffset(iSurfaceId, iDrawBuffer, offset));

    return iSurfaceChunk.Base() + offset;

    }

void CRawSurface::DrawContentL(TInt aImageIndex)

    {

    CTestCFbsImage *image = CTestCFbsImage::NewL(aImageIndex);

    CleanupStack::PushL(image);

    RSurfaceManager::TSurfaceInfoV01 info;

    TUint8 *dataAddress = MapSurfaceAndGetInfoLC(info);

    TInt stride = info.iStride;

    CFbsBitmap *bitmap = image->Bitmap();

    TDisplayMode displaymode = bitmap->DisplayMode();

    TInt pixelStride = stride / CFbsBitmap::ScanLineLength(1, displaymode);

    for(TInt y = 0; y < image->Size().iHeight; y++)

        {

        TPtr8 buf(dataAddress + y * stride, stride);

        // TODO: We need to check that the bitsperpixel matches between the surface and bitmap.

        bitmap->GetScanLine(buf, TPoint(0, y), pixelStride, displaymode);

        }

    CleanupStack::PopAndDestroy(2, image);

    }

void CRawSurface::DrawContentL(const TRgb& aColour)

    {

    //Map the surface and get its info.

    RSurfaceManager::TSurfaceInfoV01 surfaceInfo;

    TUint32* buffer = (TUint32*)MapSurfaceAndGetInfoLC(surfaceInfo);

    //Currently this function only supports drawing into ARGB_8888_PRE surfaces.

    //This is because the only test that uses this function uses this type of surface.

    //If this functionallity needs expanding, you must correctly convert the TRgb colour

    //and pack it into the surface buffer correctly.

    SURF_ASSERT(surfaceInfo.iPixelFormat == EUidPixelFormatARGB_8888_PRE);

    TUint32 fillColour = aColour._Color16MAP();

    //Loop over each pixel in the surface and colour it.

    //This is deliberately slow since it is only used for the tearing test

    //and we want to spend most of our time drawing so that the chances of the other thread

    //picking up a buffer in the middle of drawing is increased.

    for(TInt y=0; y < surfaceInfo.iSize.iHeight; ++y)

        {

        for(TInt x=0; x < surfaceInfo.iSize.iWidth; ++x)

            {

            buffer[x] = fillColour;

            }

        buffer += surfaceInfo.iStride >> 2;

        }

    CleanupStack::PopAndDestroy();

    }

void CRawSurface::SubmitContentL(TBool aShouldWaitForDisplay, TInt /* aRectsIndex */)

    {

    TRequestStatus displayNotify = KRequestPending;

    TTimeStamp timeStamp;

    if(aShouldWaitForDisplay)

        {

        Notify(ENotifyWhenDisplayed, displayNotify, 0);

        }

    TInt err = iSurfaceUpdate.SubmitUpdate(KAllScreens, iSurfaceId, iDrawBuffer, NULL);

    User::LeaveIfError(err);

    iDrawBuffer = (iDrawBuffer + 1) % iBuffers;

    if(aShouldWaitForDisplay)

        {

        TUint32 dummy;

        TInt err = WaitFor(ENotifyWhenDisplayed, displayNotify, 100 * 1000, dummy);

        if (err != KErrNone && err != KErrNotVisible && err != KErrOverflow)

            {

            RDebug::Printf("%s:%d: NotifyWhenDisplayed gave unexpected error %d", __FILE__, __LINE__, err);

            User::Leave(err);

            }

        }

    }

TSurfaceId CRawSurface::SurfaceId() const

    {

    return iSurfaceId;

    }

void CRawSurface::GetSurfaceParamsL(TSurfaceParamsRemote &aParams)

    {

    aParams.iCommonParams = KSurfaceParams[iParamIndex];

    aParams.iCommonParams.iBuffers = iBuffers; // May have been changed if it's a single buffered surface...

    aParams.iSurfaceId = SurfaceId();

    }

const TText *CRawSurface::GetSurfaceTypeStr() const

    {

    return _S("CRawSurface");

    }

TInt CRawSurface::Notify(TNotification aWhen, TRequestStatus& aStatus, TUint32 aXTimes)

    {

    aStatus = KRequestPending;

    switch(aWhen)

        {

        case ENotifyWhenAvailable:

            iSurfaceUpdate.NotifyWhenAvailable(aStatus);

            break;

        case ENotifyWhenDisplayed:

            iSurfaceUpdate.NotifyWhenDisplayed(aStatus, iTimeStamp);

            break;

        case ENotifyWhenDispXTimes:

            iSurfaceUpdate.NotifyWhenDisplayedXTimes(aXTimes, aStatus);

            break;

        default:

            RDebug::Printf("%s:%d: Invalid notification: %d. Panicking...", __FILE__, __LINE__, aWhen);

            User::Panic(_L("CRawSurface::Notify()"), __LINE__);

            break;

        }

    return KErrNone;

    }

TInt CRawSurface::WaitFor(TNotification aWhen, TRequestStatus& aStatus, TInt aTimeoutInMicroSeconds, TUint32& aTimeStamp)

    {

    RTimer timer;

    TInt err = timer.CreateLocal();

    if (err != KErrNone)

        {

        return err;

        }

    TRequestStatus timerStatus = KRequestPending;

#if __WINS__

    // Windows timer isn't very precise - add some "fuzz" to the timeout to ensure we do not wait "too little".

    const TInt KTimeOutExtra = 20000;

#else

    // On hardware, we should be able to run with less "fuzz".

    const TInt KTimeOutExtra = 10000;

#endif

    timer.HighRes(timerStatus, aTimeoutInMicroSeconds + KTimeOutExtra);

    User::WaitForRequest(timerStatus, aStatus);

    if (aStatus == KRequestPending)

        {

        if (aWhen == ENotifyWhenDisplayed)

            {

            aTimeStamp = User::FastCounter();

            }

        return KErrTimedOut;

        }

    if (aWhen == ENotifyWhenDisplayed)

        {

        aTimeStamp = iTimeStamp();

        }

    timer.Cancel();

    timer.Close();

    TInt result = aStatus.Int();

    aStatus = KRequestPending;

    return result;

    }

const TText *CRawSingleBufferSurface::GetSurfaceTypeStr() const

    {

    return _S("CRawSingleBufferedSurface");

    }

CRawSingleBufferSurface *CRawSingleBufferSurface::NewL()

    {

    CRawSingleBufferSurface* obj = new (ELeave) CRawSingleBufferSurface();

    CleanupStack::PushL(obj);

    obj->ConstructL();

    CleanupStack::Pop(obj);

    return obj;

    }

void CRawSingleBufferSurface::CreateL(TInt aIndex)

    {

    RSurfaceManager::TSurfaceCreationAttributesBuf surfaceAttribs;

    GetSurfAttribs(surfaceAttribs, aIndex);

    iBuffers = 1;

    surfaceAttribs().iBuffers = 1;

    TInt err = iSurfaceManager.CreateSurface(surfaceAttribs, iSurfaceId);

    User::LeaveIfError(err);

    }

CRawSingleBufferSurface::~CRawSingleBufferSurface()

    {

    }

class CWindow: public CBase

    {

public:

    static CWindow *NewL(TInt aIndex);

    RWindow& Window();

    ~CWindow();

private:

    void ConstructL(TInt aIndex);

    CWindow();

private:

    RWindow iWindow;

    RWindowGroup iWindowGroup;

    RWsSession iWsSession;

    };

CWindow* CWindow::NewL(TInt aIndex)

    {

    CWindow *self = new (ELeave) CWindow;

    CleanupStack::PushL(self);

    self->ConstructL(aIndex);

    CleanupStack::Pop(self);

    return self;

    }

void CWindow::ConstructL(TInt aIndex)

    {

    RFbsSession::Connect();

    if (aIndex >= KSurfaceMaxIndex)

        {

        User::Leave(KErrOverflow);

        }

    User::LeaveIfError(iWsSession.Connect());

    iWindowGroup = RWindowGroup(iWsSession);

    User::LeaveIfError(iWindowGroup.Construct((TUint32)this));

    iWindow = RWindow(iWsSession);

    User::LeaveIfError(iWindow.Construct(iWindowGroup, -1U));

    const TSurfaceParamsCommon& winAttrib = KSurfaceParams[aIndex];

    iWindow.SetExtent(TPoint(winAttrib.iXPos, winAttrib.iYPos), TSize(winAttrib.iXSize, winAttrib.iYSize));

    iWindow.SetRequiredDisplayMode(winAttrib.iDisplayMode);

    iWindow.Activate();

    }

CWindow::~CWindow()

    {

    iWindow.Close();

    iWindowGroup.Close();

    iWsSession.Close();

    RFbsSession::Disconnect();

    }

CWindow::CWindow()

    {

    }

RWindow& CWindow::Window()

    {

    return iWindow;

    }

CEglWindowSurface* CEglWindowSurface::NewL()

    {

    CEglWindowSurface* self = new (ELeave) CEglWindowSurface;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CEglWindowSurface::ConstructL()

    {

    }

CEglWindowSurface::CEglWindowSurface()

    {

    }

void CEglWindowSurface::CreateL(TInt aIndex)

    {

    SURF_ASSERT(aIndex < KSurfaceMaxIndex);