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/files/file_path.h" 12 #include "base/logging.h" 13 #include "base/native_library.h" 14 #include "base/path_service.h" 15 #include "base/strings/stringprintf.h" 16 #include "base/threading/thread_restrictions.h" 17 #include "base/win/windows_version.h" 18 #include "ui/gl/gl_bindings.h" 19 #include "ui/gl/gl_egl_api_implementation.h" 20 #include "ui/gl/gl_gl_api_implementation.h" 21 #include "ui/gl/gl_implementation.h" 22 #include "ui/gl/gl_osmesa_api_implementation.h" 23 #include "ui/gl/gl_wgl_api_implementation.h" 24 25 #if defined(ENABLE_SWIFTSHADER) 26 #include "software_renderer.h" 27 #endif 28 29 namespace gfx { 30 31 namespace { 32 33 // Version 43 is the latest version of D3DCompiler_nn.dll that works prior to 34 // Windows Vista. 35 const wchar_t kPreVistaD3DCompiler[] = L"D3DCompiler_43.dll"; 36 const wchar_t kPostVistaD3DCompiler[] = 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 } // namespace 62 63 void GetAllowedGLImplementations(std::vector<GLImplementation>* impls) { 64 impls->push_back(kGLImplementationEGLGLES2); 65 impls->push_back(kGLImplementationDesktopGL); 66 impls->push_back(kGLImplementationOSMesaGL); 67 } 68 69 bool InitializeGLBindings(GLImplementation implementation) { 70 // Prevent reinitialization with a different implementation. Once the gpu 71 // unit tests have initialized with kGLImplementationMock, we don't want to 72 // later switch to another GL implementation. 73 if (GetGLImplementation() != kGLImplementationNone) 74 return true; 75 76 // Allow the main thread or another to initialize these bindings 77 // after instituting restrictions on I/O. Going forward they will 78 // likely be used in the browser process on most platforms. The 79 // one-time initialization cost is small, between 2 and 5 ms. 80 base::ThreadRestrictions::ScopedAllowIO allow_io; 81 82 switch (implementation) { 83 case kGLImplementationOSMesaGL: { 84 base::FilePath module_path; 85 if (!PathService::Get(base::DIR_MODULE, &module_path)) { 86 LOG(ERROR) << "PathService::Get failed."; 87 return false; 88 } 89 90 base::NativeLibrary library = base::LoadNativeLibrary( 91 module_path.Append(L"osmesa.dll"), NULL); 92 if (!library) { 93 DVLOG(1) << "osmesa.dll not found"; 94 return false; 95 } 96 97 GLGetProcAddressProc get_proc_address = 98 reinterpret_cast<GLGetProcAddressProc>( 99 base::GetFunctionPointerFromNativeLibrary( 100 library, "OSMesaGetProcAddress")); 101 if (!get_proc_address) { 102 DLOG(ERROR) << "OSMesaGetProcAddress not found."; 103 base::UnloadNativeLibrary(library); 104 return false; 105 } 106 107 SetGLGetProcAddressProc(get_proc_address); 108 AddGLNativeLibrary(library); 109 SetGLImplementation(kGLImplementationOSMesaGL); 110 111 InitializeGLBindingsGL(); 112 InitializeGLBindingsOSMESA(); 113 break; 114 } 115 case kGLImplementationEGLGLES2: { 116 base::FilePath module_path; 117 if (!PathService::Get(base::DIR_MODULE, &module_path)) 118 return false; 119 120 // Attempt to load the D3DX shader compiler using the default search path 121 // and if that fails, using an absolute path. This is to ensure these DLLs 122 // are loaded before ANGLE is loaded in case they are not in the default 123 // search path. Prefer the post vista version. 124 if (base::win::GetVersion() < base::win::VERSION_VISTA || 125 !LoadD3DXLibrary(module_path, kPostVistaD3DCompiler)) { 126 LoadD3DXLibrary(module_path, kPreVistaD3DCompiler); 127 } 128 129 base::FilePath gles_path; 130 const CommandLine* command_line = CommandLine::ForCurrentProcess(); 131 bool using_swift_shader = 132 command_line->GetSwitchValueASCII(switches::kUseGL) == "swiftshader"; 133 if (using_swift_shader) { 134 if (!command_line->HasSwitch(switches::kSwiftShaderPath)) 135 return false; 136 gles_path = 137 command_line->GetSwitchValuePath(switches::kSwiftShaderPath); 138 // Preload library 139 LoadLibrary(L"ddraw.dll"); 140 } else { 141 gles_path = module_path; 142 } 143 144 // Load libglesv2.dll before libegl.dll because the latter is dependent on 145 // the former and if there is another version of libglesv2.dll in the dll 146 // search path, it will get loaded instead. 147 base::NativeLibrary gles_library = base::LoadNativeLibrary( 148 gles_path.Append(L"libglesv2.dll"), NULL); 149 if (!gles_library) { 150 DVLOG(1) << "libglesv2.dll not found"; 151 return false; 152 } 153 154 // When using EGL, first try eglGetProcAddress and then Windows 155 // GetProcAddress on both the EGL and GLES2 DLLs. 156 base::NativeLibrary egl_library = base::LoadNativeLibrary( 157 gles_path.Append(L"libegl.dll"), NULL); 158 if (!egl_library) { 159 DVLOG(1) << "libegl.dll not found."; 160 base::UnloadNativeLibrary(gles_library); 161 return false; 162 } 163 164 #if defined(ENABLE_SWIFTSHADER) 165 if (using_swift_shader) { 166 SetupSoftwareRenderer(gles_library); 167 } 168 #endif 169 170 GLGetProcAddressProc get_proc_address = 171 reinterpret_cast<GLGetProcAddressProc>( 172 base::GetFunctionPointerFromNativeLibrary( 173 egl_library, "eglGetProcAddress")); 174 if (!get_proc_address) { 175 LOG(ERROR) << "eglGetProcAddress not found."; 176 base::UnloadNativeLibrary(egl_library); 177 base::UnloadNativeLibrary(gles_library); 178 return false; 179 } 180 181 SetGLGetProcAddressProc(get_proc_address); 182 AddGLNativeLibrary(egl_library); 183 AddGLNativeLibrary(gles_library); 184 SetGLImplementation(kGLImplementationEGLGLES2); 185 186 InitializeGLBindingsGL(); 187 InitializeGLBindingsEGL(); 188 189 // These two functions take single precision float rather than double 190 // precision float parameters in GLES. 191 ::gfx::g_driver_gl.fn.glClearDepthFn = MarshalClearDepthToClearDepthf; 192 ::gfx::g_driver_gl.fn.glDepthRangeFn = MarshalDepthRangeToDepthRangef; 193 break; 194 } 195 case kGLImplementationDesktopGL: { 196 // When using Windows OpenGL, first try wglGetProcAddress and then 197 // Windows GetProcAddress. 198 base::NativeLibrary library = base::LoadNativeLibrary( 199 base::FilePath(L"opengl32.dll"), NULL); 200 if (!library) { 201 DVLOG(1) << "opengl32.dll not found"; 202 return false; 203 } 204 205 GLGetProcAddressProc get_proc_address = 206 reinterpret_cast<GLGetProcAddressProc>( 207 base::GetFunctionPointerFromNativeLibrary( 208 library, "wglGetProcAddress")); 209 if (!get_proc_address) { 210 LOG(ERROR) << "wglGetProcAddress not found."; 211 base::UnloadNativeLibrary(library); 212 return false; 213 } 214 215 SetGLGetProcAddressProc(get_proc_address); 216 AddGLNativeLibrary(library); 217 SetGLImplementation(kGLImplementationDesktopGL); 218 219 InitializeGLBindingsGL(); 220 InitializeGLBindingsWGL(); 221 break; 222 } 223 case kGLImplementationMockGL: { 224 SetGLGetProcAddressProc(GetMockGLProcAddress); 225 SetGLImplementation(kGLImplementationMockGL); 226 InitializeGLBindingsGL(); 227 break; 228 } 229 default: 230 return false; 231 } 232 233 return true; 234 } 235 236 bool InitializeGLExtensionBindings(GLImplementation implementation, 237 GLContext* context) { 238 switch (implementation) { 239 case kGLImplementationOSMesaGL: 240 InitializeGLExtensionBindingsGL(context); 241 InitializeGLExtensionBindingsOSMESA(context); 242 break; 243 case kGLImplementationEGLGLES2: 244 InitializeGLExtensionBindingsGL(context); 245 InitializeGLExtensionBindingsEGL(context); 246 break; 247 case kGLImplementationDesktopGL: 248 InitializeGLExtensionBindingsGL(context); 249 InitializeGLExtensionBindingsWGL(context); 250 break; 251 case kGLImplementationMockGL: 252 InitializeGLExtensionBindingsGL(context); 253 break; 254 default: 255 return false; 256 } 257 258 return true; 259 } 260 261 void InitializeDebugGLBindings() { 262 InitializeDebugGLBindingsEGL(); 263 InitializeDebugGLBindingsGL(); 264 InitializeDebugGLBindingsOSMESA(); 265 InitializeDebugGLBindingsWGL(); 266 } 267 268 void ClearGLBindings() { 269 ClearGLBindingsEGL(); 270 ClearGLBindingsGL(); 271 ClearGLBindingsOSMESA(); 272 ClearGLBindingsWGL(); 273 SetGLImplementation(kGLImplementationNone); 274 UnloadGLNativeLibraries(); 275 } 276 277 bool GetGLWindowSystemBindingInfo(GLWindowSystemBindingInfo* info) { 278 switch (GetGLImplementation()) { 279 case kGLImplementationDesktopGL: 280 return GetGLWindowSystemBindingInfoWGL(info); 281 case kGLImplementationEGLGLES2: 282 return GetGLWindowSystemBindingInfoEGL(info); 283 default: 284 return false; 285 } 286 return false; 287 } 288 289 } // namespace gfx 290