1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8
9 #include "include/core/SkMatrix.h"
10 #include "include/private/GrTypesPriv.h"
11 #include "src/gpu/GrDataUtils.h"
12 #include "src/gpu/gl/GrGLUtil.h"
13 #include <stdio.h>
14
15 ///////////////////////////////////////////////////////////////////////////////
16
17 #if GR_GL_LOG_CALLS
18 bool gLogCallsGL = !!(GR_GL_LOG_CALLS_START);
19 #endif
20
21 #if GR_GL_CHECK_ERROR
22 bool gCheckErrorGL = !!(GR_GL_CHECK_ERROR_START);
23 #endif
24
25 ///////////////////////////////////////////////////////////////////////////////
26
GrGLGetStandardInUseFromString(const char * versionString)27 GrGLStandard GrGLGetStandardInUseFromString(const char* versionString) {
28 if (!versionString) {
29 SkDebugf("nullptr GL version string.");
30 return kNone_GrGLStandard;
31 }
32
33 int major, minor;
34
35 // check for desktop
36 int n = sscanf(versionString, "%d.%d", &major, &minor);
37 if (2 == n) {
38 return kGL_GrGLStandard;
39 }
40
41 // WebGL might look like "OpenGL ES 2.0 (WebGL 1.0 (OpenGL ES 2.0 Chromium))"
42 int esMajor, esMinor;
43 n = sscanf(versionString, "OpenGL ES %d.%d (WebGL %d.%d", &esMajor, &esMinor, &major, &minor);
44 if (4 == n) {
45 return kWebGL_GrGLStandard;
46 }
47
48 // check for ES 1
49 char profile[2];
50 n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1, &major, &minor);
51 if (4 == n) {
52 // we no longer support ES1.
53 return kNone_GrGLStandard;
54 }
55
56 // check for ES2
57 n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor);
58 if (2 == n) {
59 return kGLES_GrGLStandard;
60 }
61 return kNone_GrGLStandard;
62 }
63
GrGLGetVersionFromString(const char * versionString)64 GrGLVersion GrGLGetVersionFromString(const char* versionString) {
65 if (!versionString) {
66 SkDebugf("nullptr GL version string.");
67 return GR_GL_INVALID_VER;
68 }
69
70 int major, minor;
71
72 // check for mesa
73 int mesaMajor, mesaMinor;
74 int n = sscanf(versionString, "%d.%d Mesa %d.%d", &major, &minor, &mesaMajor, &mesaMinor);
75 if (4 == n) {
76 return GR_GL_VER(major, minor);
77 }
78
79 n = sscanf(versionString, "%d.%d", &major, &minor);
80 if (2 == n) {
81 return GR_GL_VER(major, minor);
82 }
83
84 // WebGL might look like "OpenGL ES 2.0 (WebGL 1.0 (OpenGL ES 2.0 Chromium))"
85 int esMajor, esMinor;
86 n = sscanf(versionString, "OpenGL ES %d.%d (WebGL %d.%d", &esMajor, &esMinor, &major, &minor);
87 if (4 == n) {
88 return GR_GL_VER(major, minor);
89 }
90
91 char profile[2];
92 n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile + 1, &major, &minor);
93 if (4 == n) {
94 return GR_GL_VER(major, minor);
95 }
96
97 n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor);
98 if (2 == n) {
99 return GR_GL_VER(major, minor);
100 }
101
102 return GR_GL_INVALID_VER;
103 }
104
GrGLGetVersion(const GrGLInterface * gl)105 GrGLVersion GrGLGetVersion(const GrGLInterface* gl) {
106 SkASSERT(gl);
107 const GrGLubyte* v;
108 GR_GL_CALL_RET(gl, v, GetString(GR_GL_VERSION));
109 return GrGLGetVersionFromString((const char*)v);
110 }
111
get_glsl_version(const char * versionString)112 static GrGLSLVersion get_glsl_version(const char* versionString) {
113 SkASSERT(versionString);
114 int major, minor;
115
116 int n = sscanf(versionString, "%d.%d", &major, &minor);
117 if (2 == n) {
118 return GR_GLSL_VER(major, minor);
119 }
120
121 n = sscanf(versionString, "OpenGL ES GLSL ES %d.%d", &major, &minor);
122 if (2 == n) {
123 return GR_GLSL_VER(major, minor);
124 }
125
126 #ifdef SK_BUILD_FOR_ANDROID
127 // android hack until the gpu vender updates their drivers
128 n = sscanf(versionString, "OpenGL ES GLSL %d.%d", &major, &minor);
129 if (2 == n) {
130 return GR_GLSL_VER(major, minor);
131 }
132 #endif
133
134 return GR_GLSL_INVALID_VER;
135 }
136
get_vendor(const char * vendorString)137 static GrGLVendor get_vendor(const char* vendorString) {
138 SkASSERT(vendorString);
139 if (0 == strcmp(vendorString, "ARM")) {
140 return GrGLVendor::kARM;
141 }
142 if (0 == strcmp(vendorString, "Google Inc.")) {
143 return GrGLVendor::kGoogle;
144 }
145 if (0 == strcmp(vendorString, "Imagination Technologies")) {
146 return GrGLVendor::kImagination;
147 }
148 if (0 == strncmp(vendorString, "Intel ", 6) || 0 == strcmp(vendorString, "Intel")) {
149 return GrGLVendor::kIntel;
150 }
151 if (0 == strcmp(vendorString, "Qualcomm") || 0 == strcmp(vendorString, "freedreno")) {
152 return GrGLVendor::kQualcomm;
153 }
154 if (0 == strcmp(vendorString, "NVIDIA Corporation")) {
155 return GrGLVendor::kNVIDIA;
156 }
157 if (0 == strcmp(vendorString, "ATI Technologies Inc.")) {
158 return GrGLVendor::kATI;
159 }
160 return GrGLVendor::kOther;
161 }
162
get_renderer(const char * rendererString,const GrGLExtensions & extensions)163 static GrGLRenderer get_renderer(const char* rendererString, const GrGLExtensions& extensions) {
164 SkASSERT(rendererString);
165 static const char kTegraStr[] = "NVIDIA Tegra";
166 if (0 == strncmp(rendererString, kTegraStr, SK_ARRAY_COUNT(kTegraStr) - 1)) {
167 // Tegra strings are not very descriptive. We distinguish between the modern and legacy
168 // architectures by the presence of NV_path_rendering.
169 return extensions.has("GL_NV_path_rendering") ? GrGLRenderer::kTegra
170 : GrGLRenderer::kTegra_PreK1;
171 }
172 int lastDigit;
173 int n = sscanf(rendererString, "PowerVR SGX 54%d", &lastDigit);
174 if (1 == n && lastDigit >= 0 && lastDigit <= 9) {
175 return GrGLRenderer::kPowerVR54x;
176 }
177 // certain iOS devices also use PowerVR54x GPUs
178 static const char kAppleA4Str[] = "Apple A4";
179 static const char kAppleA5Str[] = "Apple A5";
180 static const char kAppleA6Str[] = "Apple A6";
181 if (0 == strncmp(rendererString, kAppleA4Str, SK_ARRAY_COUNT(kAppleA4Str) - 1) ||
182 0 == strncmp(rendererString, kAppleA5Str, SK_ARRAY_COUNT(kAppleA5Str) - 1) ||
183 0 == strncmp(rendererString, kAppleA6Str, SK_ARRAY_COUNT(kAppleA6Str) - 1)) {
184 return GrGLRenderer::kPowerVR54x;
185 }
186 static const char kPowerVRRogueStr[] = "PowerVR Rogue";
187 static const char kAppleA7Str[] = "Apple A7";
188 static const char kAppleA8Str[] = "Apple A8";
189 if (0 == strncmp(rendererString, kPowerVRRogueStr, SK_ARRAY_COUNT(kPowerVRRogueStr) - 1) ||
190 0 == strncmp(rendererString, kAppleA7Str, SK_ARRAY_COUNT(kAppleA7Str) - 1) ||
191 0 == strncmp(rendererString, kAppleA8Str, SK_ARRAY_COUNT(kAppleA8Str) - 1)) {
192 return GrGLRenderer::kPowerVRRogue;
193 }
194 int adrenoNumber;
195 n = sscanf(rendererString, "Adreno (TM) %d", &adrenoNumber);
196 if (n < 1) {
197 // retry with freedreno driver
198 n = sscanf(rendererString, "FD%d", &adrenoNumber);
199 }
200 if (1 == n) {
201 if (adrenoNumber >= 300) {
202 if (adrenoNumber < 400) {
203 return GrGLRenderer::kAdreno3xx;
204 }
205 if (adrenoNumber < 500) {
206 return adrenoNumber >= 430 ? GrGLRenderer::kAdreno430
207 : GrGLRenderer::kAdreno4xx_other;
208 }
209 if (adrenoNumber < 600) {
210 return adrenoNumber == 530 ? GrGLRenderer::kAdreno530
211 : GrGLRenderer::kAdreno5xx_other;
212 }
213 if (adrenoNumber < 700) {
214 if (adrenoNumber == 615) {
215 return GrGLRenderer::kAdreno615;
216 }
217 if (adrenoNumber == 620) {
218 return GrGLRenderer::kAdreno620;
219 }
220 if (adrenoNumber == 630) {
221 return GrGLRenderer::kAdreno630;
222 }
223 if (adrenoNumber == 640) {
224 return GrGLRenderer::kAdreno640;
225 }
226 return GrGLRenderer::kAdreno6xx_other;
227 }
228 }
229 }
230 if (0 == strcmp("Google SwiftShader", rendererString)) {
231 return GrGLRenderer::kGoogleSwiftShader;
232 }
233
234 if (const char* intelString = strstr(rendererString, "Intel")) {
235 // These generic strings seem to always come from Haswell: Iris 5100 or Iris Pro 5200
236 if (0 == strcmp("Intel Iris OpenGL Engine", intelString) ||
237 0 == strcmp("Intel Iris Pro OpenGL Engine", intelString)) {
238 return GrGLRenderer::kIntelHaswell;
239 }
240 if (strstr(intelString, "Sandybridge")) {
241 return GrGLRenderer::kIntelSandyBridge;
242 }
243 if (strstr(intelString, "Bay Trail")) {
244 return GrGLRenderer::kIntelValleyView;
245 }
246 // In Mesa, 'RKL' can be followed by 'Graphics', same for 'TGL' and 'ADL'.
247 // Referenced from the following Mesa source code:
248 // https://github.com/mesa3d/mesa/blob/master/include/pci_ids/iris_pci_ids.h
249 if (strstr(intelString, "RKL")) {
250 return GrGLRenderer::kIntelRocketLake;
251 }
252 if (strstr(intelString, "TGL")) {
253 return GrGLRenderer::kIntelTigerLake;
254 }
255 // For Windows on ADL-S devices, 'AlderLake-S' might be followed by 'Intel(R)'.
256 if (strstr(intelString, "ADL") || strstr(intelString, "AlderLake")) {
257 return GrGLRenderer::kIntelAlderLake;
258 }
259 // For Windows on TGL or other ADL devices, we might only get 'Xe' from the string.
260 // Since they are both 12th gen, we could temporarily use 'kIntelTigerLake' to cover
261 // both TGL and ADL.
262 if (strstr(intelString, "Xe")) {
263 return GrGLRenderer::kIntelTigerLake;
264 }
265 // There are many possible intervening strings here:
266 // 'Intel(R)' is a common prefix
267 // 'Iris' may appear, followed by '(R)' or '(TM)'
268 // 'Iris' can then be followed by 'Graphics', 'Pro Graphics', or 'Plus Graphics'
269 // If 'Iris' isn't there, we might have 'HD Graphics' or 'UHD Graphics'
270 //
271 // In all cases, though, we end with 'Graphics ', an optional 'P', and a number,
272 // so just skip to that and handle two cases:
273 if (const char* intelGfxString = strstr(intelString, "Graphics")) {
274 int intelNumber;
275 if (sscanf(intelGfxString, "Graphics %d", &intelNumber) ||
276 sscanf(intelGfxString, "Graphics P%d", &intelNumber)) {
277 if (intelNumber == 2000 || intelNumber == 3000) {
278 return GrGLRenderer::kIntelSandyBridge;
279 }
280 if (intelNumber == 2500 || intelNumber == 4000) {
281 return GrGLRenderer::kIntelIvyBridge;
282 }
283 if (intelNumber >= 4200 && intelNumber <= 5200) {
284 return GrGLRenderer::kIntelHaswell;
285 }
286 if (intelNumber >= 400 && intelNumber <= 405) {
287 return GrGLRenderer::kIntelCherryView;
288 }
289 if (intelNumber >= 5300 && intelNumber <= 6300) {
290 return GrGLRenderer::kIntelBroadwell;
291 }
292 if (intelNumber >= 500 && intelNumber <= 505) {
293 return GrGLRenderer::kIntelApolloLake;
294 }
295 if (intelNumber >= 510 && intelNumber <= 580) {
296 return GrGLRenderer::kIntelSkyLake;
297 }
298 if (intelNumber >= 600 && intelNumber <= 605) {
299 return GrGLRenderer::kIntelGeminiLake;
300 }
301 // 610 and 630 are reused from KabyLake to CoffeeLake. The CoffeeLake variants
302 // are "UHD Graphics", while the KabyLake ones are "HD Graphics"
303 if (intelNumber == 610 || intelNumber == 630) {
304 return strstr(intelString, "UHD") ? GrGLRenderer::kIntelCoffeeLake
305 : GrGLRenderer::kIntelKabyLake;
306 }
307 if (intelNumber >= 610 && intelNumber <= 650) {
308 return GrGLRenderer::kIntelKabyLake;
309 }
310 if (intelNumber == 655) {
311 return GrGLRenderer::kIntelCoffeeLake;
312 }
313 // 710/730/750/770 are all 12th gen UHD Graphics, but it's hard to distinguish
314 // among RKL, TGL and ADL. We might temporarily use 'kIntelTigerLake' to cover all.
315 if (intelNumber >= 710 && intelNumber <= 770) {
316 return GrGLRenderer::kIntelTigerLake;
317 }
318 if (intelNumber >= 910 && intelNumber <= 950) {
319 return GrGLRenderer::kIntelIceLake;
320 }
321 }
322 }
323 }
324
325 // The AMD string can have a somewhat arbitrary preamble (see skbug.com/7195)
326 static constexpr char kRadeonStr[] = "Radeon ";
327 if (const char* amdString = strstr(rendererString, kRadeonStr)) {
328 amdString += strlen(kRadeonStr);
329 // Sometimes there is a (TM) and sometimes not.
330 static constexpr char kTMStr[] = "(TM) ";
331 if (!strncmp(amdString, kTMStr, strlen(kTMStr))) {
332 amdString += strlen(kTMStr);
333 }
334
335 char amd0, amd1, amd2;
336 int amdModel;
337 n = sscanf(amdString, "R9 M3%c%c", &amd0, &amd1);
338 if (2 == n && isdigit(amd0) && isdigit(amd1)) {
339 return GrGLRenderer::kAMDRadeonR9M3xx;
340 }
341
342 n = sscanf(amdString, "R9 M4%c%c", &amd0, &amd1);
343 if (2 == n && isdigit(amd0) && isdigit(amd1)) {
344 return GrGLRenderer::kAMDRadeonR9M4xx;
345 }
346
347 n = sscanf(amdString, "HD 7%c%c%c Series", &amd0, &amd1, &amd2);
348 if (3 == n && isdigit(amd0) && isdigit(amd1) && isdigit(amd2)) {
349 return GrGLRenderer::kAMDRadeonHD7xxx;
350 }
351
352 n = sscanf(amdString, "Pro 5%c%c%c", &amd0, &amd1, &amd2);
353 if (3 == n && isdigit(amd0) && isdigit(amd1) && isdigit(amd2)) {
354 return GrGLRenderer::kAMDRadeonPro5xxx;
355 }
356
357 n = sscanf(amdString, "Pro Vega %i", &amdModel);
358 if (1 == n) {
359 return GrGLRenderer::kAMDRadeonProVegaxx;
360 }
361 }
362
363 if (strstr(rendererString, "llvmpipe")) {
364 return GrGLRenderer::kGalliumLLVM;
365 }
366 if (strstr(rendererString, "virgl")) {
367 return GrGLRenderer::kVirgl;
368 }
369 static const char kMaliGStr[] = "Mali-G";
370 if (0 == strncmp(rendererString, kMaliGStr, SK_ARRAY_COUNT(kMaliGStr) - 1)) {
371 return GrGLRenderer::kMaliG;
372 }
373 static const char kMaliTStr[] = "Mali-T";
374 if (0 == strncmp(rendererString, kMaliTStr, SK_ARRAY_COUNT(kMaliTStr) - 1)) {
375 return GrGLRenderer::kMaliT;
376 }
377 int mali400Num;
378 if (1 == sscanf(rendererString, "Mali-%d", &mali400Num) && mali400Num >= 400 &&
379 mali400Num < 500) {
380 return GrGLRenderer::kMali4xx;
381 }
382 return GrGLRenderer::kOther;
383 }
384
is_commamd_buffer(const char * rendererString,const char * versionString)385 static bool is_commamd_buffer(const char* rendererString, const char* versionString) {
386 SkASSERT(rendererString);
387 SkASSERT(versionString);
388
389 int major, minor;
390 static const char kChromium[] = "Chromium";
391 char suffix[SK_ARRAY_COUNT(kChromium)] = {0};
392 return (0 == strcmp(rendererString, kChromium) ||
393 (3 == sscanf(versionString, "OpenGL ES %d.%d %8s", &major, &minor, suffix) &&
394 0 == strcmp(kChromium, suffix)));
395 }
396
get_driver_and_version(GrGLStandard standard,GrGLVendor vendor,const char * vendorString,const char * rendererString,const char * versionString)397 static std::tuple<GrGLDriver, GrGLDriverVersion> get_driver_and_version(GrGLStandard standard,
398 GrGLVendor vendor,
399 const char* vendorString,
400 const char* rendererString,
401 const char* versionString) {
402 SkASSERT(rendererString);
403 SkASSERT(versionString);
404
405 GrGLDriver driver = GrGLDriver::kUnknown;
406 GrGLDriverVersion driverVersion = GR_GL_DRIVER_UNKNOWN_VER;
407
408 int major, minor, rev, driverMajor, driverMinor, driverPoint;
409 // This is the same on ES and regular GL.
410 if (!strcmp(vendorString, "freedreno")) {
411 driver = GrGLDriver::kFreedreno;
412 } else if (GR_IS_GR_GL(standard)) {
413 if (vendor == GrGLVendor::kNVIDIA) {
414 driver = GrGLDriver::kNVIDIA;
415 int n = sscanf(versionString,
416 "%d.%d.%d NVIDIA %d.%d",
417 &major,
418 &minor,
419 &rev,
420 &driverMajor,
421 &driverMinor);
422 // Some older NVIDIA drivers don't report the driver version.
423 if (n == 5) {
424 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, 0);
425 }
426 } else {
427 int n = sscanf(versionString,
428 "%d.%d Mesa %d.%d",
429 &major,
430 &minor,
431 &driverMajor,
432 &driverMinor);
433 if (n != 4) {
434 n = sscanf(versionString,
435 "%d.%d (Core Profile) Mesa %d.%d",
436 &major,
437 &minor,
438 &driverMajor,
439 &driverMinor);
440 }
441 if (n == 4) {
442 driver = GrGLDriver::kMesa;
443 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, 0);
444 }
445 }
446 } else if (standard == kGLES_GrGLStandard) {
447 if (vendor == GrGLVendor::kNVIDIA) {
448 driver = GrGLDriver::kNVIDIA;
449 int n = sscanf(versionString,
450 "OpenGL ES %d.%d NVIDIA %d.%d",
451 &major,
452 &minor,
453 &driverMajor,
454 &driverMinor);
455 // Some older NVIDIA drivers don't report the driver version.
456 if (n == 4) {
457 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, 0);
458 }
459 } else if (vendor == GrGLVendor::kImagination) {
460 int revision;
461 int n = sscanf(versionString,
462 "OpenGL ES %d.%d build %d.%d@%d",
463 &major,
464 &minor,
465 &driverMajor,
466 &driverMinor,
467 &revision);
468 if (n == 5) {
469 driver = GrGLDriver::kImagination;
470 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, 0);
471 }
472 } else {
473 int n = sscanf(versionString,
474 "OpenGL ES %d.%d Mesa %d.%d",
475 &major,
476 &minor,
477 &driverMajor,
478 &driverMinor);
479 if (n == 4) {
480 driver = GrGLDriver::kMesa;
481 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, 0);
482 }
483 }
484 }
485
486 if (driver == GrGLDriver::kUnknown) {
487 if (vendor == GrGLVendor::kGoogle) {
488 // Swiftshader is the only Google vendor at the moment
489 driver = GrGLDriver::kSwiftShader;
490
491 // Swiftshader has a strange version string: w.x.y.z Going to arbitrarily ignore
492 // y and assume w,x and z are major, minor, point.
493 // As of writing, version is 4.0.0.6
494 int n = sscanf(versionString,
495 "OpenGL ES %d.%d SwiftShader %d.%d.0.%d",
496 &major,
497 &minor,
498 &driverMajor,
499 &driverMinor,
500 &driverPoint);
501 if (n == 5) {
502 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, driverPoint);
503 }
504 } else if (vendor == GrGLVendor::kIntel) {
505 // We presume we're on the Intel driver since it hasn't identified itself as Mesa.
506 driver = GrGLDriver::kIntel;
507
508 // This is how the macOS version strings are structured. This might be different on
509 // different
510 // OSes.
511 int n = sscanf(versionString,
512 "%d.%d INTEL-%d.%d.%d",
513 &major,
514 &minor,
515 &driverMajor,
516 &driverMinor,
517 &driverPoint);
518 if (n == 5) {
519 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, driverPoint);
520 }
521 } else if (vendor == GrGLVendor::kQualcomm) {
522 driver = GrGLDriver::kQualcomm;
523 int n = sscanf(versionString,
524 "OpenGL ES %d.%d V@%d.%d",
525 &major,
526 &minor,
527 &driverMajor,
528 &driverMinor);
529 if (n == 4) {
530 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, 0);
531 }
532 } else if (vendor == GrGLVendor::kImagination) {
533 int revision;
534 int n = sscanf(versionString,
535 "OpenGL ES %d.%d build %d.%d@%d",
536 &major,
537 &minor,
538 &driverMajor,
539 &driverMinor,
540 &revision);
541 if (n == 5) {
542 // Revision is a large number (looks like a source control revision number) that
543 // doesn't fit into the 'patch' bits, so omit it until we need it.
544 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, 0);
545 }
546 } else if (vendor == GrGLVendor::kARM) {
547 // Example:
548 // OpenGL ES 3.2 v1.r26p0-01rel0.217d2597f6bd19b169343737782e56e3
549 // It's unclear how to interpret what comes between "p" and "rel". Every string we've
550 // seen so far has "0-01" there. We ignore it for now.
551 int ignored0;
552 int ignored1;
553 int n = sscanf(versionString,
554 "OpenGL ES %d.%d v%d.r%dp%d-%drel",
555 &major,
556 &minor,
557 &driverMajor,
558 &driverMinor,
559 &ignored0,
560 &ignored1);
561 if (n == 6) {
562 driver = GrGLDriver::kARM;
563 driverVersion = GR_GL_DRIVER_VER(driverMajor, driverMinor, 0);
564 }
565 } else {
566 static constexpr char kEmulatorPrefix[] = "Android Emulator OpenGL ES Translator";
567 if (0 == strncmp(kEmulatorPrefix, rendererString, strlen(kEmulatorPrefix))) {
568 driver = GrGLDriver::kAndroidEmulator;
569 }
570 }
571 }
572 return {driver, driverVersion};
573 }
574
575 // If this is detected as ANGLE then the ANGLE backend is returned along with rendererString
576 // stripped of "ANGLE(" and ")" at the start and end, respectively.
get_angle_backend(const char * rendererString)577 static std::tuple<GrGLANGLEBackend, SkString> get_angle_backend(const char* rendererString) {
578 // crbug.com/1203705 ANGLE renderer will be "ANGLE (<gl-vendor>, <gl-renderer>, <gl-version>)"
579 // on ANGLE's GL backend with related substitutions for the inner strings on other backends.
580 static constexpr char kHeader[] = "ANGLE (";
581 static constexpr size_t kHeaderLength = SK_ARRAY_COUNT(kHeader) - 1;
582 int rendererLength = strlen(rendererString);
583 if (!strncmp(rendererString, kHeader, kHeaderLength) &&
584 rendererString[rendererLength - 1] == ')') {
585 SkString innerString;
586 innerString.set(rendererString + kHeaderLength, rendererLength - kHeaderLength - 1);
587 if (strstr(rendererString, "Direct3D11")) {
588 return {GrGLANGLEBackend::kD3D11, std::move(innerString)};
589 } else if (strstr(rendererString, "Direct3D9")) {
590 return {GrGLANGLEBackend::kD3D9, std::move(innerString)};
591 } else if (strstr(rendererString, "OpenGL")) {
592 return {GrGLANGLEBackend::kOpenGL, std::move(innerString)};
593 }
594 }
595 return {GrGLANGLEBackend::kUnknown, {}};
596 }
597
598 static std::tuple<GrGLVendor, GrGLRenderer, GrGLDriver, GrGLDriverVersion>
get_angle_gl_vendor_and_renderer(const char * innerString,const GrGLExtensions & extensions)599 get_angle_gl_vendor_and_renderer(
600 const char* innerString,
601 const GrGLExtensions& extensions) {
602 SkTArray<SkString> parts;
603 SkStrSplit(innerString, ",", &parts);
604 // This would need some fixing if we have substrings that contain commas.
605 if (parts.size() != 3) {
606 return {GrGLVendor::kOther,
607 GrGLRenderer::kOther,
608 GrGLDriver::kUnknown,
609 GR_GL_DRIVER_UNKNOWN_VER};
610 }
611
612 const char* angleVendorString = parts[0].c_str();
613 const char* angleRendererString = parts[1].c_str() + 1; // skip initial space
614 const char* angleVersionString = parts[2].c_str() + 1; // skip initial space
615
616 GrGLVendor angleVendor = get_vendor(angleVendorString);
617
618 auto [angleDriver, angleDriverVersion] = get_driver_and_version(kGLES_GrGLStandard,
619 angleVendor,
620 angleVendorString,
621 angleRendererString,
622 angleVersionString);
623
624 auto angleRenderer = get_renderer(angleRendererString, extensions);
625
626 return {angleVendor, angleRenderer, angleDriver, angleDriverVersion};
627 }
628
629 static std::tuple<GrGLVendor, GrGLRenderer, GrGLDriver, GrGLDriverVersion>
get_angle_d3d_vendor_and_renderer(const char * innerString)630 get_angle_d3d_vendor_and_renderer(const char* innerString) {
631 auto vendor = GrGLVendor::kOther;
632 auto renderer = GrGLRenderer::kOther;
633
634 if (strstr(innerString, "Intel")) {
635 vendor = GrGLVendor::kIntel;
636
637 const char* modelStr;
638 int modelNumber;
639 if ((modelStr = strstr(innerString, "HD Graphics")) &&
640 (1 == sscanf(modelStr, "HD Graphics %i", &modelNumber) ||
641 1 == sscanf(modelStr, "HD Graphics P%i", &modelNumber))) {
642 switch (modelNumber) {
643 case 2000:
644 case 3000:
645 renderer = GrGLRenderer::kIntelSandyBridge;
646 break;
647 case 4000:
648 case 2500:
649 renderer = GrGLRenderer::kIntelSandyBridge;
650 break;
651 case 510:
652 case 515:
653 case 520:
654 case 530:
655 renderer = GrGLRenderer::kIntelSkyLake;
656 break;
657 }
658 } else if ((modelStr = strstr(innerString, "Iris")) &&
659 (1 == sscanf(modelStr, "Iris(TM) Graphics %i", &modelNumber) ||
660 1 == sscanf(modelStr, "Iris(TM) Pro Graphics %i", &modelNumber) ||
661 1 == sscanf(modelStr, "Iris(TM) Pro Graphics P%i", &modelNumber))) {
662 switch (modelNumber) {
663 case 540:
664 case 550:
665 case 555:
666 case 580:
667 renderer = GrGLRenderer::kIntelSkyLake;
668 break;
669 }
670 }
671 } else if (strstr(innerString, "NVIDIA")) {
672 vendor = GrGLVendor::kNVIDIA;
673 } else if (strstr(innerString, "Radeon")) {
674 vendor = GrGLVendor::kATI;
675 }
676 // We haven't had a need yet to parse the D3D driver string.
677 return {vendor, renderer, GrGLDriver::kUnknown, GR_GL_DRIVER_UNKNOWN_VER};
678 }
679
GrGLGetDriverInfo(const GrGLInterface * interface)680 GrGLDriverInfo GrGLGetDriverInfo(const GrGLInterface* interface) {
681 if (!interface) {
682 return {};
683 }
684 SkASSERT(interface->fStandard != kNone_GrGLStandard);
685 GrGLDriverInfo info;
686 info.fStandard = interface->fStandard;
687
688 auto getString = [&](GrGLenum s) {
689 const GrGLubyte* bytes = interface->fFunctions.fGetString(s);
690 if (!bytes) {
691 return "";
692 }
693 return reinterpret_cast<const char*>(bytes);
694 };
695
696 const char* const version = getString(GR_GL_VERSION);
697 const char* const slversion = getString(GR_GL_SHADING_LANGUAGE_VERSION);
698 const char* const renderer = getString(GR_GL_RENDERER);
699 const char* const vendor = getString(GR_GL_VENDOR);
700
701 info.fVersion = GrGLGetVersionFromString(version);
702 info.fGLSLVersion = get_glsl_version(slversion);
703 info.fVendor = get_vendor(vendor);
704 info.fRenderer = get_renderer(renderer, interface->fExtensions);
705
706 std::tie(info.fDriver, info.fDriverVersion) = get_driver_and_version(interface->fStandard,
707 info.fVendor,
708 vendor,
709 renderer,
710 version);
711
712 SkString innerAngleRendererString;
713 std::tie(info.fANGLEBackend, innerAngleRendererString) = get_angle_backend(renderer);
714
715 if (info.fANGLEBackend == GrGLANGLEBackend::kD3D9 ||
716 info.fANGLEBackend == GrGLANGLEBackend::kD3D11) {
717 std::tie(info.fANGLEVendor,
718 info.fANGLERenderer,
719 info.fANGLEDriver,
720 info.fANGLEDriverVersion) =
721 get_angle_d3d_vendor_and_renderer(innerAngleRendererString.c_str());
722 } else if (info.fANGLEBackend == GrGLANGLEBackend::kOpenGL) {
723 std::tie(info.fANGLEVendor,
724 info.fANGLERenderer,
725 info.fANGLEDriver,
726 info.fANGLEDriverVersion) =
727 get_angle_gl_vendor_and_renderer(innerAngleRendererString.c_str(),
728 interface->fExtensions);
729 }
730
731 info.fIsOverCommandBuffer = is_commamd_buffer(renderer, version);
732
733 return info;
734 }
735
GrToGLStencilFunc(GrStencilTest test)736 GrGLenum GrToGLStencilFunc(GrStencilTest test) {
737 static const GrGLenum gTable[kGrStencilTestCount] = {
738 GR_GL_ALWAYS, // kAlways
739 GR_GL_NEVER, // kNever
740 GR_GL_GREATER, // kGreater
741 GR_GL_GEQUAL, // kGEqual
742 GR_GL_LESS, // kLess
743 GR_GL_LEQUAL, // kLEqual
744 GR_GL_EQUAL, // kEqual
745 GR_GL_NOTEQUAL, // kNotEqual
746 };
747 static_assert(0 == (int)GrStencilTest::kAlways);
748 static_assert(1 == (int)GrStencilTest::kNever);
749 static_assert(2 == (int)GrStencilTest::kGreater);
750 static_assert(3 == (int)GrStencilTest::kGEqual);
751 static_assert(4 == (int)GrStencilTest::kLess);
752 static_assert(5 == (int)GrStencilTest::kLEqual);
753 static_assert(6 == (int)GrStencilTest::kEqual);
754 static_assert(7 == (int)GrStencilTest::kNotEqual);
755 SkASSERT(test < (GrStencilTest)kGrStencilTestCount);
756
757 return gTable[(int)test];
758 }
759
GrGLFormatIsCompressed(GrGLFormat format)760 bool GrGLFormatIsCompressed(GrGLFormat format) {
761 switch (format) {
762 case GrGLFormat::kCOMPRESSED_ETC1_RGB8:
763 case GrGLFormat::kCOMPRESSED_RGB8_ETC2:
764 case GrGLFormat::kCOMPRESSED_RGB8_BC1:
765 case GrGLFormat::kCOMPRESSED_RGBA8_BC1:
766 return true;
767
768 case GrGLFormat::kRGBA8:
769 case GrGLFormat::kR8:
770 case GrGLFormat::kALPHA8:
771 case GrGLFormat::kLUMINANCE8:
772 case GrGLFormat::kLUMINANCE8_ALPHA8:
773 case GrGLFormat::kBGRA8:
774 case GrGLFormat::kRGB565:
775 case GrGLFormat::kRGBA16F:
776 case GrGLFormat::kR16F:
777 case GrGLFormat::kLUMINANCE16F:
778 case GrGLFormat::kRGB8:
779 case GrGLFormat::kRGBX8:
780 case GrGLFormat::kRG8:
781 case GrGLFormat::kRGB10_A2:
782 case GrGLFormat::kRGBA4:
783 case GrGLFormat::kSRGB8_ALPHA8:
784 case GrGLFormat::kR16:
785 case GrGLFormat::kRG16:
786 case GrGLFormat::kRGBA16:
787 case GrGLFormat::kRG16F:
788 case GrGLFormat::kSTENCIL_INDEX8:
789 case GrGLFormat::kSTENCIL_INDEX16:
790 case GrGLFormat::kDEPTH24_STENCIL8:
791 case GrGLFormat::kUnknown:
792 return false;
793 }
794 SkUNREACHABLE;
795 }
796
797