53 return 0xff000000 |
color;
58 fuzz->
next(&makeOpaque);
89 dict->
lookup(
id).dump(dict);
106 uint32_t xferFunction;
107 fuzz->
next(&xferFunction);
108 xferFunction %= std::size(gTransferFunctions);
109 return gTransferFunctions[xferFunction];
127enum class ColorSpaceType {
136static constexpr int kColorSpaceTypeCount =
static_cast<int>(ColorSpaceType::kLast) + 1;
140 case ColorSpaceType::kNone:
142 case ColorSpaceType::kSRGB:
144 case ColorSpaceType::kSRGBLinear:
146 case ColorSpaceType::kRGB:
156 ColorSpaceType csType = (ColorSpaceType) (temp % kColorSpaceTypeCount);
158 return create_colorspace(fuzz, csType);
164enum class ColorFilterType {
174static constexpr int kColorFilterTypeCount =
static_cast<int>(ColorFilterType::kLast) + 1;
185 create_random_colorspace(fuzz),
186 random_blend_mode(fuzz));
212 ColorFilterType
type,
219 case ColorFilterType::kNone:
220 return {
nullptr,
nullptr };
221 case ColorFilterType::kBlend:
222 return create_blend_colorfilter(fuzz);
223 case ColorFilterType::kMatrix:
224 return create_matrix_colorfilter();
225 case ColorFilterType::kHSLAMatrix:
226 return create_hsla_matrix_colorfilter();
238 ColorFilterType cf = (ColorFilterType) (temp % kColorFilterTypeCount);
240 return create_colorfilter(fuzz, cf, depth);
244std::pair<SkPaint, PaintOptions> create_random_paint(
Fuzz* fuzz,
int depth) {
250 paint.setColor(random_opaque_skcolor(fuzz));
255 auto [cf, o] = create_random_colorfilter(fuzz, depth - 1);
259 paint.setColorFilter(std::move(cf));
264 return {
paint, paintOptions };
268void check_draw(
Context* context,
282 SkCanvas* canvas = surf->getCanvas();
285 case DrawTypeFlags::kShape:
294 std::unique_ptr<skgpu::graphite::Recording> recording = recorder->
snap();
296 context->
submit(SyncToCpu::kYes);
306void fuzz_graphite(
Fuzz* fuzz,
Context* context,
int depth = 9) {
313 std::unique_ptr<RuntimeEffectDictionary> rtDict = std::make_unique<RuntimeEffectDictionary>();
322 skgpu::Mipmapped::kNo,
323 skgpu::Protected::kNo,
324 skgpu::Renderable::kNo);
344 auto [
paint, paintOptions] = create_random_paint(fuzz, depth);
346 constexpr Coverage coverageOptions[3] = {
347 Coverage::kNone, Coverage::kSingleChannel, Coverage::kLCD};
359 bool needsDstSample = dstReadReq == DstReadRequirement::kTextureCopy ||
360 dstReadReq == DstReadRequirement::kTextureSample;
364 recorder.get(), &gatherer, &builder, layout, {},
370 curDst, fakeDstOffset, ci);
372 std::vector<UniquePaintParamsID> precompileIDs;
375 DrawTypeFlags::kNone,
382 precompileIDs.push_back(
id);
387 auto result = std::find(precompileIDs.begin(), precompileIDs.end(), paintID);
390 if (
result == precompileIDs.end()) {
394 SkDebugf(
"From combination builder:");
395 for (
auto iter : precompileIDs) {
413 check_draw(context, recorder.get(),
paint, kDrawType, path);
424 contextType = skgpu::ContextType::kMetal;
425#elif defined(SK_VULKAN)
426 contextType = skgpu::ContextType::kVulkan;
428 contextType = skgpu::ContextType::kMock;
437 fuzz_graphite(fuzz, context);
#define DEF_FUZZ(name, f)
@ kPremul_SkAlphaType
pixel components are premultiplied by alpha
#define SkASSERT_RELEASE(cond)
static constexpr int kSkBlendModeCount
SkBlenderBase * as_BB(SkBlender *blend)
@ kRGBA_8888_SkColorType
pixel with 8 bits for red, green, blue, alpha; in 32-bit word
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1
@ kJPEG_Full_SkYUVColorSpace
describes full range
static void dump(const float m[20], SkYUVColorSpace cs, bool rgb2yuv)
void nextRange(T *, Min, Max)
virtual std::optional< SkBlendMode > asBlendMode() const
void drawRect(const SkRect &rect, const SkPaint &paint)
void drawPath(const SkPath &path, const SkPaint &paint)
static sk_sp< SkColorFilter > Blend(const SkColor4f &c, sk_sp< SkColorSpace >, SkBlendMode mode)
static sk_sp< SkColorFilter > Matrix(const SkColorMatrix &)
static sk_sp< SkColorFilter > HSLAMatrix(const SkColorMatrix &)
static SkColorMatrix RGBtoYUV(SkYUVColorSpace)
static sk_sp< SkColorSpace > MakeSRGB()
static sk_sp< SkColorSpace > MakeRGB(const skcms_TransferFunction &transferFn, const skcms_Matrix3x3 &toXYZ)
static sk_sp< SkColorSpace > MakeSRGBLinear()
virtual TextureInfo getDefaultSampledTextureInfo(SkColorType, Mipmapped mipmapped, Protected, Renderable) const =0
const GlobalCache * globalCache() const
const ShaderCodeDictionary * shaderCodeDictionary() const
BackendApi backend() const
std::unique_ptr< Recorder > makeRecorder(const RecorderOptions &={})
bool submit(SyncToCpu=SyncToCpu::kNo)
bool insertRecording(const InsertRecordingInfo &)
void buildCombinations(const KeyContext &keyContext, PipelineDataGatherer *gatherer, DrawTypeFlags drawTypes, bool withPrimitiveBlender, Coverage coverage, const PaintOptions::ProcessCombination &processCombination) const
void setColorFilters(SkSpan< const sk_sp< PrecompileColorFilter > > colorFilters)
const Caps * caps() const
ResourceProvider * resourceProvider()
std::unique_ptr< Recording > snap()
PaintParamsKey lookup(UniquePaintParamsID) const SK_EXCLUDES(fSpinLock)
static sk_sp< TextureProxy > Make(const Caps *, ResourceProvider *, SkISize dimensions, const TextureInfo &, skgpu::Budgeted)
ContextInfo getContextInfo(skgpu::ContextType)
static const skcms_Matrix3x3 gGamuts[]
static constexpr skcms_Matrix3x3 kSRGB
static constexpr skcms_Matrix3x3 kAdobeRGB
static constexpr skcms_Matrix3x3 kXYZ
static constexpr skcms_Matrix3x3 kRec2020
static constexpr skcms_Matrix3x3 kDisplayP3
static constexpr skcms_TransferFunction kRec2020
static constexpr skcms_TransferFunction k2Dot2
static constexpr skcms_TransferFunction kSRGB
static constexpr skcms_TransferFunction kHLG
static constexpr skcms_TransferFunction kPQ
static constexpr skcms_TransferFunction kLinear
SK_API sk_sp< SkSurface > RenderTarget(GrRecordingContext *context, skgpu::Budgeted budgeted, const SkImageInfo &imageInfo, int sampleCount, GrSurfaceOrigin surfaceOrigin, const SkSurfaceProps *surfaceProps, bool shouldCreateWithMips=false, bool isProtected=false)
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot The VM snapshot data that will be memory mapped as read only SnapshotAssetPath must be present isolate snapshot The isolate snapshot data that will be memory mapped as read only SnapshotAssetPath must be present cache dir path
DstReadRequirement GetDstReadRequirement(const Caps *caps, std::optional< SkBlendMode > blendMode, Coverage coverage)
bool Precompile(Context *context, RuntimeEffectDictionary *rteDict, const GraphicsPipelineDesc &pipelineDesc, const RenderPassDesc &renderPassDesc)
std::tuple< UniquePaintParamsID, const UniformDataBlock *, const TextureDataBlock * > ExtractPaintData(Recorder *recorder, PipelineDataGatherer *gatherer, PaintParamsKeyBuilder *builder, const Layout layout, const SkM44 &local2Dev, const PaintParams &p, sk_sp< TextureProxy > dstTexture, SkIPoint dstOffset, const SkColorInfo &targetColorInfo)
static SkPath make_path()
static constexpr SkIPoint Make(int32_t x, int32_t y)
static constexpr SkISize Make(int32_t w, int32_t h)
static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at)
static constexpr SkRect MakeWH(float w, float h)
skgpu::graphite::Context * fContext