diff -r 3365349494cc -r cdf2f6e5c390 egl/egltest/src/egltest_stress_sgimage.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/egl/egltest/src/egltest_stress_sgimage.cpp	Thu May 27 14:13:51 2010 +0300
@@ -0,0 +1,637 @@
+// 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 <s32file.h>
+#include <test/t_simload.h>
+#include <test/tefunit.h>    //ASSERT_TRUE
+#include "egltest_stress_sgimage.h"
+
+TVerdict CEglTest_Stress::doTestStepL()
+    {
+    INFO_PRINTF1(_L("CEglTest_Stress:doTestStepL()"));
+    
+    TBuf<100> testCaseId;
+    TestCaseName(testCaseId);
+    SetTestStepID(testCaseId);
+
+#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
+    __UHEAP_MARK;
+    
+    //File server is used to generate simload ini file
+    User::LeaveIfError(iFs.Connect());
+  
+    TBool ret = CheckForExtensionL(KEGL_RSgimage | KEGL_KHR_image_base | KVG_KHR_EGL_image | KEGL_KHR_image_pixmap);
+    if(!ret)
+        {
+        // The extension is not supported
+        RecordTestResultL();
+        CloseTMSGraphicsStep();
+        return TestStepResult();
+        }
+
+    //Create a config file and launch the simulated load app
+    ReadIniValuesL();
+    PrintConfigDataL();
+    CreateSimLoadAppL();
+
+    INFO_PRINTF1(_L("Creating a Semaphore to signal all child processes at once"));
+    RSemaphore sem;
+    User::LeaveIfError(sem.CreateGlobal(KEglStressTest(), iNumberChildProcesses));
+    CleanupClosePushL(sem);
+
+    //Information to be passed to the child process
+    TSgImageInfo info;
+    TSize size(iRSgImageWidth, iRSgImageHeight);
+    info.iUsage = ESgUsageBitOpenVgImage | ESgUsageBitOpenVgSurface;
+    info.iPixelFormat = iFormat;
+    info.iSizeInPixels = size;
+
+    //Utilise egl helper functions
+    CreateEglSessionL();
+    
+    //Create a display and initialise it
+    GetDisplayL();
+    iEglSess->InitializeL();
+    
+    //Open RSGImage driver    
+    iEglSess->OpenSgDriverL();
+    
+    EGL_LEAVE_ERROR(eglBindAPI(EGL_OPENVG_API));
+ 
+    EGLContext context;
+    for(TInt i=0; i<iNumberRSgImages; i++)
+        {
+        RSgImage image;
+        iSgImageArray.InsertL(image, i);
+        User::LeaveIfError(iSgImageArray[i].Create(info, NULL, NULL));
+
+        EGLConfig config;
+        if(i == 0)
+            {
+            //Only need to determine a matching configuration once
+            ChooseConfigAndCreateContextL(iDisplay, context, config, iSgImageArray[i], KStressTestMainAppPanic, iAlphaPre);
+            }
+ 
+        EGLSurface surface = EGL_NO_SURFACE; //remove arm warning
+        EGL_LEAVE_NULL(surface, CreatePixmapSurfaceL(iDisplay, config, iSgImageArray[i], iAlphaPre));
+
+        EGL_LEAVE_ERROR(eglMakeCurrent(iDisplay, surface, surface, context));
+         
+        PaintSurfaceL(iDisplay, surface, context);
+        EGL_LEAVE_ERROR(eglSwapBuffers(iDisplay, surface));
+
+        if(iTestType == EStressVGImage)
+            {
+            EGL_LEAVE_ERROR(eglMakeCurrent(iDisplay, surface, surface, context));
+            
+            EGLImageKHR eglImage = 0; //removes arm compiler warning
+            VGImage vgImage;
+
+            EGL_LEAVE_NULL(eglImage, iEglSess->eglCreateImageKhrL(iDisplay, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR, &iSgImageArray[i], (int*)KEglImageAttribsPreservedTrue));
+            EGL_LEAVE_NULL(vgImage, iEglSess->vgCreateImageTargetKHR(eglImage));
+
+            //Close the EGLImage
+            EGL_LEAVE_ERROR(iEglSess->DestroyEGLImage(iDisplay, eglImage));
+                        
+            User::LeaveIfError(iVGImageArray.Insert(vgImage, i));
+            }
+
+        User::LeaveIfError(iSurfaceArray.Insert(surface, i));
+        }
+
+    /* Create and install the active scheduler */
+    CActiveScheduler* sched = new(ELeave) CActiveScheduler;
+    CActiveScheduler::Install(sched);
+    CleanupStack::PushL(sched);
+
+    TInt exitCounter = iNumberMainImages;
+    TBool testResult = ETrue;
+
+    //Create an active object for each RSgImage accessed in the main process
+    CTReadWriteMain* painter = 0;
+    for(TInt i=0; i<iNumberMainImages; i++)
+        {
+        if(iTestType == EStressVGImage)
+            {
+            painter = CTReadWriteMain::NewL(iDisplay, iSurfaceArray[i], context, iRSgImageWidth, iRSgImageHeight, iByteSize, iVgFormat, testResult, exitCounter, iTestType, iVGImageArray[i]);
+            }
+        else
+            {
+            painter = CTReadWriteMain::NewL(iDisplay, iSurfaceArray[i], context, iRSgImageWidth, iRSgImageHeight, iByteSize, iVgFormat, testResult, exitCounter, iTestType);            
+            }
+            
+        CleanupStack::PushL(painter);
+        painter->After(TTimeIntervalMicroSeconds32(0));
+        }
+
+    CreateChildProcessesL();
+
+    INFO_PRINTF1(_L("Signaling all child processes at once - starts data access in the child processes"));
+    sem.Signal(iNumberChildProcesses);
+
+    //Start the active scheduler - starts data access in the main process
+    sched->Start();
+
+    if(testResult == EFalse)
+        {
+		if (iTestType == EStressReadWriteSingleImage || iTestType == EStressReadWriteMultiImage)
+			{
+			// For GRAPHICS-EGL-0428 and GRAPHICS-EGL-0437 data integrity cannot be guaranteed on 
+			// all implementations, so the pixel value checking aspects of these tests are regarded as optional   
+			WARN_PRINTF1(_L("Unexpected pixel colour"));
+			}
+		else
+			{
+			ERR_PRINTF1(_L("Unexpected pixel colour"));
+			SetTestStepResult(EFail);
+			}
+        }
+
+    //Check that each child process has completed without error
+    for(TInt i=0; i<iNumberChildProcesses; i++)
+       {
+       TRequestStatus status;
+       iProcessArray[i].Logon(status);
+       User::WaitForRequest(status);
+
+       if(status != KErrNone)
+           {
+		   if (status == KTestStressUnexpectedPixelError && (iTestType == EStressReadWriteSingleImage || iTestType == EStressReadWriteMultiImage))
+			   {
+			   // For GRAPHICS-EGL-0428 and GRAPHICS-EGL-0437 data integrity cannot be guaranteed on 
+			   // all implementations, so the pixel value checking aspects of these tests are regarded as optional
+			   // So check that if it fails, it fails for the expected reason of no matching pixel.
+			   WARN_PRINTF2(_L("Child Process completed with code %d, expected KErrNone"), status.Int());
+			   }
+		   else
+			   {
+			   ERR_PRINTF2(_L("Child Process completed with code %d, expected KErrNone"), status.Int());
+			   SetTestStepResult(EFail);
+			   }
+           }
+       }
+
+    DestroySimLoadProcess();
+    DeleteConfigData();
+    ClearDownArraysL(iDisplay);
+    EGL_LEAVE_ERROR(eglDestroyContext(iDisplay, context));
+
+    CleanupStack::PopAndDestroy(iNumberMainImages + 2, &sem); //(iNumberMainImages + 1) active objects, sched, sem
+    iEglSess->CloseSgDriver();
+    
+    CleanAll();
+    iFs.Close();
+
+    __UHEAP_MARKEND;
+
+#else
+    INFO_PRINTF2(_L("%S can only be run with SgImage-Lite"), &testCaseId);
+#endif //SYMBIAN_GRAPHICS_EGL_SGIMAGELITE
+    
+    //Comply with the terrific TMS
+    RecordTestResultL();
+    CloseTMSGraphicsStep();
+
+    return TestStepResult();
+    }
+
+CEglTest_Stress::~CEglTest_Stress()
+    {
+    //Free memory and close handles in case of panic in the doTestStepL()
+    delete iEglSess;
+    
+    iFs.Close();
+    iSurfaceArray.Close();
+    iProcessArray.Close();
+    iSgImageArray.Close();
+    iVGImageArray.Close();
+    }
+
+void CEglTest_Stress::PaintSurfaceL(EGLDisplay aDisplay, EGLSurface aSurface, EGLContext aContext)
+    {
+    //Clear surface background, format of the constant is ARGB
+    //Match the colour to that of the defined constant
+    VGfloat red = 0.0;
+    VGfloat green = 0.0;
+    VGfloat blue = 0.0;
+    VGfloat alpha = 0.0;
+    
+    //Care taken to avoid fixed width -> floating point -> fixed width rounding errors
+    if(iByteSize == 4)
+        {
+        red = 1.0 * ((KColourInitial32 & 0x00FF0000) >> 16)/255;
+        green = 1.0 * ((KColourInitial32 & 0x0000FF00) >> 8)/255;
+        blue = 1.0 * (KColourInitial32 & 0x000000FF)/255;
+        alpha = 1.0 * ((KColourInitial32 & 0xFF000000) >> 24)/255;        
+        }
+    else //iByteSize == 2
+        {
+        red = 1.0 * ((KColourInitial16 & 0x7C00) >> 11)/31;
+        green = 1.0 * ((KColourInitial16 & 0x0480) >> 5)/63;
+        blue = 1.0 * (KColourInitial16 & 0x001F)/31;
+        }
+
+    //Format of the constant is RGBA (32 bit) 
+    VGfloat bgColor[] = {red, green, blue, alpha};
+
+    EGL_LEAVE_ERROR(eglMakeCurrent(aDisplay, aSurface, aSurface, aContext));
+ 
+    vgSetfv(VG_CLEAR_COLOR, 4, bgColor);
+    ASSERT_VG_TRUE(vgGetError() == VG_NO_ERROR);
+    vgClear(0, 0, iRSgImageWidth, iRSgImageHeight);
+    ASSERT_VG_TRUE(vgGetError() == VG_NO_ERROR);
+    }
+
+void CEglTest_Stress::CreateChildProcessL(TInt aProcessNumber, TTestType aTestType, TSgDrawableId aDrawableId)
+    {
+    TRequestStatus status;
+    RProcess client;
+    User::LeaveIfError(client.Create(KStressTestClientApp, KNullDesC));
+
+    //Pass image and test information to the child process
+    TStressProcessInfo info;
+    info.iTestType = aTestType;
+    info.iSgId = aDrawableId;
+    info.iByteSize = iByteSize;
+    info.iAlphaPre = iAlphaPre;
+
+    TPckg<TStressProcessInfo> pckgInfo(info);
+    User::LeaveIfError((client.SetParameter(KMultiProcessSlot, pckgInfo)));
+
+    client.Rendezvous(status);
+    client.Resume();
+    User::WaitForRequest(status);
+    TEST(status == KErrNone);
+
+    //Store image handle for cleanup
+    iProcessArray.InsertL(client, aProcessNumber);
+    }
+
+void CEglTest_Stress::CreateChildProcessesL()
+    {
+    for(TInt i=0; i<iNumberChildProcesses; i++)
+        {
+        switch(iTestType)
+            {
+            case EStressReadWriteMultiImage:
+            case EStressPixmapSurface:
+                {
+                //Each child process accesses one SgImage
+                CreateChildProcessL(i, iTestType, iSgImageArray[i].Id());
+                break;
+                }
+            case EStressRead:
+            case EStressReadWriteSingleImage:
+            case EStressVGImage:
+                {
+                //All child processes access the same SgImage
+                CreateChildProcessL(i, iTestType, iSgImageArray[0].Id());
+                break;
+                }
+            default:
+                User::Panic(KStressTestMainAppPanic, KErrNotFound);
+                break;
+            }
+        }
+    }
+
+void CEglTest_Stress::ClearDownArraysL(EGLDisplay aDisplay)
+    {
+    for(TInt i=0; i<iSurfaceArray.Count(); i++)
+        {
+        ASSERT_EGL_TRUE(eglDestroySurface(aDisplay, iSurfaceArray[i]));
+        }
+    
+    for(TInt i=0; i<iVGImageArray.Count(); i++)
+        {
+        vgDestroyImage(iVGImageArray[i]);
+        ASSERT_VG_TRUE(vgGetError() == VG_NO_ERROR);
+        }
+    
+    for(TInt i=0; i<iProcessArray.Count(); i++)
+        {
+        iProcessArray[i].Close();
+        }
+
+    for(TInt i=0; i<iSgImageArray.Count(); i++)
+        {
+        iSgImageArray[i].Close();
+        }
+    
+    iSurfaceArray.Close();
+    iProcessArray.Close();
+    iSgImageArray.Close();
+    iVGImageArray.Close();
+    }
+
+void CEglTest_Stress::CreateSimLoadAppL()
+    {
+    TInt index = 1;
+    TBuf<100> tempStore;
+
+    //Three simload processes need to be launched t_simloadapp1.exe - t_simloadapp3.exe
+    while(index <= KNumSimLoadApps)
+        {
+        tempStore.Format(KSimLoadApp, index++);
+        CreateSimLoadProcessL(tempStore);
+        }
+    }
+
+void CEglTest_Stress::CreateSimLoadProcessL(const TDesC& aApp)
+    {
+    INFO_PRINTF2(_L("Starting App: %S"), &aApp);
+
+    RProcess process;
+    User::LeaveIfError(process.Create(aApp, KNullDesC));
+
+    //Give the simulated load high priority to be sure it does its job
+    process.SetPriority(EPriorityHigh);
+    TEST(process.Priority() == EPriorityHigh);
+    INFO_PRINTF3(_L("Process Priority: Actual: %d, Expected: %d"), process.Priority(), EPriorityHigh);
+    process.Resume();
+    
+    iProcessList.AppendL(process);
+    }
+
+void CEglTest_Stress::DestroySimLoadProcess()
+    {
+    for (TInt index = 0; index < iProcessList.Count(); index++)
+        {
+        // check process
+        INFO_PRINTF3(_L("Process Check: Actual: %d, Expected: %d"), iProcessList[index].ExitReason(), KErrNone);
+        TEST(iProcessList[index].ExitReason( )== KErrNone);
+
+        // kill process
+        iProcessList[index].Kill(KErrGeneral);
+        INFO_PRINTF3(_L("Process Exit Reason: Actual: %d, Expected: %d"), iProcessList[index].ExitReason(), KErrGeneral);
+        TEST(iProcessList[index].ExitReason() == KErrGeneral);
+
+        iProcessList[index].Close();
+        }
+
+    iProcessList.Close();
+    }
+
+void CEglTest_Stress::ReadIniValueL(const TDesC& aSectName, const TDesC& aKeyName, TInt& aResult)
+    {
+    if(!GetIntFromConfig(aSectName, aKeyName, aResult))
+        {
+        ERR_PRINTF2(_L("Error reading %S value from ini file"), &aKeyName);
+        User::Leave(KErrNotFound);
+        }
+
+    INFO_PRINTF3(_L("Ini file value %S = %d"), &aKeyName, aResult);
+    }
+
+void CEglTest_Stress::ReadIniValuesL()
+    {
+    ReadIniValueL(ConfigSection(), KNumberRSgImages, iNumberRSgImages);
+    ReadIniValueL(ConfigSection(), KNumberMainImages, iNumberMainImages);
+    ReadIniValueL(ConfigSection(), KNumberChildProcesses, iNumberChildProcesses);
+    ReadIniValueL(ConfigSection(), KRSgImageWidth, iRSgImageWidth);
+    ReadIniValueL(ConfigSection(), KRSgImageHeight, iRSgImageHeight);
+    ReadIniValueL(ConfigSection(), KConfigSimLoadValue, iSimLoadValue);
+    
+    //Check for erroneous ini values
+    ASSERT_TRUE(iNumberChildProcesses <= iNumberRSgImages);
+    ASSERT_TRUE(iNumberMainImages <= iNumberRSgImages);
+    ASSERT_TRUE(iRSgImageWidth >= 0);
+    ASSERT_TRUE(iRSgImageHeight >= 0);
+    ASSERT_TRUE(iSimLoadValue >= 0);
+    ASSERT_TRUE(iSimLoadValue <= 100);
+    
+    TBuf16<100> buffer;
+    TPtrC16 ptrBuffer(buffer);
+    if(!GetStringFromConfig(ConfigSection(), KPixelFormat, ptrBuffer))
+        {
+        ERR_PRINTF2(_L("Error reading %S value from ini file"), &KPixelFormat);
+        User::Leave(KErrNotFound);
+        }
+
+    INFO_PRINTF3(_L("Ini file value %S = %S"), &KPixelFormat, &ptrBuffer);
+
+    //Derive information from the pixel format
+    if(ptrBuffer == KUidPixelFormatARGB_8888)
+        {
+        iFormat = EUidPixelFormatARGB_8888;
+        iVgFormat = VG_sARGB_8888;
+        iAlphaPre = EFalse;
+        iByteSize = 4;
+        }
+    else if(ptrBuffer == KUidPixelFormatARGB_8888_PRE)
+        {
+        iFormat = EUidPixelFormatARGB_8888_PRE;
+        iVgFormat = VG_sARGB_8888_PRE;
+        iAlphaPre = ETrue;
+        iByteSize = 4;
+        }
+    else if(ptrBuffer == KUidPixelFormatRGB_565)
+        {
+        iFormat = EUidPixelFormatRGB_565;
+        iVgFormat = VG_sRGB_565;
+        iAlphaPre = EFalse;
+        iByteSize = 2;
+        }
+    else
+        {
+        ERR_PRINTF2(_L("Unsupported pixel format %S"), &ptrBuffer);
+        User::Leave(KErrNotFound);
+        }
+
+     //Determine the test type from the ini file section name
+     if(ConfigSection().Find(KStressReadOnly) != KErrNotFound)
+         {
+         iTestType = EStressRead;
+         }
+     else if(ConfigSection().Find(KEStressReadWriteSingleImage) != KErrNotFound)
+         {
+         iTestType = EStressReadWriteSingleImage;
+         }
+     else if(ConfigSection().Find(KStressReadWriteMultiImage) != KErrNotFound)
+         {
+         iTestType = EStressReadWriteMultiImage;
+         }
+     else if(ConfigSection().Find(KStressVGImage) != KErrNotFound)
+         {
+         iTestType = EStressVGImage;
+         }
+     else if(ConfigSection().Find(KStressPixmapSurface) != KErrNotFound)
+         {
+         iTestType = EStressPixmapSurface;
+         }
+     else
+         {
+         ERR_PRINTF2(_L("Unknown test case %S"), &ptrBuffer);
+         User::Leave(KErrNotFound);
+         }
+    }
+
+/** 
+ *   This function generates an ini file for the simulated load application
+ *   containing two lines to determine
+ *   1. The type of load (static or spiked, in this case always static)
+ *   2. The simulated load level
+ */
+void CEglTest_Stress::PrintConfigDataL()
+    {
+    RFileWriteStream writer;
+    writer.PushL();
+
+    TInt err = iFs.MkDirAll(KSimLoadConfigFile);
+    TEST(err == KErrNone || err == KErrAlreadyExists);
+    INFO_PRINTF2(_L("Create Config File: %S"), &KSimLoadConfigFile);
+    User::LeaveIfError(writer.Replace(iFs, KSimLoadConfigFile, EFileStreamText|EFileWrite));
+    writer.CommitL();
+
+    CleanupStack::PopAndDestroy(&writer);
+
+    CIniData* data=CIniData::NewL(KSimLoadConfigFile);
+    CleanupStack::PushL(data);
+
+    INFO_PRINTF3(_L("Config Name: %S, \t\tConfig Data: %S"), &KConfigSimLoadType, &KConfigSimLoadStatic);
+    err = data->AddValue(KDefaultSectionName, KConfigSimLoadType, KConfigSimLoadStatic);
+    INFO_PRINTF3(_L("AddValue - Expected: %d, Actual: %d"), KErrNone, err);
+    TEST(err == KErrNone);
+
+    TBuf16<100> buffer;
+    TPtrC16 ptrBuffer(buffer);
+    User::LeaveIfError(GetStringFromConfig(ConfigSection(), KConfigSimLoadValue, ptrBuffer));
+
+    INFO_PRINTF3(_L("Config Name: %S, \t\tConfig Data: %S"), &KConfigSimLoadValue, &ptrBuffer);
+    err = data->AddValue(KDefaultSectionName, KConfigSimLoadValue, ptrBuffer);
+
+    INFO_PRINTF3(_L("AddValue - Expected: %d, Actual: %d"), KErrNone, err);
+    TEST(err == KErrNone);
+
+    data->WriteToFileL();
+    CleanupStack::PopAndDestroy(data);
+    }
+
+void CEglTest_Stress::DeleteConfigData()
+    {
+    INFO_PRINTF2(_L("Deleting Config File Name: %S"), &KSimLoadConfigFile);
+    TInt err = iFs.Delete(KSimLoadConfigFile);
+    TEST(err==KErrNone);
+    }
+
+/**
+ *    class CTReadWriteMain
+ *    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
+ */
+CTReadWriteMain::CTReadWriteMain(EGLDisplay aDisplay, EGLSurface aSurface, EGLContext aContext, TInt aWidth, TInt aHeight, TInt aByteSize, VGImageFormat aFormat, TBool& aTestPass, TInt& aFinishedCounter, const TTestType& aTestType)
+: CTReadWrite(aWidth, aHeight, aByteSize, aFormat, aTestType, aTestPass),
+    iDisplay(aDisplay),
+    iSurface(aSurface),
+    iContext(aContext),
+    iFinishedCounter(aFinishedCounter)
+    {
+    }
+
+CTReadWriteMain* CTReadWriteMain::NewL(EGLDisplay aDisplay, EGLSurface aSurface, EGLContext aContext, TInt aWidth, TInt aHeight, TInt aByteSize, VGImageFormat aFormat, TBool& aTestPass, TInt& aFinishedCounter, const TTestType& aTestType, VGImage aVGImage)
+    {
+    CTReadWriteMain* self = new (ELeave) CTReadWriteMain(aDisplay, aSurface, aContext, aWidth, aHeight, aByteSize, aFormat, aTestPass, aFinishedCounter, aTestType);
+    CleanupStack::PushL(self);
+    self->ConstructL(aVGImage);
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+void CTReadWriteMain::ConstructL(VGImage aVGImage)
+    {
+    //NULL values indicate a programming error
+    if( (iDisplay == EGL_NO_DISPLAY) || (iSurface == EGL_NO_SURFACE) || (iContext == EGL_NO_CONTEXT) || (iFinishedCounter == 0) || ((iTestType == EStressVGImage) && (aVGImage == NULL)) )
+        {
+        User::Leave(KErrArgument);
+        }
+    
+    iVGImage = aVGImage;
+    
+    //Call base class function to complete construction
+     CTReadWrite::ConstructL();
+    }
+
+void CTReadWriteMain::MakeCurrentL() const
+    {
+    EGL_LEAVE_ERROR(eglMakeCurrent(iDisplay, iSurface, iSurface, iContext));
+    }
+
+void CTReadWriteMain::ReadImageFuncL()
+    {
+    vgReadPixels(iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);
+    VgLeaveIfErrorL();
+    }
+
+void CTReadWriteMain::ReadFuncL()
+    {
+    ReadImageFuncL();
+    }
+
+void CTReadWriteMain::WriteImageFuncL()
+    {
+    vgWritePixels(iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);
+    VgLeaveIfErrorL();
+    }
+
+TBool CTReadWriteMain::IsFinished()
+    {
+    iFinishedCounter--;
+
+    if(iFinishedCounter <= 0)
+        {
+        return ETrue;
+        }
+
+    return EFalse;
+    }
+
+void CTReadWriteMain::VgImageFuncL()
+    {
+    //Alter the image data, actual pixel values are not important
+    for(TInt i=0; i<iBufferSize; i++)
+        {
+        const TUint32 temp = iBufferSize % iFrameNumber;
+        iData[i] = temp + (temp << 8) + (temp << 16) + (temp << 24);
+        }
+    
+    //Currently panics as context->scanlinebuffer is NULL
+    vgImageSubData(iVGImage, iData, iWidth*iByteSize, iFormat, 0, 0, iWidth, iHeight);
+    VgLeaveIfErrorL();
+    
+    EGL_LEAVE_ERROR(eglSwapBuffers(iDisplay, iSurface));
+    }
+
+void CTReadWriteMain::PixmapSurfaceFuncL()
+    {
+    // clear surface background to an arbitrary colour
+    VGfloat arbitraryColour = (1.0*iFrameNumber)/KNumberOfFrames;
+    VGfloat backgroundColour[] = {1.0 - arbitraryColour/2, arbitraryColour/2, 1.0 - arbitraryColour, arbitraryColour};
+    vgSetfv(VG_CLEAR_COLOR, 4, backgroundColour);
+    VgLeaveIfErrorL();
+    vgClear(0, 0, iWidth, iHeight);
+    VgLeaveIfErrorL();
+
+    EGL_LEAVE_ERROR(eglSwapBuffers(iDisplay, iSurface));
+    }