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