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

 @internalComponent - Internal Symbian test code

*/

#include <e32debug.h>

#include "eglendpointwrap.h"

#include "egltest_commscommon.h"

/*

 * TEglEndpointWrap is a simple class that presents all of the EGL endpoint

 * extension functions without the user needing to perform an eglGetProcAddress()

 * to obtain the function pointer. Each endpoint member function takes the same

 * arguments as the EGL functions and returns the same types. After construction

 * you should check the Error() function to ensure that all function pointers

 * were resolved. Trying to use one of the endpoint functions in the event of a

 * construction error will result in a panic.

 */

TEglEndpointWrap::TEglEndpointWrap()

    {

    //Save all the endpoint function pointers. If an error occurs, log it to iError.

    TRAP(iError,

        ipfnEglCreateEndpointNOK = reinterpret_cast<PFNEGLCREATEENDPOINTNOKPROC>(ProcAddressL("eglCreateEndpointNOK"));

        ipfnEglDestroyEndpointNOK = reinterpret_cast<PFNEGLDESTROYENDPOINTNOKPROC>(ProcAddressL("eglDestroyEndpointNOK"));

        ipfnEglGetEndpointAttribNOK = reinterpret_cast<PFNEGLGETENDPOINTATTRIBNOKPROC>(ProcAddressL("eglGetEndpointAttribNOK"));

        ipfnEglSetEndpointAttribNOK = reinterpret_cast<PFNEGLSETENDPOINTATTRIBNOKPROC>(ProcAddressL("eglSetEndpointAttribNOK"));

        ipfnEglEndpointBeginStreamingNOK = reinterpret_cast<PFNEGLENDPOINTBEGINSTREAMINGNOKPROC>(ProcAddressL("eglEndpointBeginStreamingNOK"));

        ipfnEglEndpointEndStreamingNOK = reinterpret_cast<PFNEGLENDPOINTENDSTREAMINGNOKPROC>(ProcAddressL("eglEndpointEndStreamingNOK"));

        ipfnEglAcquireImageNOK = reinterpret_cast<PFNEGLACQUIREIMAGENOKPROC>(ProcAddressL("eglAcquireImageNOK"));

        ipfnEglReleaseImageNOK = reinterpret_cast<PFNEGLRELEASEIMAGENOKPROC>(ProcAddressL("eglReleaseImageNOK"));

        ipfnEglGetEndpointDirtyAreaNOK = reinterpret_cast<PFNEGLGETENDPOINTDIRTYAREANOKPROC>(ProcAddressL("eglGetEndpointDirtyAreaNOK"));

        ipfnEglEndpointRequestNotificationNOK = reinterpret_cast<PFNEGLENDPOINTREQUESTNOTIFICATIONNOKPROC>(ProcAddressL("eglEndpointRequestNotificationNOK"));

        ipfnEglEndpointCancelNotificationNOK = reinterpret_cast<PFNEGLENDPOINTCANCELNOTIFICATIONNOKPROC>(ProcAddressL("eglEndpointCancelNotificationNOK"));

        ipfnEglDestroyImageKHR = reinterpret_cast<PFNEGLDESTROYIMAGEKHRPROC>(ProcAddressL("eglDestroyImageKHR"));

        );

    }

TInt TEglEndpointWrap::Error() const

    {

    return iError;

    }

TAnyFuncPtr TEglEndpointWrap::ProcAddressL(const char* aProcName) const

    {

    //get the function pointer and check for errors

    TAnyFuncPtr func = reinterpret_cast<TAnyFuncPtr>(eglGetProcAddress(aProcName));

    if(!func)

        {

        User::Leave(KErrNotFound);

        }

    return func;

    }

EGLEndpointNOK TEglEndpointWrap::CreateEndpoint(EGLDisplay dpy, EGLenum type, EGLenum source_type, 

                                                EGLEndpointSourceNOK source, const EGLint *attrib_list) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglCreateEndpointNOK(dpy, type, source_type, source, attrib_list);

    }

EGLBoolean TEglEndpointWrap::DestroyEndpoint(EGLDisplay dpy, EGLEndpointNOK endpoint) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglDestroyEndpointNOK(dpy, endpoint);

    }

EGLint TEglEndpointWrap::GetEndpointAttrib(EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint attrib) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglGetEndpointAttribNOK(dpy, endpoint, attrib);

    }

EGLBoolean TEglEndpointWrap::SetEndpointAttrib(EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint attrib, EGLint value) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglSetEndpointAttribNOK(dpy, endpoint, attrib, value);

    }

EGLBoolean TEglEndpointWrap::EndpointBeginStreaming(EGLDisplay dpy, EGLEndpointNOK endpoint) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglEndpointBeginStreamingNOK(dpy, endpoint);

    }

EGLBoolean TEglEndpointWrap::EndpointEndStreaming(EGLDisplay dpy, EGLEndpointNOK endpoint) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglEndpointEndStreamingNOK(dpy, endpoint);

    }

EGLImageKHR TEglEndpointWrap::AcquireImage(EGLDisplay dpy, EGLEndpointNOK endpoint) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglAcquireImageNOK(dpy, endpoint);

    }

EGLBoolean TEglEndpointWrap::ReleaseImage(EGLDisplay dpy, EGLEndpointNOK endpoint, EGLImageKHR image, EGLenum api) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglReleaseImageNOK(dpy, endpoint, image, api);

    }

EGLint TEglEndpointWrap::GetEndpointDirtyArea(EGLDisplay dpy, EGLEndpointNOK endpoint, EGLint* rects, 

                                              EGLint start_rect, EGLint max_rects, EGLBoolean collapse) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglGetEndpointDirtyAreaNOK(dpy, endpoint, rects, start_rect, max_rects, collapse);

    }

EGLBoolean TEglEndpointWrap::EndpointRequestNotification(EGLDisplay dpy, EGLEndpointNOK endpoint, EGLTRequestStatusNOK sync) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglEndpointRequestNotificationNOK(dpy, endpoint, sync);

    }

EGLBoolean TEglEndpointWrap::EndpointCancelNotification(EGLDisplay dpy, EGLEndpointNOK endpoint) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglEndpointCancelNotificationNOK(dpy, endpoint);

    }

EGLBoolean TEglEndpointWrap::DestroyImage(EGLDisplay dpy, EGLImageKHR image) const

    {

    ENDPOINT_ASSERT_DEBUG(iError == KErrNone, User::Invariant());

    return ipfnEglDestroyImageKHR(dpy, image);

    }