1 /* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2  *

     3  * Permission is hereby granted, free of charge, to any person obtaining a

     4  * copy of this software and /or associated documentation files

     5  * (the "Materials "), to deal in the Materials without restriction,

     6  * including without limitation the rights to use, copy, modify, merge,

     7  * publish, distribute, sublicense, and/or sell copies of the Materials,

     8  * and to permit persons to whom the Materials are furnished to do so,

     9  * subject to the following conditions:

    10  *

    11  * The above copyright notice and this permission notice shall be included

    12  * in all copies or substantial portions of the Materials.

    13  *

    14  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    15  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    16  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    17  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

    18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

    19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

    20  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    21  *

    22  * Initial Contributors:

    23  * Nokia Corporation - initial contribution.

    24  *

    25  * Contributors:

    26  *

    27  * Description:

    28  *

    29  */

    30 

    31 #include "EGLOs.h"

    32 #include "EGLState.h"

    33 #include "EGLProcess.h"

    34 #include "EGLThread.h"

    35 #include "EGLWindowSurface.h"

    36 #include "EGLDisplay.h"

    37 

    38 #include <dlfcn.h>

    39 

    40 void CEGLOs::InitializeLock( EGLI_LOCK *lock )

    41     {

    42     // \todo

    43     EGLI_ASSERT( false );

    44     }

    45 

    46 void CEGLOs::GetLock( EGLI_LOCK *lock )

    47     {

    48     // \todo

    49     EGLI_ASSERT( false );

    50     }

    51 

    52 void CEGLOs::ReleaseLock(EGLI_LOCK *lock )

    53     {

    54     // \todo

    55     EGLI_ASSERT( false );

    56     }

    57 

    58 void CEGLOs::DestroyLock( EGLI_LOCK *lock )

    59     {

    60     // \todo

    61     EGLI_ASSERT( false );

    62     }

    63 

    64 void CEGLOs::ConfigToNativePixelFormat( const CEGLConfig& config, EGLINativePixelFormatType* nativeFormat )

    65     {

    66     // \todo

    67     EGLI_ASSERT( false );

    68     }

    69 

    70 /*static*/ EGLINativeContextType CEGLOs::CreateNativeContext( const CEGLConfig& config, EGLINativeDisplayType display, EGLINativeContextType shareContext )

    71     {

    72     // \todo

    73     EGLI_ASSERT( false );

    74     return NULL;

    75     }

    76 

    77 EGLINativeContextType CEGLOs::CurrentNativeContext()

    78     {

    79     // \todo

    80     EGLI_ASSERT( false );

    81     return NULL;

    82     }

    83 

    84 EGLINativeDisplayType CEGLOs::CurrentNativeSurface()

    85     {

    86     // \todo

    87     EGLI_ASSERT( false );

    88     return NULL;

    89     }

    90 

    91 bool CEGLOs::MakeNativeContextCurrent( struct EGLINativeGLFunctions* func, EGLINativeDisplayType draw, EGLINativeDisplayType read, EGLINativeContextType context )

    92     {

    93     // \todo

    94     EGLI_ASSERT( false );

    95     return false;

    96     }

    97 

    98 bool CEGLOs::DestroyNativeContext( EGLINativeContextType context )

    99     {

   100     // \todo

   101     EGLI_ASSERT( false );

   102     return false;

   103     }

   104 

   105 bool CEGLOs::InitializeNativeGLFunctions( struct EGLINativeGLFunctions* func, EGLINativeDisplayType display, EGLINativeContextType context )

   106     {

   107     // \todo

   108     EGLI_ASSERT( false );

   109     return false;

   110     }

   111 

   112 struct EGLINativePbufferContainer* CEGLOs::CreateNativePbuffer( EGLINativeDisplayType display,

   113         const CEGLConfig& config, EGLint width, EGLint height, EGLBoolean largestPbuffer,

   114         EGLint textureFormat, EGLint textureTarget )

   115     {

   116     // \todo

   117     EGLI_ASSERT( false );

   118     return NULL;

   119     }

   120 

   121 bool CEGLOs::DestroyNativePbuffer( struct EGLINativePbufferContainer* container )

   122     {

   123     // \todo

   124     EGLI_ASSERT( false );

   125     return false;

   126     }

   127 

   128 EGLINativeWindowType CEGLOs::CreateNativeWindow( int width, int height )

   129     {

   130     // \todo

   131     EGLI_ASSERT( false );

   132     return NULL;

   133     }

   134 

   135 bool CEGLOs::IsValidNativeWindow( EGLINativeWindowType wnd )

   136     {

   137     // \todo

   138     EGLI_ASSERT( false );

   139     return false;

   140     }

   141 

   142 bool CEGLOs::GetNativeWindowSize( EGLINativeWindowType wnd, int& width, int& height )

   143     {

   144     // \todo

   145     EGLI_ASSERT( false );

   146     return false;

   147     }

   148 

   149 EGLIOsWindowContext* CEGLOs::CreateOSWindowContext( EGLINativeWindowType wnd, const CEGLConfig& config )

   150     {

   151     // \todo

   152     EGLI_ASSERT( false );

   153     return NULL;

   154     }

   155 

   156 void CEGLOs::DestroyOSWindowContext( EGLIOsWindowContext* context )

   157     {

   158     // \todo

   159     EGLI_ASSERT( false );

   160     }

   161 

   162 void CEGLOs::BlitToOSWindow( EGLenum api, CEGLDisplay* display, EGLIOsWindowContext* context, void* buf, int w, int h, int stride )

   163     {

   164     // \todo

   165     EGLI_ASSERT( false );

   166     }

   167 

   168 void* CEGLOs::LoadHostGL()

   169     {

   170     EGLI_ASSERT(0);

   171     return NULL;

   172     }

   173 

   174 void* CEGLOs::GetGLProcAddress(EGLILibraryHandle& libraryHandle, const char* proc)

   175     {

   176     EGLI_ASSERT(0);

   177     return NULL;

   178     }

   179 

   180 bool CEGLOs::FreeClientLibrary(EGLILibraryHandle& libraryHandle)

   181     {

   182     //assert(libraryHandle);

   183     return (dlclose(libraryHandle) == 0);

   184     }

   185 

   186 IEGLtoVGInterface* CEGLOs::LoadVGInterface( void*& libraryHandle )

   187     {

   188     fpGetVGInterface proc;

   189     void* libHandle = dlopen("libopenvg_sf.so", RTLD_NOW);

   190 

   191     if (libHandle == NULL)

   192         return NULL;

   193 

   194     libraryHandle = libHandle;

   195     proc = (fpGetVGInterface)dlsym(libHandle, "getVGInterface");

   196 

   197     if (!proc)

   198         return NULL;

   199 

   200     return proc();

   201     }

   202 

   203 IEGLtoGLES2Interface* CEGLOs::LoadGLES2Interface( void*& libraryHandle )

   204     {

   205     EGLI_ASSERT( false );

   206     return NULL;

   207     }