Home | History | Annotate | Download | only in gl 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <vector>
      6 
      7 #include "base/at_exit.h"
      8 #include "base/base_paths.h"
      9 #include "base/bind.h"
     10 #include "base/command_line.h"
     11 #include "base/debug/trace_event.h"
     12 #include "base/files/file_path.h"
     13 #include "base/logging.h"
     14 #include "base/native_library.h"
     15 #include "base/path_service.h"
     16 #include "base/strings/stringprintf.h"
     17 #include "base/threading/thread_restrictions.h"
     18 #include "base/win/windows_version.h"
     19 #include "ui/gl/gl_bindings.h"
     20 #include "ui/gl/gl_context_stub_with_extensions.h"
     21 #include "ui/gl/gl_egl_api_implementation.h"
     22 #include "ui/gl/gl_gl_api_implementation.h"
     23 #include "ui/gl/gl_implementation.h"
     24 #include "ui/gl/gl_osmesa_api_implementation.h"
     25 #include "ui/gl/gl_surface_wgl.h"
     26 #include "ui/gl/gl_wgl_api_implementation.h"
     27 
     28 #if defined(ENABLE_SWIFTSHADER)
     29 #include "software_renderer.h"
     30 #endif
     31 
     32 namespace gfx {
     33 
     34 namespace {
     35 
     36 const wchar_t kD3DCompiler[] = L"D3DCompiler_46.dll";
     37 
     38 void GL_BINDING_CALL MarshalClearDepthToClearDepthf(GLclampd depth) {
     39   glClearDepthf(static_cast<GLclampf>(depth));
     40 }
     41 
     42 void GL_BINDING_CALL MarshalDepthRangeToDepthRangef(GLclampd z_near,
     43                                                     GLclampd z_far) {
     44   glDepthRangef(static_cast<GLclampf>(z_near), static_cast<GLclampf>(z_far));
     45 }
     46 
     47 bool LoadD3DXLibrary(const base::FilePath& module_path,
     48                      const base::FilePath::StringType& name) {
     49   base::NativeLibrary library =
     50       base::LoadNativeLibrary(base::FilePath(name), NULL);
     51   if (!library) {
     52     library = base::LoadNativeLibrary(module_path.Append(name), NULL);
     53     if (!library) {
     54       DVLOG(1) << name << " not found.";
     55       return false;
     56     }
     57   }
     58   return true;
     59 }
     60 
     61 const unsigned char* AngleGetTraceCategoryEnabledFlag(const char* name) {
     62   return TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(name);
     63 }
     64 
     65 void AngleAddTraceEvent(char phase,
     66                         const unsigned char* category_group_enabled,
     67                         const char* name,
     68                         unsigned long long id,
     69                         int num_args,
     70                         const char** arg_names,
     71                         const unsigned char* arg_types,
     72                         const unsigned long long* arg_values,
     73                         unsigned char flags) {
     74   TRACE_EVENT_API_ADD_TRACE_EVENT(phase,
     75                                   category_group_enabled,
     76                                   name,
     77                                   id,
     78                                   num_args,
     79                                   arg_names,
     80                                   arg_types,
     81                                   arg_values,
     82                                   NULL,
     83                                   flags);
     84 }
     85 
     86 typedef const unsigned char* (*GetCategoryEnabledFlagFunc)(const char* name);
     87 typedef void (*AddTraceEventFunc)(char phase,
     88                                   const unsigned char* categoryGroupEnabled,
     89                                   const char* name,
     90                                   unsigned long long id,
     91                                   int numArgs,
     92                                   const char** argNames,
     93                                   const unsigned char* argTypes,
     94                                   const unsigned long long* argValues,
     95                                   unsigned char flags);
     96 typedef void (__stdcall *SetTraceFunctionPointersFunc)(
     97     GetCategoryEnabledFlagFunc get_category_enabled_flag,
     98     AddTraceEventFunc add_trace_event_func);
     99 
    100 }  // namespace
    101 
    102 void GetAllowedGLImplementations(std::vector<GLImplementation>* impls) {
    103   impls->push_back(kGLImplementationEGLGLES2);
    104   impls->push_back(kGLImplementationDesktopGL);
    105   impls->push_back(kGLImplementationOSMesaGL);
    106 }
    107 
    108 bool InitializeStaticGLBindings(GLImplementation implementation) {
    109   // Prevent reinitialization with a different implementation. Once the gpu
    110   // unit tests have initialized with kGLImplementationMock, we don't want to
    111   // later switch to another GL implementation.
    112   DCHECK_EQ(kGLImplementationNone, GetGLImplementation());
    113 
    114   // Allow the main thread or another to initialize these bindings
    115   // after instituting restrictions on I/O. Going forward they will
    116   // likely be used in the browser process on most platforms. The
    117   // one-time initialization cost is small, between 2 and 5 ms.
    118   base::ThreadRestrictions::ScopedAllowIO allow_io;
    119 
    120   switch (implementation) {
    121     case kGLImplementationOSMesaGL: {
    122       base::FilePath module_path;
    123       if (!PathService::Get(base::DIR_MODULE, &module_path)) {
    124         LOG(ERROR) << "PathService::Get failed.";
    125         return false;
    126       }
    127 
    128       base::NativeLibrary library = base::LoadNativeLibrary(
    129           module_path.Append(L"osmesa.dll"), NULL);
    130       if (!library) {
    131         DVLOG(1) << "osmesa.dll not found";
    132         return false;
    133       }
    134 
    135       GLGetProcAddressProc get_proc_address =
    136           reinterpret_cast<GLGetProcAddressProc>(
    137               base::GetFunctionPointerFromNativeLibrary(
    138                   library, "OSMesaGetProcAddress"));
    139       if (!get_proc_address) {
    140         DLOG(ERROR) << "OSMesaGetProcAddress not found.";
    141         base::UnloadNativeLibrary(library);
    142         return false;
    143       }
    144 
    145       SetGLGetProcAddressProc(get_proc_address);
    146       AddGLNativeLibrary(library);
    147       SetGLImplementation(kGLImplementationOSMesaGL);
    148 
    149       InitializeStaticGLBindingsGL();
    150       InitializeStaticGLBindingsOSMESA();
    151       break;
    152     }
    153     case kGLImplementationEGLGLES2: {
    154       base::FilePath module_path;
    155       if (!PathService::Get(base::DIR_MODULE, &module_path))
    156         return false;
    157 
    158       // Attempt to load the D3DX shader compiler using the default search path
    159       // and if that fails, using an absolute path. This is to ensure these DLLs
    160       // are loaded before ANGLE is loaded in case they are not in the default
    161       // search path.
    162       LoadD3DXLibrary(module_path, kD3DCompiler);
    163 
    164       base::FilePath gles_path;
    165       const CommandLine* command_line = CommandLine::ForCurrentProcess();
    166       bool using_swift_shader =
    167           command_line->GetSwitchValueASCII(switches::kUseGL) == "swiftshader";
    168       if (using_swift_shader) {
    169         if (!command_line->HasSwitch(switches::kSwiftShaderPath))
    170           return false;
    171         gles_path =
    172             command_line->GetSwitchValuePath(switches::kSwiftShaderPath);
    173         // Preload library
    174         LoadLibrary(L"ddraw.dll");
    175       } else {
    176         gles_path = module_path;
    177       }
    178 
    179       // Load libglesv2.dll before libegl.dll because the latter is dependent on
    180       // the former and if there is another version of libglesv2.dll in the dll
    181       // search path, it will get loaded instead.
    182       base::NativeLibrary gles_library = base::LoadNativeLibrary(
    183           gles_path.Append(L"libglesv2.dll"), NULL);
    184       if (!gles_library) {
    185         DVLOG(1) << "libglesv2.dll not found";
    186         return false;
    187       }
    188 
    189       // When using EGL, first try eglGetProcAddress and then Windows
    190       // GetProcAddress on both the EGL and GLES2 DLLs.
    191       base::NativeLibrary egl_library = base::LoadNativeLibrary(
    192           gles_path.Append(L"libegl.dll"), NULL);
    193       if (!egl_library) {
    194         DVLOG(1) << "libegl.dll not found.";
    195         base::UnloadNativeLibrary(gles_library);
    196         return false;
    197       }
    198 
    199 #if defined(ENABLE_SWIFTSHADER)
    200       if (using_swift_shader) {
    201         SetupSoftwareRenderer(gles_library);
    202       }
    203 #endif
    204 
    205       if (!using_swift_shader) {
    206         SetTraceFunctionPointersFunc set_trace_function_pointers =
    207             reinterpret_cast<SetTraceFunctionPointersFunc>(
    208                 base::GetFunctionPointerFromNativeLibrary(
    209                     gles_library, "SetTraceFunctionPointers"));
    210         if (set_trace_function_pointers) {
    211           set_trace_function_pointers(&AngleGetTraceCategoryEnabledFlag,
    212                                       &AngleAddTraceEvent);
    213         }
    214       }
    215 
    216       GLGetProcAddressProc get_proc_address =
    217           reinterpret_cast<GLGetProcAddressProc>(
    218               base::GetFunctionPointerFromNativeLibrary(
    219                   egl_library, "eglGetProcAddress"));
    220       if (!get_proc_address) {
    221         LOG(ERROR) << "eglGetProcAddress not found.";
    222         base::UnloadNativeLibrary(egl_library);
    223         base::UnloadNativeLibrary(gles_library);
    224         return false;
    225       }
    226 
    227       SetGLGetProcAddressProc(get_proc_address);
    228       AddGLNativeLibrary(egl_library);
    229       AddGLNativeLibrary(gles_library);
    230       SetGLImplementation(kGLImplementationEGLGLES2);
    231 
    232       InitializeStaticGLBindingsGL();
    233       InitializeStaticGLBindingsEGL();
    234 
    235       // These two functions take single precision float rather than double
    236       // precision float parameters in GLES.
    237       ::gfx::g_driver_gl.fn.glClearDepthFn = MarshalClearDepthToClearDepthf;
    238       ::gfx::g_driver_gl.fn.glDepthRangeFn = MarshalDepthRangeToDepthRangef;
    239       break;
    240     }
    241     case kGLImplementationDesktopGL: {
    242       base::NativeLibrary library = base::LoadNativeLibrary(
    243           base::FilePath(L"opengl32.dll"), NULL);
    244       if (!library) {
    245         DVLOG(1) << "opengl32.dll not found";
    246         return false;
    247       }
    248 
    249       GLGetProcAddressProc get_proc_address =
    250           reinterpret_cast<GLGetProcAddressProc>(
    251               base::GetFunctionPointerFromNativeLibrary(
    252                   library, "wglGetProcAddress"));
    253       if (!get_proc_address) {
    254         LOG(ERROR) << "wglGetProcAddress not found.";
    255         base::UnloadNativeLibrary(library);
    256         return false;
    257       }
    258 
    259       SetGLGetProcAddressProc(get_proc_address);
    260       AddGLNativeLibrary(library);
    261       SetGLImplementation(kGLImplementationDesktopGL);
    262 
    263       // Initialize GL surface and get some functions needed for the context
    264       // creation below.
    265       if (!GLSurfaceWGL::InitializeOneOff()) {
    266         LOG(ERROR) << "GLSurfaceWGL::InitializeOneOff failed.";
    267         return false;
    268       }
    269       wglCreateContextProc wglCreateContextFn =
    270           reinterpret_cast<wglCreateContextProc>(
    271               GetGLProcAddress("wglCreateContext"));
    272       wglDeleteContextProc wglDeleteContextFn =
    273           reinterpret_cast<wglDeleteContextProc>(
    274               GetGLProcAddress("wglDeleteContext"));
    275       wglMakeCurrentProc wglMakeCurrentFn =
    276           reinterpret_cast<wglMakeCurrentProc>(
    277               GetGLProcAddress("wglMakeCurrent"));
    278 
    279       // Create a temporary GL context to bind to entry points. This is needed
    280       // because wglGetProcAddress is specified to return NULL for all queries
    281       // if a context is not current in MSDN documentation, and the static
    282       // bindings may contain functions that need to be queried with
    283       // wglGetProcAddress. OpenGL wiki further warns that other error values
    284       // than NULL could also be returned from wglGetProcAddress on some
    285       // implementations, so we need to clear the WGL bindings and reinitialize
    286       // them after the context creation.
    287       HGLRC gl_context = wglCreateContextFn(GLSurfaceWGL::GetDisplayDC());
    288       if (!gl_context) {
    289         LOG(ERROR) << "Failed to create temporary context.";
    290         return false;
    291       }
    292       if (!wglMakeCurrentFn(GLSurfaceWGL::GetDisplayDC(), gl_context)) {
    293         LOG(ERROR) << "Failed to make temporary GL context current.";
    294         wglDeleteContextFn(gl_context);
    295         return false;
    296       }
    297 
    298       InitializeStaticGLBindingsGL();
    299       InitializeStaticGLBindingsWGL();
    300 
    301       wglMakeCurrent(NULL, NULL);
    302       wglDeleteContext(gl_context);
    303 
    304       break;
    305     }
    306     case kGLImplementationMockGL: {
    307       SetGLImplementation(kGLImplementationMockGL);
    308       InitializeStaticGLBindingsGL();
    309       break;
    310     }
    311     default:
    312       return false;
    313   }
    314 
    315   return true;
    316 }
    317 
    318 bool InitializeDynamicGLBindings(GLImplementation implementation,
    319     GLContext* context) {
    320   switch (implementation) {
    321     case kGLImplementationOSMesaGL:
    322       InitializeDynamicGLBindingsGL(context);
    323       InitializeDynamicGLBindingsOSMESA(context);
    324       break;
    325     case kGLImplementationEGLGLES2:
    326       InitializeDynamicGLBindingsGL(context);
    327       InitializeDynamicGLBindingsEGL(context);
    328       break;
    329     case kGLImplementationDesktopGL:
    330       InitializeDynamicGLBindingsGL(context);
    331       InitializeDynamicGLBindingsWGL(context);
    332       break;
    333     case kGLImplementationMockGL:
    334       if (!context) {
    335         scoped_refptr<GLContextStubWithExtensions> mock_context(
    336             new GLContextStubWithExtensions());
    337         mock_context->SetGLVersionString("3.0");
    338         InitializeDynamicGLBindingsGL(mock_context.get());
    339       } else
    340         InitializeDynamicGLBindingsGL(context);
    341       break;
    342     default:
    343       return false;
    344   }
    345 
    346   return true;
    347 }
    348 
    349 void InitializeDebugGLBindings() {
    350   InitializeDebugGLBindingsEGL();
    351   InitializeDebugGLBindingsGL();
    352   InitializeDebugGLBindingsOSMESA();
    353   InitializeDebugGLBindingsWGL();
    354 }
    355 
    356 void ClearGLBindings() {
    357   ClearGLBindingsEGL();
    358   ClearGLBindingsGL();
    359   ClearGLBindingsOSMESA();
    360   ClearGLBindingsWGL();
    361   SetGLImplementation(kGLImplementationNone);
    362   UnloadGLNativeLibraries();
    363 }
    364 
    365 bool GetGLWindowSystemBindingInfo(GLWindowSystemBindingInfo* info) {
    366   switch (GetGLImplementation()) {
    367     case kGLImplementationDesktopGL:
    368       return GetGLWindowSystemBindingInfoWGL(info);
    369     case kGLImplementationEGLGLES2:
    370       return GetGLWindowSystemBindingInfoEGL(info);
    371     default:
    372       return false;
    373   }
    374 }
    375 
    376 }  // namespace gfx
    377