in src/gpu/ganesh/gl/GrGLUtil.cpp [176:403]
static GrGLRenderer get_renderer(const char* rendererString, const GrGLExtensions& extensions) {
SkASSERT(rendererString);
static const char kTegraStr[] = "NVIDIA Tegra";
if (0 == strncmp(rendererString, kTegraStr, std::size(kTegraStr) - 1)) {
// Tegra strings are not very descriptive. We distinguish between the modern and legacy
// architectures by the presence of NV_path_rendering.
return extensions.has("GL_NV_path_rendering") ? GrGLRenderer::kTegra
: GrGLRenderer::kTegra_PreK1;
}
int lastDigit;
int n = sscanf(rendererString, "PowerVR SGX 54%d", &lastDigit);
if (1 == n && lastDigit >= 0 && lastDigit <= 9) {
return GrGLRenderer::kPowerVR54x;
}
if (strstr(rendererString, "PowerVR B-Series")) {
return GrGLRenderer::kPowerVRBSeries;
}
// certain iOS devices also use PowerVR54x GPUs
static const char kAppleA4Str[] = "Apple A4";
static const char kAppleA5Str[] = "Apple A5";
static const char kAppleA6Str[] = "Apple A6";
if (0 == strncmp(rendererString, kAppleA4Str, std::size(kAppleA4Str) - 1) ||
0 == strncmp(rendererString, kAppleA5Str, std::size(kAppleA5Str) - 1) ||
0 == strncmp(rendererString, kAppleA6Str, std::size(kAppleA6Str) - 1)) {
return GrGLRenderer::kPowerVR54x;
}
static const char kPowerVRRogueStr[] = "PowerVR Rogue";
static const char kAppleA7Str[] = "Apple A7";
static const char kAppleA8Str[] = "Apple A8";
if (0 == strncmp(rendererString, kPowerVRRogueStr, std::size(kPowerVRRogueStr) - 1) ||
0 == strncmp(rendererString, kAppleA7Str, std::size(kAppleA7Str) - 1) ||
0 == strncmp(rendererString, kAppleA8Str, std::size(kAppleA8Str) - 1)) {
return GrGLRenderer::kPowerVRRogue;
}
int adrenoNumber;
n = sscanf(rendererString, "Adreno (TM) %d", &adrenoNumber);
if (n < 1) {
// retry with freedreno driver
n = sscanf(rendererString, "FD%d", &adrenoNumber);
}
if (1 == n) {
if (adrenoNumber >= 300) {
if (adrenoNumber < 400) {
return GrGLRenderer::kAdreno3xx;
}
if (adrenoNumber < 500) {
return adrenoNumber >= 430 ? GrGLRenderer::kAdreno430
: GrGLRenderer::kAdreno4xx_other;
}
if (adrenoNumber < 600) {
return adrenoNumber == 530 ? GrGLRenderer::kAdreno530
: GrGLRenderer::kAdreno5xx_other;
}
if (adrenoNumber < 700) {
if (adrenoNumber == 615) {
return GrGLRenderer::kAdreno615;
}
if (adrenoNumber == 620) {
return GrGLRenderer::kAdreno620;
}
if (adrenoNumber == 630) {
return GrGLRenderer::kAdreno630;
}
if (adrenoNumber == 640) {
return GrGLRenderer::kAdreno640;
}
return GrGLRenderer::kAdreno6xx_other;
}
}
}
if (const char* intelString = strstr(rendererString, "Intel")) {
// These generic strings seem to always come from Haswell: Iris 5100 or Iris Pro 5200
if (0 == strcmp("Intel Iris OpenGL Engine", intelString) ||
0 == strcmp("Intel Iris Pro OpenGL Engine", intelString)) {
return GrGLRenderer::kIntelHaswell;
}
if (strstr(intelString, "Sandybridge")) {
return GrGLRenderer::kIntelSandyBridge;
}
if (strstr(intelString, "Bay Trail")) {
return GrGLRenderer::kIntelValleyView;
}
// In Mesa, 'RKL' can be followed by 'Graphics', same for 'TGL' and 'ADL'.
// Referenced from the following Mesa source code:
// https://github.com/mesa3d/mesa/blob/master/include/pci_ids/iris_pci_ids.h
if (strstr(intelString, "RKL")) {
return GrGLRenderer::kIntelRocketLake;
}
if (strstr(intelString, "TGL")) {
return GrGLRenderer::kIntelTigerLake;
}
// For Windows on ADL-S devices, 'AlderLake-S' might be followed by 'Intel(R)'.
if (strstr(intelString, "ADL") || strstr(intelString, "AlderLake")) {
return GrGLRenderer::kIntelAlderLake;
}
// For Windows on TGL or other ADL devices, we might only get 'Xe' from the string.
// Since they are both 12th gen, we could temporarily use 'kIntelTigerLake' to cover
// both TGL and ADL.
if (strstr(intelString, "Xe")) {
return GrGLRenderer::kIntelTigerLake;
}
// There are many possible intervening strings here:
// 'Intel(R)' is a common prefix
// 'Iris' may appear, followed by '(R)' or '(TM)'
// 'Iris' can then be followed by 'Graphics', 'Pro Graphics', or 'Plus Graphics'
// If 'Iris' isn't there, we might have 'HD Graphics' or 'UHD Graphics'
//
// In all cases, though, we end with 'Graphics ', an optional 'P', and a number,
// so just skip to that and handle two cases:
if (const char* intelGfxString = strstr(intelString, "Graphics")) {
int intelNumber;
if (sscanf(intelGfxString, "Graphics %d", &intelNumber) ||
sscanf(intelGfxString, "Graphics P%d", &intelNumber)) {
if (intelNumber == 2000 || intelNumber == 3000) {
return GrGLRenderer::kIntelSandyBridge;
}
if (intelNumber == 2500 || intelNumber == 4000) {
return GrGLRenderer::kIntelIvyBridge;
}
if (intelNumber >= 4200 && intelNumber <= 5200) {
return GrGLRenderer::kIntelHaswell;
}
if (intelNumber >= 400 && intelNumber <= 405) {
return GrGLRenderer::kIntelCherryView;
}
if (intelNumber >= 5300 && intelNumber <= 6300) {
return GrGLRenderer::kIntelBroadwell;
}
if (intelNumber >= 500 && intelNumber <= 505) {
return GrGLRenderer::kIntelApolloLake;
}
if (intelNumber >= 510 && intelNumber <= 580) {
return GrGLRenderer::kIntelSkyLake;
}
if (intelNumber >= 600 && intelNumber <= 605) {
return GrGLRenderer::kIntelGeminiLake;
}
// 610 and 630 are reused from KabyLake to CoffeeLake. The CoffeeLake variants
// are "UHD Graphics", while the KabyLake ones are "HD Graphics"
if (intelNumber == 610 || intelNumber == 630) {
return strstr(intelString, "UHD") ? GrGLRenderer::kIntelCoffeeLake
: GrGLRenderer::kIntelKabyLake;
}
if (intelNumber >= 610 && intelNumber <= 650) {
return GrGLRenderer::kIntelKabyLake;
}
if (intelNumber == 655) {
return GrGLRenderer::kIntelCoffeeLake;
}
// 710/730/750/770 are all 12th gen UHD Graphics, but it's hard to distinguish
// among RKL, TGL and ADL. We might temporarily use 'kIntelTigerLake' to cover all.
if (intelNumber >= 710 && intelNumber <= 770) {
return GrGLRenderer::kIntelTigerLake;
}
if (intelNumber >= 910 && intelNumber <= 950) {
return GrGLRenderer::kIntelIceLake;
}
}
}
}
// The AMD string can have a somewhat arbitrary preamble (see skbug.com/7195)
static constexpr char kRadeonStr[] = "Radeon ";
if (const char* amdString = strstr(rendererString, kRadeonStr)) {
amdString += strlen(kRadeonStr);
// Sometimes there is a (TM) and sometimes not.
static constexpr char kTMStr[] = "(TM) ";
if (!strncmp(amdString, kTMStr, strlen(kTMStr))) {
amdString += strlen(kTMStr);
}
char amd0, amd1, amd2;
int amdModel;
n = sscanf(amdString, "R9 M3%c%c", &amd0, &amd1);
if (2 == n && isdigit(amd0) && isdigit(amd1)) {
return GrGLRenderer::kAMDRadeonR9M3xx;
}
n = sscanf(amdString, "R9 M4%c%c", &amd0, &amd1);
if (2 == n && isdigit(amd0) && isdigit(amd1)) {
return GrGLRenderer::kAMDRadeonR9M4xx;
}
n = sscanf(amdString, "HD 7%c%c%c Series", &amd0, &amd1, &amd2);
if (3 == n && isdigit(amd0) && isdigit(amd1) && isdigit(amd2)) {
return GrGLRenderer::kAMDRadeonHD7xxx;
}
n = sscanf(amdString, "Pro 5%c%c%c", &amd0, &amd1, &amd2);
if (3 == n && isdigit(amd0) && isdigit(amd1) && isdigit(amd2)) {
return GrGLRenderer::kAMDRadeonPro5xxx;
}
n = sscanf(amdString, "Pro Vega %i", &amdModel);
if (1 == n) {
return GrGLRenderer::kAMDRadeonProVegaxx;
}
}
if (strstr(rendererString, "llvmpipe")) {
return GrGLRenderer::kGalliumLLVM;
}
static const char kMaliGStr[] = "Mali-G";
if (0 == strncmp(rendererString, kMaliGStr, std::size(kMaliGStr) - 1)) {
return GrGLRenderer::kMaliG;
}
static const char kMaliTStr[] = "Mali-T";
if (0 == strncmp(rendererString, kMaliTStr, std::size(kMaliTStr) - 1)) {
return GrGLRenderer::kMaliT;
}
int mali400Num;
if (1 == sscanf(rendererString, "Mali-%d", &mali400Num) && mali400Num >= 400 &&
mali400Num < 500) {
return GrGLRenderer::kMali4xx;
}
static const char kAppleStr[] = "Apple";
if (0 == strncmp(rendererString, kAppleStr, std::size(kAppleStr) - 1)) {
return GrGLRenderer::kApple;
}
if (strstr(rendererString, "WebGL")) {
return GrGLRenderer::kWebGL;
}
return GrGLRenderer::kOther;
}