CommonFlagsConfig.cpp File Reference

#include "tools/flags/CommonFlagsConfig.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkSurfaceProps.h"
#include "src/core/SkColorSpacePriv.h"
#include "src/core/SkStringUtils.h"
#include "src/core/SkSurfacePriv.h"
#include "src/core/SkTHash.h"
#include <stdlib.h>
#include <string_view>
#include <unordered_map>

Go to the source code of this file.

Classes
class	ExtendedOptions

Macros
#define	DEFAULT_GPU_CONFIG   "gl"

Functions
static const char *	config_help_fn ()
static const char *	config_extended_help_fn ()
	DEFINE_extended_string (config, defaultConfigs, config_help_fn(), config_extended_help_fn())
static bool	parse_option_int (const SkString &value, int *outInt)
static bool	parse_option_bool (const SkString &value, bool *outBool)
static bool	parse_option_gpu_api (const SkString &value, SkCommandLineConfigGpu::ContextType *outContextType, bool *outFakeGLESVersion2)
static bool	parse_option_gpu_color (const SkString &value, SkColorType *outColorType, SkAlphaType *alphaType)
static bool	parse_option_gpu_surf_type (const SkString &value, SkCommandLineConfigGpu::SurfType *surfType)
SkCommandLineConfigGpu *	parse_command_line_config_gpu (const SkString &tag, const TArray< SkString > &vias, const SkString &options)
SkCommandLineConfigSvg *	parse_command_line_config_svg (const SkString &tag, const TArray< SkString > &vias, const SkString &options)
void	ParseConfigs (const CommandLineFlags::StringArray &configs, SkCommandLineConfigArray *outResult)

Variables
static const char	defaultConfigs []
struct {
const char *   predefinedConfig
const char *   backend
const char *   options
}	gPredefinedConfigs []
static const char	configHelp []
static const char	configExtendedHelp []

Macro Definition Documentation

DEFAULT_GPU_CONFIG

#define DEFAULT_GPU_CONFIG   "gl"

Definition at line 27 of file CommonFlagsConfig.cpp.

Function Documentation

config_extended_help_fn()

static const char * config_extended_help_fn ( )

static

Definition at line 245 of file CommonFlagsConfig.cpp.

                                             {
    static SkString helpString;
    helpString.set(configExtendedHelp);
    for (const auto& config : gPredefinedConfigs) {
        helpString.appendf("\t%-10s\t= gpu(%s)\n", config.predefinedConfig, config.options);
    }
    return helpString.c_str();
}

config_help_fn()

static const char * config_help_fn ( )

static

Definition at line 179 of file CommonFlagsConfig.cpp.

                                    {
    static SkString helpString;
    helpString.set(configHelp);
    for (const auto& config : gPredefinedConfigs) {
        helpString.appendf(" %s", config.predefinedConfig);
    }
    helpString.append(" or use extended form 'backend[option=value,...]'.\n");
    return helpString.c_str();
}

DEFINE_extended_string()

DEFINE_extended_string	(	config	,
		defaultConfigs	,
		config_help_fn()	,
		config_extended_help_fn()
	)

parse_command_line_config_gpu()

SkCommandLineConfigGpu * parse_command_line_config_gpu	(	const SkString &	tag,
		const TArray< SkString > &	vias,
		const SkString &	options
	)

Definition at line 612 of file CommonFlagsConfig.cpp.

                                                                                       {
    // Defaults for GPU backend.
    SkCommandLineConfigGpu::ContextType contextType         = skgpu::ContextType::kGL;
    bool                                useDIText           = false;
    bool                                useDMSAA            = false;
    int                                 samples             = 1;
    SkColorType                         colorType           = kRGBA_8888_SkColorType;
    SkAlphaType                         alphaType           = kPremul_SkAlphaType;
    bool                                useStencils         = true;
    int                                 testPersistentCache = 0;
    bool                                testPrecompile      = false;
    bool                                useDDLs             = false;
    bool                                slug                = false;
    bool                                serializeSlug       = false;
    bool                                remoteSlug          = false;
    bool                                reducedShaders      = false;
    bool                                fakeGLESVersion2    = false;
    SkCommandLineConfigGpu::SurfType    surfType = SkCommandLineConfigGpu::SurfType::kDefault;
 
    bool            parseSucceeded = false;
    ExtendedOptions extendedOptions(options, &parseSucceeded);
    if (!parseSucceeded) {
        return nullptr;
    }
 
    bool validOptions =
            extendedOptions.get_option_gpu_api("api", &contextType, &fakeGLESVersion2, false) &&
            extendedOptions.get_option_bool("dit", &useDIText) &&
            extendedOptions.get_option_int("samples", &samples) &&
            extendedOptions.get_option_bool("dmsaa", &useDMSAA) &&
            extendedOptions.get_option_gpu_color("color", &colorType, &alphaType) &&
            extendedOptions.get_option_bool("stencils", &useStencils) &&
            extendedOptions.get_option_int("testPersistentCache", &testPersistentCache) &&
            extendedOptions.get_option_bool("testPrecompile", &testPrecompile) &&
            extendedOptions.get_option_bool("useDDLSink", &useDDLs) &&
            extendedOptions.get_option_bool("slug", &slug) &&
            extendedOptions.get_option_bool("serializeSlug", &serializeSlug) &&
            extendedOptions.get_option_bool("remoteSlug", &remoteSlug) &&
            extendedOptions.get_option_bool("reducedShaders", &reducedShaders) &&
            extendedOptions.get_option_gpu_surf_type("surf", &surfType);
 
    if (!validOptions) {
        return nullptr;
    }
 
    uint32_t surfaceFlags = 0;
    if (useDIText) {
        surfaceFlags |= SkSurfaceProps::kUseDeviceIndependentFonts_Flag;
    }
    if (useDMSAA) {
        surfaceFlags |= SkSurfaceProps::kDynamicMSAA_Flag;
    }
 
    return new SkCommandLineConfigGpu(tag,
                                      vias,
                                      contextType,
                                      fakeGLESVersion2,
                                      surfaceFlags,
                                      samples,
                                      colorType,
                                      alphaType,
                                      useStencils,
                                      testPersistentCache,
                                      testPrecompile,
                                      useDDLs,
                                      slug,
                                      serializeSlug,
                                      remoteSlug,
                                      reducedShaders,
                                      surfType);
}

parse_command_line_config_svg()

SkCommandLineConfigSvg * parse_command_line_config_svg	(	const SkString &	tag,
		const TArray< SkString > &	vias,
		const SkString &	options
	)

Definition at line 738 of file CommonFlagsConfig.cpp.

                                                                               {
    // Defaults for SVG backend.
    int pageIndex = 0;
 
    bool            parseSucceeded = false;
    ExtendedOptions extendedOptions(options, &parseSucceeded);
    if (!parseSucceeded) {
        return nullptr;
    }
 
    bool validOptions = extendedOptions.get_option_int("page", &pageIndex);
 
    if (!validOptions) {
        return nullptr;
    }
 
    return new SkCommandLineConfigSvg(tag, vias, pageIndex);
}

parse_option_bool()

static bool parse_option_bool ( const SkString &  value, bool *  outBool  )

static

Definition at line 302 of file CommonFlagsConfig.cpp.

                                                                    {
    if (value.equals("true")) {
        *outBool = true;
        return true;
    }
    if (value.equals("false")) {
        *outBool = false;
        return true;
    }
    return false;
}

parse_option_gpu_api()

static bool parse_option_gpu_api ( const SkString &  value, SkCommandLineConfigGpu::ContextType *  outContextType, bool *  outFakeGLESVersion2  )

static

Definition at line 313 of file CommonFlagsConfig.cpp.

                                                                                           {
    *outFakeGLESVersion2 = false;
    if (value.equals("gl")) {
        *outContextType = skgpu::ContextType::kGL;
        return true;
    }
    if (value.equals("gles")) {
        *outContextType = skgpu::ContextType::kGLES;
        return true;
    }
    if (value.equals("glesfakev2")) {
        *outContextType = skgpu::ContextType::kGLES;
        *outFakeGLESVersion2 = true;
        return true;
    }
    if (value.equals("angle_d3d9_es2")) {
        *outContextType = skgpu::ContextType::kANGLE_D3D9_ES2;
        return true;
    }
    if (value.equals("angle_d3d11_es2")) {
        *outContextType = skgpu::ContextType::kANGLE_D3D11_ES2;
        return true;
    }
    if (value.equals("angle_d3d11_es3")) {
        *outContextType = skgpu::ContextType::kANGLE_D3D11_ES3;
        return true;
    }
    if (value.equals("angle_gl_es2")) {
        *outContextType = skgpu::ContextType::kANGLE_GL_ES2;
        return true;
    }
    if (value.equals("angle_gl_es3")) {
        *outContextType = skgpu::ContextType::kANGLE_GL_ES3;
        return true;
    }
    if (value.equals("angle_mtl_es2")) {
        *outContextType = skgpu::ContextType::kANGLE_Metal_ES2;
        return true;
    }
    if (value.equals("angle_mtl_es3")) {
        *outContextType = skgpu::ContextType::kANGLE_Metal_ES3;
        return true;
    }
    if (value.equals("mock")) {
        *outContextType = skgpu::ContextType::kMock;
        return true;
    }
#ifdef SK_VULKAN
    if (value.equals("vulkan")) {
        *outContextType = skgpu::ContextType::kVulkan;
        return true;
    }
#endif
#ifdef SK_METAL
    if (value.equals("metal")) {
        *outContextType = skgpu::ContextType::kMetal;
        return true;
    }
#endif
#ifdef SK_DIRECT3D
    if (value.equals("direct3d")) {
        *outContextType = skgpu::ContextType::kDirect3D;
        return true;
    }
#endif
    return false;
}

parse_option_gpu_color()

static bool parse_option_gpu_color ( const SkString &  value, SkColorType *  outColorType, SkAlphaType *  alphaType  )

static

Definition at line 383 of file CommonFlagsConfig.cpp.

                                                              {
    // We always use premul unless the color type is 565.
    *alphaType = kPremul_SkAlphaType;
 
    if (value.equals("8888")) {
        *outColorType  = kRGBA_8888_SkColorType;
    } else if (value.equals("888x")) {
        *outColorType  = kRGB_888x_SkColorType;
    } else if (value.equals("bgra8")) {
        *outColorType  = kBGRA_8888_SkColorType;
    } else if (value.equals("4444")) {
        *outColorType  = kARGB_4444_SkColorType;
    } else if (value.equals("565")) {
        *outColorType  = kRGB_565_SkColorType;
        *alphaType     = kOpaque_SkAlphaType;
    } else if (value.equals("1010102")) {
        *outColorType  = kRGBA_1010102_SkColorType;
    } else if (value.equals("f16")) {
        *outColorType  = kRGBA_F16_SkColorType;
    } else if (value.equals("f16norm")) {
        *outColorType  = kRGBA_F16Norm_SkColorType;
    } else if (value.equals("srgba")) {
        *outColorType = kSRGBA_8888_SkColorType;
    } else if (value.equals("r8")) {
        *outColorType = kR8_unorm_SkColorType;
        *alphaType = kOpaque_SkAlphaType;
    } else {
        return false;
    }
    return true;
}

parse_option_gpu_surf_type()

static bool parse_option_gpu_surf_type ( const SkString &  value, SkCommandLineConfigGpu::SurfType *  surfType  )

static

Definition at line 417 of file CommonFlagsConfig.cpp.

                                                                                 {
    if (value.equals("default")) {
        *surfType = SkCommandLineConfigGpu::SurfType::kDefault;
        return true;
    }
    if (value.equals("betex")) {
        *surfType = SkCommandLineConfigGpu::SurfType::kBackendTexture;
        return true;
    }
    if (value.equals("bert")) {
        *surfType = SkCommandLineConfigGpu::SurfType::kBackendRenderTarget;
        return true;
    }
    return false;
}

parse_option_int()

static bool parse_option_int ( const SkString &  value, int *  outInt  )

static

Definition at line 290 of file CommonFlagsConfig.cpp.

                                                                 {
    if (value.isEmpty()) {
        return false;
    }
    char* endptr   = nullptr;
    long  intValue = strtol(value.c_str(), &endptr, 10);
    if (*endptr != '\0') {
        return false;
    }
    *outInt = static_cast<int>(intValue);
    return true;
}

ParseConfigs()

void ParseConfigs	(	const CommandLineFlags::StringArray &	configs,
		SkCommandLineConfigArray *	outResult
	)

Definition at line 759 of file CommonFlagsConfig.cpp.

                                                                  {
    outResult->clear();
    for (int i = 0; i < configs.size(); ++i) {
        SkString         extendedBackend;
        SkString         extendedOptions;
        SkString         simpleBackend;
        TArray<SkString> vias;
 
        SkString         tag(configs[i]);
        TArray<SkString> parts;
        SkStrSplit(tag.c_str(), "[", kStrict_SkStrSplitMode, &parts);
        if (parts.size() == 2) {
            TArray<SkString> parts2;
            SkStrSplit(parts[1].c_str(), "]", kStrict_SkStrSplitMode, &parts2);
            if (parts2.size() == 2 && parts2[1].isEmpty()) {
                SkStrSplit(parts[0].c_str(), "-", kStrict_SkStrSplitMode, &vias);
                if (vias.size()) {
                    extendedBackend = vias[vias.size() - 1];
                    vias.pop_back();
                } else {
                    extendedBackend = parts[0];
                }
                extendedOptions = parts2[0];
                simpleBackend.printf("%s[%s]", extendedBackend.c_str(), extendedOptions.c_str());
            }
        }
 
        if (extendedBackend.isEmpty()) {
            simpleBackend = tag;
            SkStrSplit(tag.c_str(), "-", kStrict_SkStrSplitMode, &vias);
            if (vias.size()) {
                simpleBackend = vias[vias.size() - 1];
                vias.pop_back();
            }
            for (auto& predefinedConfig : gPredefinedConfigs) {
                if (simpleBackend.equals(predefinedConfig.predefinedConfig)) {
                    extendedBackend = predefinedConfig.backend;
                    extendedOptions = predefinedConfig.options;
                    break;
                }
            }
        }
        SkCommandLineConfig* parsedConfig = nullptr;
        if (extendedBackend.equals("gpu")) {
            parsedConfig = parse_command_line_config_gpu(tag, vias, extendedOptions);
        }
#if defined(SK_GRAPHITE)
        if (extendedBackend.equals("graphite")) {
            parsedConfig = parse_command_line_config_graphite(tag, vias, extendedOptions);
        }
#endif
        if (extendedBackend.equals("svg")) {
            parsedConfig = parse_command_line_config_svg(tag, vias, extendedOptions);
        }
        if (!parsedConfig) {
            parsedConfig = new SkCommandLineConfig(tag, simpleBackend, vias);
        }
        outResult->emplace_back(parsedConfig);
    }
}

Variable Documentation

backend

const char* backend

Definition at line 42 of file CommonFlagsConfig.cpp.

configExtendedHelp

const char configExtendedHelp[]

static

Definition at line 189 of file CommonFlagsConfig.cpp.

configHelp

const char configHelp[]

static

Initial value:

=
        "Options: 565 4444 8888 rgba bgra rgbx 1010102 101010x bgra1010102 bgr101010x f16 f16norm "
        "f32 nonrendering null pdf pdfa pdf300 skp svg xps"

Definition at line 175 of file CommonFlagsConfig.cpp.

defaultConfigs

const char defaultConfigs[]

static

Initial value:

= "8888 " DEFAULT_GPU_CONFIG
                                     " nonrendering "

Definition at line 30 of file CommonFlagsConfig.cpp.

[struct]

const struct { ... } gPredefinedConfigs[]

options

const char* options

Definition at line 43 of file CommonFlagsConfig.cpp.

predefinedConfig

const char* predefinedConfig

Definition at line 41 of file CommonFlagsConfig.cpp.