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