CommonFlags Namespace Reference

Functions
bool	CollectImages (const CommandLineFlags::StringArray &dir, skia_private::TArray< SkString > *output)
void	SetCtxOptions (struct GrContextOptions *)
static	DEFINE_bool (cachePathMasks, true, "Allows path mask textures to be cached in GPU configs.")
static	DEFINE_bool (failFlushTimeCallbacks, false, "Causes all flush-time callbacks to fail.")
static	DEFINE_bool (allPathsVolatile, false, "Causes all GPU paths to be processed as if 'setIsVolatile' had been called.")
static	DEFINE_string (pr, "", "Set of enabled gpu path renderers. Defined as a list of: " "[~]none [~]dashline [~]aahairline [~]aaconvex [~]aalinearizing [~]small [~]tri " "[~]atlas [~]tess [~]all")
static	DEFINE_int (internalSamples, -1, "Number of samples for internal draws that use MSAA, or default value if negative.")
static	DEFINE_int (maxAtlasSize, -1, "Maximum width and height of internal texture atlases, or default value if negative.")
static	DEFINE_bool (disableDriverCorrectnessWorkarounds, false, "Disables all GPU driver correctness workarounds")
static	DEFINE_bool (dontReduceOpsTaskSplitting, false, "Don't reorder tasks to reduce render passes")
static	DEFINE_int (gpuResourceCacheLimit, -1, "Maximum number of bytes to use for budgeted GPU resources. " "Default is -1, which means GrResourceCache::kDefaultMaxSize.")
static	DEFINE_bool (allowMSAAOnNewIntel, false, "Allows MSAA to be enabled on newer intel GPUs.")
static GpuPathRenderers	get_named_pathrenderers_flags (const char *name)
static GpuPathRenderers	collect_gpu_path_renderers_from_flags ()

Function Documentation

collect_gpu_path_renderers_from_flags()

static GpuPathRenderers CommonFlags::collect_gpu_path_renderers_from_flags ( )

static

Definition at line 75 of file CommonFlagsGpu.cpp.

                                                                {
    if (FLAGS_pr.isEmpty()) {
        return GpuPathRenderers::kDefault;
    }
 
    GpuPathRenderers gpuPathRenderers = ('~' == FLAGS_pr[0][0])
            ? GpuPathRenderers::kDefault
            : GpuPathRenderers::kNone;
 
    for (int i = 0; i < FLAGS_pr.size(); ++i) {
        const char* name = FLAGS_pr[i];
        if (name[0] == '~') {
            gpuPathRenderers &= ~get_named_pathrenderers_flags(&name[1]);
        } else {
            gpuPathRenderers |= get_named_pathrenderers_flags(name);
        }
    }
    return gpuPathRenderers;
}

CollectImages()

bool CommonFlags::CollectImages	(	const CommandLineFlags::StringArray &	dir,
		skia_private::TArray< SkString > *	output
	)

Helper to assist in collecting image paths from |dir| specified through a command line flag.

Populates |output|, an array of strings with paths to images to test.

Returns true if each argument to the images flag is meaningful:

• If the file/directory does not exist, return false.
• If |dir| does not have any supported images (based on file type), return false.
• If |dir| is a single file, assume the user is deliberately testing this image, regardless of file type.

Definition at line 11 of file CommonFlagsImages.cpp.

                                                                                        {
    SkASSERT(output);
 
    static const char* const exts[] = {
        "bmp",
        "gif",
        "jpg",
        "jpeg",
        "png",
        "webp",
        "ktx",
        "astc",
        "wbmp",
        "ico",
#if !defined(SK_BUILD_FOR_WIN)
        "BMP",
        "GIF",
        "JPG",
        "JPEG",
        "PNG",
        "WEBP",
        "KTX",
        "ASTC",
        "WBMP",
        "ICO",
#endif
#ifdef SK_HAS_HEIF_LIBRARY
        "heic",
#if !defined(SK_BUILD_FOR_WIN)
        "HEIC",
#endif
#endif
#ifdef SK_CODEC_DECODES_RAW
        "arw",
        "cr2",
        "dng",
        "nef",
        "nrw",
        "orf",
        "raf",
        "rw2",
        "pef",
        "srw",
#if !defined(SK_BUILD_FOR_WIN)
        "ARW",
        "CR2",
        "DNG",
        "NEF",
        "NRW",
        "ORF",
        "RAF",
        "RW2",
        "PEF",
        "SRW",
#endif
#endif
    };
 
    for (int i = 0; i < images.size(); ++i) {
        const char* flag = images[i];
        if (!sk_exists(flag)) {
            SkDebugf("%s does not exist!\n", flag);
            return false;
        }
 
        if (sk_isdir(flag)) {
            // If the value passed in is a directory, add all the images
            bool foundAnImage = false;
            for (const char* ext : exts) {
                SkOSFile::Iter it(flag, ext);
                SkString file;
                while (it.next(&file)) {
                    foundAnImage = true;
                    output->push_back() = SkOSPath::Join(flag, file.c_str());
                }
            }
            if (!foundAnImage) {
                SkDebugf("No supported images found in %s!\n", flag);
                return false;
            }
        } else {
            // Also add the value if it is a single image
            output->push_back() = flag;
        }
    }
    return true;
}

DEFINE_bool() [1/6]

static CommonFlags::DEFINE_bool ( allowMSAAOnNewIntel  , false  , "Allows MSAA to be enabled on newer intel GPUs."    )

static

DEFINE_bool() [2/6]

static CommonFlags::DEFINE_bool ( allPathsVolatile  , false  , "Causes all GPU paths to be processed as if 'setIsVolatile' had been called."    )

static

DEFINE_bool() [3/6]

static CommonFlags::DEFINE_bool ( cachePathMasks  , true  , "Allows path mask textures to be cached in GPU configs."    )

static

DEFINE_bool() [4/6]

static CommonFlags::DEFINE_bool ( disableDriverCorrectnessWorkarounds  , false  , "Disables all GPU driver correctness workarounds"    )

static

DEFINE_bool() [5/6]

static CommonFlags::DEFINE_bool ( dontReduceOpsTaskSplitting  , false  , "Don't reorder tasks to reduce render passes"    )

static

DEFINE_bool() [6/6]

static CommonFlags::DEFINE_bool ( failFlushTimeCallbacks  , false  , "Causes all flush-time callbacks to fail."    )

static

DEFINE_int() [1/3]

static CommonFlags::DEFINE_int ( gpuResourceCacheLimit  , -  1, "Maximum number of bytes to use for budgeted GPU resources. " "Default is -  1, which means GrResourceCache::kDefaultMaxSize."    )

static

DEFINE_int() [2/3]

static CommonFlags::DEFINE_int ( internalSamples  , -  1, "Number of samples for internal draws that use  MSAA, or default value if negative."    )

static

DEFINE_int() [3/3]

static CommonFlags::DEFINE_int ( maxAtlasSize  , -  1, "Maximum width and height of internal texture  atlases, or default value if negative."    )

static

DEFINE_string()

static CommonFlags::DEFINE_string ( pr  , ""  , "Set of enabled gpu path renderers. Defined as a list of: " "none dashline aahairline aaconvex aalinearizing small tri " "atlas tess all"  [~][~][~][~][~][~][~][~][~][~]  )

static

get_named_pathrenderers_flags()

static GpuPathRenderers CommonFlags::get_named_pathrenderers_flags ( const char *  name )

static

Definition at line 50 of file CommonFlagsGpu.cpp.

                                                                        {
    if (!strcmp(name, "none")) {
        return GpuPathRenderers::kNone;
    } else if (!strcmp(name, "dashline")) {
        return GpuPathRenderers::kDashLine;
    } else if (!strcmp(name, "aahairline")) {
        return GpuPathRenderers::kAAHairline;
    } else if (!strcmp(name, "aaconvex")) {
        return GpuPathRenderers::kAAConvex;
    } else if (!strcmp(name, "aalinearizing")) {
        return GpuPathRenderers::kAALinearizing;
    } else if (!strcmp(name, "small")) {
        return GpuPathRenderers::kSmall;
    } else if (!strcmp(name, "tri")) {
        return GpuPathRenderers::kTriangulating;
    } else if (!strcmp(name, "atlas")) {
        return GpuPathRenderers::kAtlas;
    } else if (!strcmp(name, "tess")) {
        return GpuPathRenderers::kTessellation;
    } else if (!strcmp(name, "default")) {
        return GpuPathRenderers::kDefault;
    }
    SK_ABORT("error: unknown named path renderer \"%s\"\n", name);
}

SetCtxOptions()

void CommonFlags::SetCtxOptions

(

struct GrContextOptions *

ctxOptions

)

Helper to set GrContextOptions from common GPU flags, including –gpuThreads –cachePathMasks –allPathsVolatile –(no)gs –(no)ts –pr –internalSamples –disableDriverCorrectnessWorkarounds –reduceOpsTaskSplitting –dontReduceOpsTaskSplitting –allowMSAAOnNewIntel

Definition at line 95 of file CommonFlagsGpu.cpp.

                                                 {
    static std::unique_ptr<SkExecutor> gGpuExecutor = (0 != FLAGS_gpuThreads)
        ? SkExecutor::MakeFIFOThreadPool(FLAGS_gpuThreads)
        : nullptr;
 
    ctxOptions->fExecutor                            = gGpuExecutor.get();
    ctxOptions->fAllowPathMaskCaching                = FLAGS_cachePathMasks;
    ctxOptions->fFailFlushTimeCallbacks              = FLAGS_failFlushTimeCallbacks;
    ctxOptions->fAllPathsVolatile                    = FLAGS_allPathsVolatile;
    ctxOptions->fGpuPathRenderers                    = collect_gpu_path_renderers_from_flags();
    ctxOptions->fDisableDriverCorrectnessWorkarounds = FLAGS_disableDriverCorrectnessWorkarounds;
    ctxOptions->fResourceCacheLimitOverride          = FLAGS_gpuResourceCacheLimit;
 
    if (FLAGS_internalSamples >= 0) {
        ctxOptions->fInternalMultisampleCount = FLAGS_internalSamples;
    }
    if (FLAGS_maxAtlasSize >= 0) {
        ctxOptions->fMaxTextureAtlasSize = FLAGS_maxAtlasSize;
    }
 
    if (FLAGS_dontReduceOpsTaskSplitting) {
        ctxOptions->fReduceOpsTaskSplitting = GrContextOptions::Enable::kNo;
    } else {
        ctxOptions->fReduceOpsTaskSplitting = GrContextOptions::Enable::kYes;
    }
    ctxOptions->fAllowMSAAOnNewIntel = FLAGS_allowMSAAOnNewIntel;
}