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

*/

#include "egltest_stress_process_sgimage.h"

GLDEF_C TInt E32Main()

	{

	RDebug::Print(_L("Stress test client process::E32Main - entry"));

	CTrapCleanup* TheTrapCleanup = CTrapCleanup::New();

	TRAPD(err, LaunchClientProcessL());

	if (err)

		{

		User::Panic(KStressTestChildAppPanic, err);

		}

    delete TheTrapCleanup;

	RDebug::Print(_L("Stress test client process::E32Main - exit"));

	return KErrNone;

	}

LOCAL_C void LaunchClientProcessL()

	{

	__UHEAP_MARK;

	RProcess::Rendezvous(KErrNone);

    RSemaphore sem;

    User::LeaveIfError(sem.OpenGlobal(KEglStressTest));

    CleanupClosePushL(sem);

    //Access data passed from the main process

    TStressProcessInfo info;

    TPckg<TStressProcessInfo> pckgInfo(info);

    User::LeaveIfError(User::GetDesParameter(KMultiProcessSlot, pckgInfo));

    //Create RSgDriver and open the image

    RSgDriver driver;

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

    CleanupClosePushL(driver);

    RSgImage image;

    User::LeaveIfError(image.Open(info.iSgId));

    CleanupClosePushL(image);

    EGLDisplay display;

    EGL_LEAVE_NULL(display, eglGetDisplay(EGL_DEFAULT_DISPLAY));

    EGL_LEAVE_ERROR(eglInitialize(display, NULL, NULL));

    EGL_LEAVE_ERROR(eglBindAPI(EGL_OPENVG_API));

    //Initialise to remove arm compiler warnings

    EGLConfig config = 0;

    EGLContext context = EGL_NO_CONTEXT;

    EGLSurface surface = EGL_NO_SURFACE;

    if(info.iTestType == EStressRead)

        {

        TSgImageInfo sginfo;

        User::LeaveIfError(image.GetInfo(sginfo));

        //Create an independant pixmap surface on which to copy the vgimage 

        RSgImage image2;

        User::LeaveIfError(image2.Create(sginfo, NULL, NULL));

        CleanupClosePushL(image2);

        ChooseConfigAndCreateContextL(display, context, config, image2, KStressTestChildAppPanic, info.iAlphaPre);

        EGL_LEAVE_NULL(surface, CreatePixmapSurfaceL(display, config, image2, info.iAlphaPre)); 

        CleanupStack::PopAndDestroy(&image2);

        }

    else

        {

        ChooseConfigAndCreateContextL(display, context, config, image, KStressTestChildAppPanic, info.iAlphaPre);

        EGL_LEAVE_NULL(surface, CreatePixmapSurfaceL(display, config, image, info.iAlphaPre));       

        }

    EGL_LEAVE_ERROR(eglMakeCurrent(display, surface, surface, context));

    VGImage vgImage;

    GenerateVgImageL(display, &image, vgImage);

    /* Create and install the active scheduler */

    CActiveScheduler* sched = new(ELeave) CActiveScheduler;

    CActiveScheduler::Install(sched);

    CleanupStack::PushL(sched);

    TInt width = vgGetParameteri(vgImage, VG_IMAGE_WIDTH);

    VgLeaveIfErrorL();

    TInt height = vgGetParameteri(vgImage, VG_IMAGE_HEIGHT);

    VgLeaveIfErrorL();

    VGImageFormat format = static_cast<VGImageFormat>(vgGetParameteri(vgImage, VG_IMAGE_FORMAT));

    VgLeaveIfErrorL();

    TBool testPass = ETrue;

    CTReadWriteChild* painter = CTReadWriteChild::NewL(vgImage, width, height, info.iByteSize, format, info.iTestType, testPass);

    CleanupStack::PushL(painter);

    painter->After(TTimeIntervalMicroSeconds32(0));

    //Data access is synchronised from the main process

    sem.Wait();

    sched->Start();

    if(testPass == EFalse)

        {

		// Leave with a 'known' test error so that we can catch this particular failure 

        User::Leave(KTestStressUnexpectedPixelError);

        }

    CleanupStack::PopAndDestroy(5, &sem); //painter, sched, image, driver, sem

    __UHEAP_MARKEND;

    }

/**

 *    class CTReadWriteChild

 *    A Child of CTReadWrite which contains member data not included in the base class and 

 *    implementations of pure virtual functions.

 *    a) One for each particular test case

 *    b) Support functions MakeCurrentL() and IsFinished()

 *    

 *    The base class is an active object and the implemented virtual functions are invoked

 *    indirectly from the RunL() function

 */

CTReadWriteChild::CTReadWriteChild(VGImage aImage, TInt aWidth, TInt aHeight, TInt aByteSize, VGImageFormat aFormat, const TTestType& aTestType, TBool& aTestPass)

: CTReadWrite(aWidth, aHeight, aByteSize, aFormat, aTestType, aTestPass),

    iImage(aImage)

    {

    }

CTReadWriteChild* CTReadWriteChild::NewL(VGImage aImage, TInt aWidth, TInt aHeight, TInt aByteSize, VGImageFormat aFormat, const TTestType& aTestType, TBool& aTestPass)

    {

    CTReadWriteChild* self = new (ELeave) CTReadWriteChild(aImage, aWidth, aHeight, aByteSize, aFormat, aTestType, aTestPass);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CTReadWriteChild::MakeCurrentL() const

    {

    }

void CTReadWriteChild::ReadImageFuncL()

    {

    vgGetImageSubData(iImage, iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);

    VgLeaveIfErrorL();

    }

void CTReadWriteChild::ReadFuncL()

    {

    vgDrawImage(iImage);

    vgReadPixels(iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);

    VgLeaveIfErrorL();

    //Small delay to aid pixel access sharing between processes

    User::After(TTimeIntervalMicroSeconds32(1000));

    }

void CTReadWriteChild::WriteImageFuncL()

    {

    vgImageSubData(iImage, iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);

    VgLeaveIfErrorL();

    }

TBool CTReadWriteChild::IsFinished()

    {

    return ETrue;

    }

void CTReadWriteChild::VgImageFuncL()

    {

    vgDrawImage(iImage);

    VgLeaveIfErrorL();

    }

void CTReadWriteChild::PixmapSurfaceFuncL()

    {

    vgDrawImage(iImage);

    VgLeaveIfErrorL();

    }