#include "egltest_releaseimagegles.h"

#include "eglendpointwrap.h"

#include "egltest_surface.h"

//Remote test step----------------------------------------------------------------

CEglTest_RemoteTestStep_EndpointReleaseImageGles::CEglTest_RemoteTestStep_EndpointReleaseImageGles() :

    CRemoteTestStepBase(ETestUidEndpointReleaseImageGles)

    {

    }

CEglTest_RemoteTestStep_EndpointReleaseImageGles::~CEglTest_RemoteTestStep_EndpointReleaseImageGles()

    {

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointReleaseImageGles::DoStartRemoteTestStepL(const TRemoteTestParams& /*aMessageIn*/)

    {

    REMOTE_INFO_PRINTF1(_L("Starting Remote Test Step."));

    EglStartL();

    iDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    //Create a raw surface that will be encapsulated by the endpoint.

    iSurface = CRawSurface::NewL();

    iSurface->CreateL(EStandardSurface, TPoint(0, 0));

    TSurfaceId id = iSurface->SurfaceId();

    iEndpoint = EglEndpoint().CreateEndpoint(iDisplay, EGL_ENDPOINT_TYPE_CONSUMER_NOK, EGL_TSURFACEID_NOK, &id, NULL);

    if(iEndpoint == EGL_NO_ENDPOINT_NOK)

        {

        REMOTE_ERR_PRINTF1(_L("Failed to create endpoint."));

        User::Leave(KErrUnknown);

        }

    iSurface->DrawContentL(TRgb(128,128,128));

    User::LeaveIfError(iSurface->SubmitContent(EFalse));

    EGLBoolean ret = EglEndpoint().EndpointBeginStreaming(iDisplay, iEndpoint);

    if(!ret)

        {

        REMOTE_ERR_PRINTF1(_L("Failed to begin streaming from endpoint."));

        User::Leave(KErrUnknown);

        }

    return ERtvPass;

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointReleaseImageGles::DoEndRemoteTestStepL(const TRemoteTestParams& /*aMessageIn*/)

    {

    REMOTE_INFO_PRINTF1(_L("Ending Remote Test Step."));

    if(iEndpoint != EGL_NO_ENDPOINT_NOK)

        {

        EglEndpoint().EndpointEndStreaming(iDisplay, iEndpoint);

        EglEndpoint().DestroyEndpoint(iDisplay, iEndpoint);

        }

    delete iSurface;

    EglEndL();

    return ERtvPass;

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointReleaseImageGles::DoRunRemoteTestCaseL(TInt aTestCase, const TRemoteTestParams& aParams)

    {

    switch(aTestCase)

        {

        case 0:     return GlesContextTestCaseL(aParams);

        default:    return ERtvAbort;

        }

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointReleaseImageGles::GlesContextTestCaseL(const TRemoteTestParams& aParams)

    {

    //This test case acquires an image from an endpoint then attempts to 

    //release the image, passing in EGL_OPENGL_ES_API as the API flag.

    //There are two configurations for the test, that is controlled by

    //a flag in aParams. The options are to have a valid GLES context 

    //set current, or to have nothing current.

    EGLContext glesContext = EGL_NO_CONTEXT;

    EGLSurface glesSurface = EGL_NO_SURFACE;

    //Create GLES state and set it current if the test requires it.

    if(aParams.iEndpointReleaseImageGles.iUseValidGlesContext)

        {

        EGLConfig config;

        EGLint nConfigs = 0;

        static const EGLint KConfigAttribs[] =

        {

            EGL_BUFFER_SIZE,    32,

            EGL_RED_SIZE,       8,

            EGL_GREEN_SIZE,     8,

            EGL_BLUE_SIZE,      8,

            EGL_ALPHA_SIZE,     8,

            EGL_SURFACE_TYPE,   EGL_PBUFFER_BIT,

            EGL_RENDERABLE_TYPE,EGL_OPENGL_ES_BIT,

            EGL_NONE

        };

        eglChooseConfig(iDisplay, KConfigAttribs, &config, 1, &nConfigs);

        if (!nConfigs)

            {

            RDebug::Printf("%s:%d: err = %d", __FILE__, __LINE__, eglGetError());

            User::Leave(KErrNotSupported);

            }

        if (!eglBindAPI(EGL_OPENGL_ES_API))

            {

            RDebug::Printf("%s:%d: err = %d", __FILE__, __LINE__, eglGetError());

            User::Leave(KErrNotSupported);

            }

        glesContext = eglCreateContext(iDisplay, config, 0, NULL);

        if (glesContext == EGL_NO_CONTEXT)

            {

            RDebug::Printf("%s:%d: err = %d", __FILE__, __LINE__, eglGetError());

            User::Leave(KErrNotSupported);

            }

        static const EGLint KPbufferAttribs[] =

            {

            EGL_WIDTH, 100,

            EGL_HEIGHT, 100,

            EGL_NONE,

            };

        glesSurface = eglCreatePbufferSurface(iDisplay, config, KPbufferAttribs);

        if (glesSurface == EGL_NO_SURFACE)

            {

            RDebug::Printf("%s:%d: err = %x", __FILE__, __LINE__, eglGetError());

            User::Leave(KErrNotSupported);

            }

        eglMakeCurrent(iDisplay, glesSurface, glesSurface, glesContext);

        }

    //Run the test case ansd trap to give us an opportunity to destroy the GLES state if it exists.

    TRemoteTestVerdict verdict = ERtvPass;

    TRAPD(err, verdict = DoGlesContextTestCaseL(aParams));

    //Destroy the GLES state if it exists.

    if(aParams.iEndpointReleaseImageGles.iUseValidGlesContext)

        {

        eglMakeCurrent(iDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

        eglDestroySurface(iDisplay, glesSurface);

        eglDestroyContext(iDisplay, glesContext);

        }

    //Releave if the test left or return the verdict.

    User::LeaveIfError(err);

    return verdict;

    }

TRemoteTestVerdict CEglTest_RemoteTestStep_EndpointReleaseImageGles::DoGlesContextTestCaseL(const TRemoteTestParams& /*aParams*/)

    {

    //Draw to the surface and submit the update.

    iSurface->DrawContentL(TRgb(128,128,128));

    User::LeaveIfError(iSurface->SubmitContent(ETrue));

    //Acquire an image and check that it was successful.

    EGLImageKHR image = EglEndpoint().AcquireImage(iDisplay, iEndpoint);

    if(image == EGL_NO_IMAGE_KHR)

        {

        REMOTE_ERR_PRINTF2(_L("Failed to acquire image from endpoint with error = %d"), eglGetError());

        return ERtvFail;

        }

    //Attempt to release the image. This must always succeed regardless of whether there is a valid GLES context.

    EGLBoolean ret = EglEndpoint().ReleaseImage(iDisplay, iEndpoint, image, EGL_OPENGL_ES_API);

    if(!ret)

        {

        REMOTE_ERR_PRINTF2(_L("Failed to release image from endpoint with error = %d"), eglGetError());

        return ERtvFail;

        }

    return ERtvPass;

    }

//--------------------------------------------------------------------------------