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

     }