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

//

/**

 @file

 @test

*/

#include "egltest_stress_common_sgimage.h"

void ChooseConfigAndCreateContextL(EGLDisplay& aDisplay, EGLContext& aContext, EGLConfig& aConfig, const RSgImage& aSgImage, const TDesC& aPanicString, TBool aPreMultAlpha)

    {

    EGLConfig configs[KMaxEglConfigs];

    EGLint numConfigs = 0;

    //If the aPixmap argument is ETrue, then the attributes are for a pixmap surface

    //Otherwise, the surface will be of type pbuffer. Note assumption on the position

    //of the EGL_MATCH_NATIVE_PIXMAP and EGL_SURFACE_TYPE attribute/value pair

    EGLint KAttrib_list_RSgImage[] = { EGL_MATCH_NATIVE_PIXMAP,    (TInt)&aSgImage,

                                       EGL_RENDERABLE_TYPE,       EGL_OPENVG_BIT,

                                       EGL_SURFACE_TYPE,          EGL_PIXMAP_BIT,

                                       EGL_NONE };

    if(aPreMultAlpha != EFalse)

        {

        KAttrib_list_RSgImage[5] |= EGL_VG_ALPHA_FORMAT_PRE_BIT;

        }

    EGL_LEAVE_ERROR(eglChooseConfig(aDisplay, KAttrib_list_RSgImage, configs, KMaxEglConfigs, &numConfigs));

    if(numConfigs > 0)

        {

        //Choose an arbitrary config

        aConfig = configs[0];        

        }

    else

        {

        User::Panic(aPanicString , KErrNotSupported);      

        }

    //One context is sufficient for all surfaces

    EGL_LEAVE_NULL(aContext, eglCreateContext(aDisplay, aConfig, EGL_NO_CONTEXT, NULL));

    }

EGLSurface CreatePixmapSurfaceL(EGLDisplay aDisplay, EGLConfig aConfig, const RSgImage& aSgImage, TBool aAlphaPre)

    {

    EGLSurface surface = EGL_NO_SURFACE;

    if(aAlphaPre == EFalse)

        {

        EGL_LEAVE_NULL(surface, eglCreatePixmapSurface(aDisplay, aConfig, (void*)&aSgImage, KPixmapAttribsVgAlphaFormatNonPre));

        }

    else

        {

        EGL_LEAVE_NULL(surface, eglCreatePixmapSurface(aDisplay, aConfig, (void*)&aSgImage, KPixmapAttribsVgAlphaFormatPre));

        }

    return surface;

    }

void GenerateVgImageL(const EGLDisplay aDisplay, RSgImage* aImage, VGImage& aVgImage)

    {

    EGLImageKHR eglImage = 0;

    TFPtrEglCreateImageKhr ipfnEglCreateImageKHR = reinterpret_cast<TFPtrEglCreateImageKhr>(eglGetProcAddress("eglCreateImageKHR"));

    EGL_LEAVE_ERROR(ipfnEglCreateImageKHR);

    TFPtrVgCreateEglImageTargetKhr ipfnvgCreateImageTargetKHR = reinterpret_cast<TFPtrVgCreateEglImageTargetKhr>(eglGetProcAddress("vgCreateEGLImageTargetKHR"));

    EGL_LEAVE_ERROR(ipfnvgCreateImageTargetKHR);

    TFPtrEglDestroyImageKhr ipfnEglDestroyImageKHR = reinterpret_cast<TFPtrEglDestroyImageKhr>(eglGetProcAddress("eglDestroyImageKHR"));

    EGL_LEAVE_ERROR(ipfnEglDestroyImageKHR);

    EGL_LEAVE_NULL(eglImage, ipfnEglCreateImageKHR(aDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, reinterpret_cast<EGLClientBuffer>(aImage), (int*)KEglImageAttribsPreservedTrue));

    EGL_LEAVE_NULL(aVgImage, ipfnvgCreateImageTargetKHR((VGeglImageKHR)eglImage));

    //Close the EGLImage

    EGL_LEAVE_ERROR(ipfnEglDestroyImageKHR(aDisplay, eglImage));

    }

void VgLeaveIfErrorL()

    {

    VGErrorCode ret = vgGetError();

    if(ret != VG_NO_ERROR)

        {

        User::Leave(ret);

        }

    }

/**

 *    class CTReadWrite

 *    A base class for use by both the main process and the child processes. Contains common

 *    data and functions that both children use. Caters for all stress test cases. The children 

 *    provide implementations of pure virtual functions, one for each test case. The function

 *    particular to each test case are called in the base class RunL() and these

 *    call the implemented virtual functions in either the main or the child process.

 *    The virtual functions read from and write to objects derived from a shared SgImage

 */

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

: CTimer(CActive::EPriorityHigh),

    iWidth(aWidth),

    iHeight(aHeight),

    iByteSize(aByteSize),

    iFormat(aFormat),

    iTestType(aTestType),

    iTestPass(aTestPass)

    {

    }

CTReadWrite::~CTReadWrite()

    {

    delete[] iData;

    }

void CTReadWrite::ConstructL()

    {

    if(iByteSize == 2)

        {

        //Pack two bytes into a four byte value and halve the buffer size

        iInitialColour = (KColourInitial16 << 16) + KColourInitial16;

        iFinalColour = (KColourFinal16 << 16) + KColourFinal16;

        iBufferSize = iWidth*iHeight/2;

        }

    else

        {

        iInitialColour = KColourInitial32;

        iFinalColour = KColourFinal32;

        iBufferSize = iWidth*iHeight;

        }

    //Buffer must cater for an odd (as in not even) buffer size

    iData = new(ELeave) TUint32[iBufferSize + 1];

    CTimer::ConstructL();

    CActiveScheduler::Add(this);

    }

void CTReadWrite::RunL()

    {

    MakeCurrentL();

    switch(iTestType)

        {

        case EStressRead:

            {

            ReadL();

            break;

            }

        case EStressReadWriteSingleImage:

        case EStressReadWriteMultiImage:

            {

            ReadWriteImageL();

            break;

            }

        case EStressVGImage:

            {

            VgImageL();

            break;

            }

        case EStressPixmapSurface:

            {

            PixmapSurfaceL();

            break;

            }

        default:

            //Error

            User::Leave(KErrArgument);

            break;

        }

    }

void CTReadWrite::ReadL()

    {

    ReadFuncL();

    if(iFrameNumber != KNumberOfFrames)

         {

         iFrameNumber++;

         for(TInt i=0; i<iBufferSize; i++)

             {

             if(iData[i] != iInitialColour)

                 {

                 RDebug::Print(_L("Unexpected pixel colour %x"), iData[i]);

                 CActiveScheduler::Stop();

                 iTestPass = EFalse;

                 return;

                 }

             }

         //Re-issue the request

         After(TTimeIntervalMicroSeconds32(0));

         }

     else

         {

         //Stop the active scheduler and process with test termination

         CActiveScheduler::Stop();

         }

    }

void CTReadWrite::ReadWriteImageL()

    {

    ReadImageFuncL();

    TBool ret = EFalse; 

    for(TInt i=0; i<iBufferSize; i++)

        {

        if(iData[i] == iInitialColour)

            {

            iData[i] = iFinalColour;

            WriteImageFuncL();

            //Re-issue the request

            After(TTimeIntervalMicroSeconds32(0));

            ret = ETrue;

            break;

            }

        else if(iData[i] != iFinalColour)

            {

            CActiveScheduler::Stop();

            iTestPass = EFalse;

            ret = ETrue;

            break;

            }

        }

    //If no pixels have been modified, check to see if the test should finish

    if( (IsFinished() != EFalse) && (ret == EFalse) )

        {

        //Stop the active scheduler and process with test termination

        CActiveScheduler::Stop();

        }

    }

void CTReadWrite::VgImageL()

    {

    if(iFrameNumber != KNumberOfFrames)

          {

          iFrameNumber++;

          VgImageFuncL();

          //Re-issue the request

          After(TTimeIntervalMicroSeconds32(0));

          }

      else

          {

          //Stop the active scheduler and process with test termination

          CActiveScheduler::Stop();

          }

    }

void CTReadWrite::PixmapSurfaceL()

    {

    if(iFrameNumber != KNumberOfFrames)

          {

          iFrameNumber++;

          PixmapSurfaceFuncL();

          //Re-issue the request

          After(TTimeIntervalMicroSeconds32(0));

          return;

          }

    if(IsFinished() != EFalse)

        {

        //Stop the active scheduler and process with test termination

        CActiveScheduler::Stop();

        }

    }