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

// Implementation of Test class for OpenWfc Native Stream 

// 

//

#include <graphics/symbianstream.h>

#include <graphics/streammap.h>

#include <graphics/compositionsurfaceupdate.h>

#include <graphics/extensioncontainer.h>

#include <graphics/suerror.h>

#include <test/extendtef.h>

#include <dispchannel.h>

#include <hal.h>

#include "tnativestream.h"

#include "surfaceutility.h"

#include "owftestexithelper.inl"

#define BUFFER_READ_HANDLE_BASE  0x100

#define BUFFER_WRITE_HANDLE_BASE 0x200

#define INDEX_TO_READ_HANDLE(x)  ((SymbianStreamBuffer) ((x)+BUFFER_READ_HANDLE_BASE))

#define INDEX_TO_WRITE_HANDLE(x)  ((SymbianStreamBuffer) ((x)+BUFFER_WRITE_HANDLE_BASE))

#define BUFFER_READ_HANDLE_TO_INDEX(x)  (TInt) (x > 0 ? (x&0xFF) : (x-BUFFER_READ_HANDLE_BASE))

#define BUFFER_WRITE_HANDLE_TO_INDEX(x)  (TInt) (x > 0 ? (x&0xFF) : (x-BUFFER_WRITE_HANDLE_BASE))

#define WFC_INVALID_HANDLE NULL

#define KGrowCleanupStack   12

#define KCompositorVersion 0x01023456

#define KCompositorVersionMajor 0x1

#define KCompositorVersionMinor 0x2

#define KCompositorVersionRevision 0x3456

void PopHeap(void* aHeapPtr)

    {

    User::SwitchHeap((RHeap*)aHeapPtr);

    }

void GrowCleanupStackL()

    {

    TInt n = KGrowCleanupStack;

    while(n--)

        {

        CleanupStack::PushL((CBase*)NULL);

        }

    CleanupStack::Pop(KGrowCleanupStack);

    }

// Helper functions

/* supported external image formats */

enum OWF_PIXEL_FORMAT   {

    OWF_IMAGE_NOT_SUPPORTED = 0,

    OWF_IMAGE_ARGB8888      = 0x8888,

    OWF_IMAGE_XRGB8888      = 0xf888,

    OWF_IMAGE_RGB888        = 0x888,

    OWF_IMAGE_RGB565        = 0x565,

    OWF_IMAGE_L32           = 0xA32,

    OWF_IMAGE_L16           = 0xA16,

    OWF_IMAGE_L8            = 0xA8,

    OWF_IMAGE_L1            = 0xA1,

    OWF_IMAGE_ARGB_INTERNAL = 0x666 /* OWFpixel rep */

} ;

struct CTestNativeStream::OWF_IMAGE_FORMAT{

    OWF_PIXEL_FORMAT        pixelFormat;

    bool              linear;

    bool              premultiplied;

    int                  rowPadding; /* row alignment, in bytes */

} ;

TInt CTestNativeStream::BytesPerPixel(TUidPixelFormat aPixelFormat)

    {

    switch (aPixelFormat)

        {

        case EUidPixelFormatXRGB_8888:

        case EUidPixelFormatARGB_8888:

        case EUidPixelFormatBGRX_8888:

        case EUidPixelFormatXBGR_8888:

        case EUidPixelFormatBGRA_8888:

        case EUidPixelFormatABGR_8888:  

        case EUidPixelFormatABGR_8888_PRE:

        case EUidPixelFormatARGB_8888_PRE:

        case EUidPixelFormatBGRA_8888_PRE:

        case EUidPixelFormatARGB_2101010:

        case EUidPixelFormatABGR_2101010:

            return 4;

        case EUidPixelFormatBGR_888:

        case EUidPixelFormatRGB_888:

            return 3;

        case EUidPixelFormatXRGB_4444:

        case EUidPixelFormatARGB_4444:

        case EUidPixelFormatXBGR_4444:

        case EUidPixelFormatRGB_565:

        case EUidPixelFormatBGR_565:

        case EUidPixelFormatARGB_1555:

        case EUidPixelFormatXRGB_1555:

        case EUidPixelFormatARGB_8332:

        case EUidPixelFormatBGRX_5551:

        case EUidPixelFormatBGRA_5551:

        case EUidPixelFormatBGRA_4444:

        case EUidPixelFormatBGRX_4444:

        case EUidPixelFormatAP_88:

            return  2;

        case EUidPixelFormatRGB_332:

        case EUidPixelFormatBGR_332:

        case EUidPixelFormatA_8:

        case EUidPixelFormatL_8:

            return  1;

        case EUidPixelFormatP_8:

            return -1;

        case EUidPixelFormatP_4:

        case EUidPixelFormatL_4:

            return -2;

        case EUidPixelFormatL_2:

        case EUidPixelFormatP_2:

            return -4;

        case EUidPixelFormatL_1 :

            return -8;

        default:

            {

            return 0;

            }

        }

    }

/*****************************************

 * Helper Creates Surface from OWF spec 

 * 

 *

 */

TSurfaceId CTestNativeStream::helperCreateSurfaceL(khronos_int32_t width,

        khronos_int32_t height,

        const OWF_IMAGE_FORMAT*   format,

        khronos_int32_t nbufs,

        TUidPixelFormat overridePixelFormat)

	{

	RSurfaceManager::TSurfaceCreationAttributesBuf bf;

	RSurfaceManager::TSurfaceCreationAttributes& b = bf();

	TBool premultiplied = format->premultiplied;

	OWF_PIXEL_FORMAT pixelFormat = format->pixelFormat;

	khronos_int32_t bytesPerPixel = 0;

	if (overridePixelFormat != EUidPixelFormatUnknown)

	    {

        bytesPerPixel = BytesPerPixel(overridePixelFormat);

        b.iAlignment = 4;

        b.iPixelFormat = overridePixelFormat;

	    }

	else

	    {

        switch(pixelFormat)

            {

            case OWF_IMAGE_RGB565:

                b.iPixelFormat = EUidPixelFormatRGB_565;

                bytesPerPixel = 2;

                b.iAlignment = 4;

                break;

            case OWF_IMAGE_ARGB8888:

                {

                if (premultiplied)

                    {

                    b.iPixelFormat = EUidPixelFormatARGB_8888_PRE;

                    }

                else

                    {

                    b.iPixelFormat = EUidPixelFormatARGB_8888;

                    }

                bytesPerPixel = 4;

                b.iAlignment = 4;

                break;

                }

            case OWF_IMAGE_XRGB8888 :

                b.iPixelFormat = EUidPixelFormatXRGB_8888;

                bytesPerPixel = 4;

                b.iAlignment = 4;

                break;

            case OWF_IMAGE_L8 :

                b.iPixelFormat = EUidPixelFormatA_8;

                bytesPerPixel = 1;

                b.iAlignment = 4;

                break;

            case OWF_IMAGE_L1 :

                b.iPixelFormat = EUidPixelFormatL_1;

                bytesPerPixel = -8;

                b.iAlignment = 4;

                break;

            default:

                User::Leave(KErrNotSupported);	

                break;

            }

	    }

	b.iSize.iWidth = width;

	b.iSize.iHeight = height;

	b.iBuffers = nbufs;								// number of buffers in the surface

	b.iOffsetToFirstBuffer = 0;						// way of reserving space before the surface pixel data

	if (bytesPerPixel >= 0)

	    {

	    b.iStride = bytesPerPixel * width;	// number of bytes between start of one line and start of next	

	    }

	else

	    {

	    b.iStride = (width-(bytesPerPixel+1)) / (-bytesPerPixel);

	    }

	b.iContiguous = EFalse;

	b.iMappable = ETrue;

	TSurfaceId surface = TSurfaceId::CreateNullId();

	User::LeaveIfError(iUtility->Manager().CreateSurface(bf, surface));

	return surface;

	}

SymbianStreamType CTestNativeStream::helperCreateImageStream(khronos_int32_t width,

                                 khronos_int32_t height,

                                 const OWF_IMAGE_FORMAT*  format,

                                 khronos_int32_t nbufs,

                                 TUidPixelFormat overridePixelFormat)

	{

	TSurfaceId surface;

	TRAPD(err,surface = helperCreateSurfaceL(width, height, format, nbufs, overridePixelFormat));

	if (err)

	    {

	    return WFC_INVALID_HANDLE;

	    }

	SymbianStreamType ns;

	SymbianStreamAcquire(&surface, &ns);

	iUtility->Manager().CloseSurface(surface);

	return ns;

	}

RSemaphore      gSemaphore;

TGlobalNativeStreamVar	gVarInstance={0};

const TGlobalNativeStreamVar& TGlobalNativeStreamVar::Instance()

	{

	return gVarInstance;

	}

void TGlobalNativeStreamVar::SetSurfaceID(TSurfaceId aSurfaceID)

    {

    iSurfaceID = aSurfaceID;

    }

void TGlobalNativeStreamVar::SetTestComplete(TBool aTestComplete)

    {

    iTestComplete = aTestComplete;

    }

void TGlobalNativeStreamVar::SetBuffers(TInt aBuffers)

    {

    iBuffers = aBuffers;

    }

TSurfaceId TGlobalNativeStreamVar::SurfaceID() const

    {

    return iSurfaceID;

    }

TBool TGlobalNativeStreamVar::TestComplete() const

    {

    return iTestComplete;

    }

TInt TGlobalNativeStreamVar::Buffers() const

    {

    return iBuffers;

    }

/*

 * CTestNativeStream implementation

 * 

 * 

 * 

 * 

 */

CTestNativeStream::CTestNativeStream(): iUtility(this)

	{

	// No implementation required

	}

CTestNativeStream::~CTestNativeStream()

	{

	DeleteOwfSingletons();

	}

void CTestNativeStream::SetupL()

	{

	TRAPD(err_FailedToCreateSurfaceUtility, iUtility = CSurfaceUtility::NewL( NULL ));

	ASSERT_EQUALS(err_FailedToCreateSurfaceUtility,KErrNone);

	DefineOwfSingletonKeys();

	}

/**

 * test Suite furniture 

 **/

void CTestNativeStream::TearDownL()

	{

	delete iUtility();

	}

/**

WFC context callback function invoked by native stream when the stream's content

is updated. For testing, we simply call a class member function that checks that the

correct native stream handle and events mask were supplied.

*/

void CTestNativeStream::SourceStreamUpdatedCallback(

        SymbianStreamType aNs, khronos_int32_t aEvents, void* aData, void* aParam)

    {

    (void)aData;

    if (aEvents == ESOWF_ObserverReturnDefaultEvent && aParam)

        {

        SYMOWF_DEFAULT_EVENT_PARAM* parameter = (SYMOWF_DEFAULT_EVENT_PARAM*) aParam;

        if ((parameter->length) == sizeof(SYMOWF_DEFAULT_EVENT_PARAM))

            {

            parameter->event = ESOWF_EventUpdated;

            }

        return;

        }

    ASSERT(CTestNativeStream::iTester);

    CTestNativeStream::iTester->CheckSourceStreamUpdated(aNs, aParam);

    }

void CTestNativeStream::CheckSourceStreamUpdated(SymbianStreamType aNs, void* aParam)

    {

    RHeap *h1 = &(User::Heap());

    if (aParam)

        {

        ASSERT_EQUALS(iNs, aNs);

        SYMOWF_CONTENT_UPDATED_PARAM* param = (SYMOWF_CONTENT_UPDATED_PARAM*) aParam;

        ASSERT_TRUE(param->id == SYM_CONTENT_UPDATE_BEGIN || 

                    param->id == SYM_CONTENT_UPDATE_END ||

                    param->id == SYM_CONTENT_UPDATE);

        iSourceStreamUpdatedCalled++;

        iStreamUpdatedParameter = param->id; 

        switch(param->id)

            {

            case SYM_CONTENT_UPDATE_BEGIN:

                param->immediateAvailable = iImmediateAvailable;

                param->immediateVisibility = iImmediateVisible;

                param->serialNumber = iStreamUpdatedSerialNumber;

                break;

            case SYM_CONTENT_UPDATE:

            case SYM_CONTENT_UPDATE_END:

                ASSERT_EQUALS(iExpectedSourceStreamUpdatedEventMask, param->par);        

                iContextUpdatedFlags |= param->par & (~ESOWF_EventUpdated);    

                break;

            default:

                break;

            }

        }

    else

        {

        iSourceStreamUpdatedCalled++;

        }

    }

/**

Remove the native stream notifications. The creator of the source is responsible

for destroying the native stream. 

Now with the new SymbianStreamRemoveObserver function we need to pass in an observer

*/

void CTestNativeStream::RemoveNsNotifications()

    {

    SymbianStreamRemoveObserver(iNs, &iScreenNo, ESOWF_EventAvailable);

    SymbianStreamRemoveObserver(iNs, &iScreenNo, ESOWF_EventDisplayed);

    SymbianStreamRemoveObserver(iNs, &iScreenNo, ESOWF_EventDisplayedX);

    }

CTestNativeStream* CTestNativeStream::iTester = NULL;

// Create a suite of all the tests

CTestSuite* CTestNativeStream::CreateSuiteL(const TDesC& aName)

	{

	SymbianStreamRegisterScreenNotifications(0, 10, KCompositorVersion);

	SUB_SUITE_OPT(CTestNativeStream,NULL);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0100L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0101L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0102L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0103L);

		// Test with 1, 2 and 3 buffers

		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0104L,1,4);

		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0105L,1,4);

		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0106L,1,4);

		// Concurrent tests

		ADD_TEST_STEP_PARAM_RANGE(CreateSharedNativeStreamL,1,4);

		ADD_THIS_TEST_STEP(DestroySharedNativeStreamL);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0107_1L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0107_2L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0107_3L);

		// Test SUS with OpenWF pipeline

		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0108L, 1, 4);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0109L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0110L);

		// Test various cases for Native Stream callbacks

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0111L);

		// Test multithreaded cases for Native Stream callbacks

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0112_1L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0112_2L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0112_3L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0112_4L);

		// Notification tests

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0113L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0114L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0115L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0116L);

		// Notification cancel

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0117_1L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0117_2L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0117_3L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0117_4L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0118_1L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0118_2L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0118_3L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0118_4L);

		// Notification overflow

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0119_1L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0119_2L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0119_3L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0120_1L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0120_2L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0120_3L);

		// Notifications cancelled due to removal of source observer

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0122L);

		// Sym native stream add/remove observers

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0130L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0131L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0132L);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0133L);

		// Test with 1, 2 and 3 buffers

		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0140L,1,4);

		ADD_TEST_STEP_PARAM_RANGE(GRAPHICS_OPENWFC_NATIVESTREAM_0141L,1,4);

		ADD_THIS_TEST_STEP(GRAPHICS_OPENWFC_NATIVESTREAM_0142L);

	END_SUITE;	

	}

// This handles any non-member uses of the extended ASSERT_XXX macros

void TefUnitFailLeaveL()

	{

	User::Leave(KErrTEFUnitFail);

	}

SymbianStreamType CTestNativeStream::NsCheckL(const TSurfaceId aId, TInt aCheck, TBool aFind)

	{

	// Acquire (create OR find) the stream

	SymbianStreamType ns = NULL;

	TInt err;

	if (aFind)

		{

		err = (TInt)SymbianStreamFind(&aId, &ns);

		}

	else

		{

		err = SymbianStreamAcquire(&aId, &ns);

		}

	ASSERT_TRUE(err == KErrNone);

	// Check the hash map count

	ASSERT_EQUALS((COpenWfcStreamMap::InstanceL().Count()), aCheck);

    SymbianStreamBuffer bufferHandle;

    err = SymbianStreamAcquireReadBuffer(ns,&bufferHandle);

    ASSERT_TRUE(err == KErrNone);

    long bufferIndex;

    const TSurfaceId* checkId = NULL;

    err = SymbianStreamGetBufferId(ns,bufferHandle,&bufferIndex,&checkId);

    ASSERT_TRUE(err == KErrNone);

    SymbianStreamReleaseReadBuffer(ns,bufferHandle);

	ASSERT_NOT_NULL(checkId);

	ASSERT_EQUALS(*checkId, aId);

	return ns;

	}

void CTestNativeStream::CreateSharedNativeStreamL(TInt aBuffers)

	{

    RHeap* mainHeap = COpenWfcStreamMap::InstanceL().GetMainHeap();

    GrowCleanupStackL();

	CleanupStack::PushL(TCleanupItem(PopHeap, User::SwitchHeap(mainHeap)));

	gVarInstance.SetTestComplete(EFalse);

	gVarInstance.SetBuffers(aBuffers);

	TSize surfaceSize(TSize(100,100));

	khronos_int32_t width = surfaceSize.iWidth;

	khronos_int32_t height = surfaceSize.iHeight;

	OWF_IMAGE_FORMAT pixelFormat =

		{

		OWF_IMAGE_ARGB8888,

		ETrue,

		ETrue,

		4

		};	

	// Create the first stream

	SymbianStreamType ns=helperCreateImageStream(width,