// 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)

    },

};

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());

    }

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".

    }

    {

    SURF_ASSERT(aIndex < KSurfaceMaxIndex);

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

    iParamIndex = aIndex;

    iBuffers = KSurfaceParams[aIndex].iBuffers;

    aSurfaceAttribs().iBuffers = iBuffers;

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

    TInt stride = KSurfaceParams[aIndex].iStrideInBytes;

    if (stride == 0)

        {

        }

    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;

    }

    {

    RSurfaceManager::TSurfaceCreationAttributesBuf surfaceAttribs;

    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();

    }

    {

    TRequestStatus displayNotify = KRequestPending;

    TTimeStamp timeStamp;

    if(aShouldWaitForDisplay)

        {

        Notify(ENotifyWhenDisplayed, displayNotify, 0);

        }

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

    iDrawBuffer = (iDrawBuffer + 1) % iBuffers;

    if(aShouldWaitForDisplay)

        {

        TUint32 dummy;

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

            {

            }

        }

    }

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);