Flutter Engine
The Flutter Engine
Loading...
Searching...
No Matches
Macros | Typedefs | Functions
GrDirectContextPriv.cpp File Reference
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GrContextThreadSafeProxy.h"
#include "include/gpu/GrDirectContext.h"
#include "include/private/chromium/GrDeferredDisplayList.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/gpu/ganesh/GrContextThreadSafeProxyPriv.h"
#include "src/gpu/ganesh/GrDrawingManager.h"
#include "src/gpu/ganesh/GrGpu.h"
#include "src/gpu/ganesh/GrMemoryPool.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "src/gpu/ganesh/GrTexture.h"
#include "src/gpu/ganesh/GrThreadSafePipelineBuilder.h"
#include "src/gpu/ganesh/GrTracing.h"
#include "src/gpu/ganesh/SkGr.h"
#include "src/gpu/ganesh/SurfaceContext.h"
#include "src/gpu/ganesh/SurfaceFillContext.h"
#include "src/gpu/ganesh/effects/GrSkSLFP.h"
#include "src/gpu/ganesh/effects/GrTextureEffect.h"
#include "src/gpu/ganesh/image/SkImage_Ganesh.h"
#include "src/gpu/ganesh/text/GrAtlasManager.h"
#include "src/image/SkImage_Base.h"
#include "src/text/gpu/TextBlobRedrawCoordinator.h"

Go to the source code of this file.

Macros

#define ASSERT_OWNED_PROXY(P)    SkASSERT(!(P) || !((P)->peekTexture()) || (P)->peekTexture()->getContext() == this->context())
 
#define ASSERT_SINGLE_OWNER   SKGPU_ASSERT_SINGLE_OWNER(this->context()->singleOwner())
 
#define RETURN_VALUE_IF_ABANDONED(value)   if (this->context()->abandoned()) { return (value); }
 

Typedefs

using MaskFormat = skgpu::MaskFormat
 

Functions

static std::unique_ptr< GrFragmentProcessor > make_premul_effect (std::unique_ptr< GrFragmentProcessor > fp)
 
static std::unique_ptr< GrFragmentProcessor > make_unpremul_effect (std::unique_ptr< GrFragmentProcessor > fp)
 
static bool test_for_preserving_PM_conversions (GrDirectContext *dContext)
 

Macro Definition Documentation

◆ ASSERT_OWNED_PROXY

#define ASSERT_OWNED_PROXY (   P)     SkASSERT(!(P) || !((P)->peekTexture()) || (P)->peekTexture()->getContext() == this->context())

Definition at line 38 of file GrDirectContextPriv.cpp.

41 { return (value); }
42
43GrSemaphoresSubmitted GrDirectContextPriv::flushSurfaces(
44 SkSpan<GrSurfaceProxy*> proxies,
45 SkSurfaces::BackendSurfaceAccess access,
46 const GrFlushInfo& info,
47 const skgpu::MutableTextureState* newState) {
48 ASSERT_SINGLE_OWNER
49 GR_CREATE_TRACE_MARKER_CONTEXT("GrDirectContextPriv", "flushSurfaces", this->context());
50
51 if (this->context()->abandoned()) {
52 if (info.fSubmittedProc) {
53 info.fSubmittedProc(info.fSubmittedContext, false);
54 }
55 if (info.fFinishedProc) {
56 info.fFinishedProc(info.fFinishedContext);
57 }
58 return GrSemaphoresSubmitted::kNo;
59 }
60
61#ifdef SK_DEBUG
62 for (GrSurfaceProxy* proxy : proxies) {
63 SkASSERT(proxy);
64 ASSERT_OWNED_PROXY(proxy);
65 }
66#endif
67 return this->context()->drawingManager()->flushSurfaces(proxies, access, info, newState);
68}
69
70void GrDirectContextPriv::createDDLTask(sk_sp<const GrDeferredDisplayList> ddl,
71 sk_sp<GrRenderTargetProxy> newDest) {
72 this->context()->drawingManager()->createDDLTask(std::move(ddl), std::move(newDest));
73}
74
75bool GrDirectContextPriv::compile(const GrProgramDesc& desc, const GrProgramInfo& info) {
76 GrGpu* gpu = this->getGpu();
77 if (!gpu) {
78 return false;
79 }
80
81 return gpu->compile(desc, info);
82}
83
84
85//////////////////////////////////////////////////////////////////////////////
86#if defined(GR_TEST_UTILS)
87
88void GrDirectContextPriv::dumpCacheStats(SkString* out) const {
89#if GR_CACHE_STATS
90 this->context()->fResourceCache->dumpStats(out);
91#endif
92}
93
94void GrDirectContextPriv::dumpCacheStatsKeyValuePairs(TArray<SkString>* keys,
95 TArray<double>* values) const {
96#if GR_CACHE_STATS
97 this->context()->fResourceCache->dumpStatsKeyValuePairs(keys, values);
98#endif
99}
100
101void GrDirectContextPriv::printCacheStats() const {
102 SkString out;
103 this->dumpCacheStats(&out);
104 SkDebugf("%s", out.c_str());
105}
106
107/////////////////////////////////////////////////
108void GrDirectContextPriv::resetGpuStats() const {
109#if GR_GPU_STATS
110 this->context()->fGpu->stats()->reset();
111#endif
112}
113
114void GrDirectContextPriv::dumpGpuStats(SkString* out) const {
115#if GR_GPU_STATS
116 this->context()->fGpu->stats()->dump(out);
117 if (auto builder = this->context()->fGpu->pipelineBuilder()) {
118 builder->stats()->dump(out);
119 }
120#endif
121}
122
123void GrDirectContextPriv::dumpGpuStatsKeyValuePairs(TArray<SkString>* keys,
124 TArray<double>* values) const {
125#if GR_GPU_STATS
126 this->context()->fGpu->stats()->dumpKeyValuePairs(keys, values);
127 if (auto builder = this->context()->fGpu->pipelineBuilder()) {
128 builder->stats()->dumpKeyValuePairs(keys, values);
129 }
130#endif
131}
132
133void GrDirectContextPriv::printGpuStats() const {
134 SkString out;
135 this->dumpGpuStats(&out);
136 SkDebugf("%s", out.c_str());
137}
138
139/////////////////////////////////////////////////
140void GrDirectContextPriv::resetContextStats() {
141#if GR_GPU_STATS
142 this->context()->stats()->reset();
143#endif
144}
145
146void GrDirectContextPriv::dumpContextStats(SkString* out) const {
147#if GR_GPU_STATS
148 this->context()->stats()->dump(out);
149#endif
150}
151
152void GrDirectContextPriv::dumpContextStatsKeyValuePairs(TArray<SkString>* keys,
153 TArray<double>* values) const {
154#if GR_GPU_STATS
155 this->context()->stats()->dumpKeyValuePairs(keys, values);
156#endif
157}
158
159void GrDirectContextPriv::printContextStats() const {
160 SkString out;
161 this->dumpContextStats(&out);
162 SkDebugf("%s", out.c_str());
163}
164
165/////////////////////////////////////////////////
166sk_sp<SkImage> GrDirectContextPriv::testingOnly_getFontAtlasImage(MaskFormat format,
167 unsigned int index) {
168 auto atlasManager = this->getAtlasManager();
169 if (!atlasManager) {
170 return nullptr;
171 }
172
173 unsigned int numActiveProxies;
174 const GrSurfaceProxyView* views = atlasManager->getViews(format, &numActiveProxies);
175 if (index >= numActiveProxies || !views || !views[index].proxy()) {
176 return nullptr;
177 }
178
179 SkColorType colorType = skgpu::MaskFormatToColorType(format);
180 SkASSERT(views[index].proxy()->priv().isExact());
181 return sk_make_sp<SkImage_Ganesh>(sk_ref_sp(this->context()),
182 kNeedNewImageUniqueID,
183 views[index],
184 SkColorInfo(colorType, kPremul_SkAlphaType, nullptr));
185}
186
187void GrDirectContextPriv::testingOnly_flushAndRemoveOnFlushCallbackObject(
188 GrOnFlushCallbackObject* cb) {
189 this->context()->flushAndSubmit();
190 this->context()->drawingManager()->testingOnly_removeOnFlushCallbackObject(cb);
191}
192#endif
193
194// Both of these effects aggressively round to the nearest exact (N / 255) floating point values.
195// This lets us find a round-trip preserving pair on some GPUs that do odd byte to float conversion.
196static std::unique_ptr<GrFragmentProcessor> make_premul_effect(
197 std::unique_ptr<GrFragmentProcessor> fp) {
198 if (!fp) {
199 return nullptr;
200 }
201
202 static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
203 "half4 main(half4 halfColor) {"
204 "float4 color = float4(halfColor);"
205 "color = floor(color * 255 + 0.5) / 255;"
206 "color.rgb = floor(color.rgb * color.a * 255 + 0.5) / 255;"
207 "return color;"
208 "}"
209 );
210
211 fp = GrSkSLFP::Make(effect, "ToPremul", std::move(fp), GrSkSLFP::OptFlags::kNone);
212 return GrFragmentProcessor::HighPrecision(std::move(fp));
213}
214
215static std::unique_ptr<GrFragmentProcessor> make_unpremul_effect(
216 std::unique_ptr<GrFragmentProcessor> fp) {
217 if (!fp) {
218 return nullptr;
219 }
220
221 static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
222 "half4 main(half4 halfColor) {"
223 "float4 color = float4(halfColor);"
224 "color = floor(color * 255 + 0.5) / 255;"
225 "color.rgb = color.a <= 0 ? half3(0) : floor(color.rgb / color.a * 255 + 0.5) / 255;"
226 "return color;"
227 "}"
228 );
229
230 fp = GrSkSLFP::Make(effect, "ToUnpremul", std::move(fp), GrSkSLFP::OptFlags::kNone);
231 return GrFragmentProcessor::HighPrecision(std::move(fp));
232}
233
234static bool test_for_preserving_PM_conversions(GrDirectContext* dContext) {
235 static constexpr int kSize = 256;
236 AutoTMalloc<uint32_t> data(kSize * kSize * 3);
237 uint32_t* srcData = data.get();
238
239 // Fill with every possible premultiplied A, color channel value. There will be 256-y duplicate
240 // values in row y. We set r, g, and b to the same value since they are handled identically.
241 for (int y = 0; y < kSize; ++y) {
242 for (int x = 0; x < kSize; ++x) {
243 uint8_t* color = reinterpret_cast<uint8_t*>(&srcData[kSize*y + x]);
244 color[3] = y;
245 color[2] = std::min(x, y);
246 color[1] = std::min(x, y);
247 color[0] = std::min(x, y);
248 }
249 }
250
251 const SkImageInfo pmII =
252 SkImageInfo::Make(kSize, kSize, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
253 const SkImageInfo upmII = pmII.makeAlphaType(kUnpremul_SkAlphaType);
254
255 auto readSFC =
256 dContext->priv().makeSFC(upmII, "ReadSfcForPMUPMConversion", SkBackingFit::kExact);
257 auto tempSFC =
258 dContext->priv().makeSFC(pmII, "TempSfcForPMUPMConversion", SkBackingFit::kExact);
259 if (!readSFC || !tempSFC) {
260 return false;
261 }
262
263 // This function is only ever called if we are in a GrDirectContext since we are calling read
264 // pixels here. Thus the pixel data will be uploaded immediately and we don't need to keep the
265 // pixel data alive in the proxy. Therefore the ReleaseProc is nullptr.
266 SkBitmap bitmap;
267 bitmap.installPixels(pmII, srcData, 4 * kSize);
268 bitmap.setImmutable();
269
270 auto dataView = std::get<0>(GrMakeUncachedBitmapProxyView(dContext, bitmap));
271 if (!dataView) {
272 return false;
273 }
274
275 uint32_t* firstRead = data.get() + kSize*kSize;
276 uint32_t* secondRead = data.get() + 2*kSize*kSize;
277 std::fill_n( firstRead, kSize*kSize, 0);
278 std::fill_n(secondRead, kSize*kSize, 0);
279
280 GrPixmap firstReadPM( upmII, firstRead, kSize*sizeof(uint32_t));
281 GrPixmap secondReadPM(upmII, secondRead, kSize*sizeof(uint32_t));
282
283 // We do a PM->UPM draw from dataTex to readTex and read the data. Then we do a UPM->PM draw
284 // from readTex to tempTex followed by a PM->UPM draw to readTex and finally read the data.
285 // We then verify that two reads produced the same values.
286
287 auto fp1 = make_unpremul_effect(GrTextureEffect::Make(std::move(dataView), bitmap.alphaType()));
288 readSFC->fillRectWithFP(SkIRect::MakeWH(kSize, kSize), std::move(fp1));
289 if (!readSFC->readPixels(dContext, firstReadPM, {0, 0})) {
290 return false;
291 }
292
293 auto fp2 = make_premul_effect(
294 GrTextureEffect::Make(readSFC->readSurfaceView(), readSFC->colorInfo().alphaType()));
295 tempSFC->fillRectWithFP(SkIRect::MakeWH(kSize, kSize), std::move(fp2));
296
297 auto fp3 = make_unpremul_effect(
298 GrTextureEffect::Make(tempSFC->readSurfaceView(), tempSFC->colorInfo().alphaType()));
299 readSFC->fillRectWithFP(SkIRect::MakeWH(kSize, kSize), std::move(fp3));
300
301 if (!readSFC->readPixels(dContext, secondReadPM, {0, 0})) {
302 return false;
303 }
304
305 for (int y = 0; y < kSize; ++y) {
306 for (int x = 0; x <= y; ++x) {
307 if (firstRead[kSize*y + x] != secondRead[kSize*y + x]) {
308 return false;
309 }
310 }
311 }
312
313 return true;
314}
315
316bool GrDirectContextPriv::validPMUPMConversionExists() {
317 ASSERT_SINGLE_OWNER
318
319 auto dContext = this->context();
320
321 if (!dContext->fDidTestPMConversions) {
322 dContext->fPMUPMConversionsRoundTrip = test_for_preserving_PM_conversions(dContext);
323 dContext->fDidTestPMConversions = true;
324 }
325
326 // The PM<->UPM tests fail or succeed together so we only need to check one.
327 return dContext->fPMUPMConversionsRoundTrip;
328}
329
330std::unique_ptr<GrFragmentProcessor> GrDirectContextPriv::createPMToUPMEffect(
331 std::unique_ptr<GrFragmentProcessor> fp) {
332 ASSERT_SINGLE_OWNER
333 // We should have already called this->priv().validPMUPMConversionExists() in this case
334 SkASSERT(this->context()->fDidTestPMConversions);
335 // ...and it should have succeeded
336 SkASSERT(this->validPMUPMConversionExists());
337
338 return make_unpremul_effect(std::move(fp));
339}
340
341std::unique_ptr<GrFragmentProcessor> GrDirectContextPriv::createUPMToPMEffect(
342 std::unique_ptr<GrFragmentProcessor> fp) {
343 ASSERT_SINGLE_OWNER
344 // We should have already called this->priv().validPMUPMConversionExists() in this case
345 SkASSERT(this->context()->fDidTestPMConversions);
346 // ...and it should have succeeded
347 SkASSERT(this->validPMUPMConversionExists());
348
349 return make_premul_effect(std::move(fp));
350}
info
static void info(const char *fmt,...) SK_PRINTF_LIKE(1
Definition DM.cpp:213
test_for_preserving_PM_conversions
static bool test_for_preserving_PM_conversions(GrDirectContext *dContext)
Definition GrDirectContextPriv.cpp:234
make_unpremul_effect
static std::unique_ptr< GrFragmentProcessor > make_unpremul_effect(std::unique_ptr< GrFragmentProcessor > fp)
Definition GrDirectContextPriv.cpp:215
ASSERT_OWNED_PROXY
#define ASSERT_OWNED_PROXY(P)
Definition GrDirectContextPriv.cpp:38
make_premul_effect
static std::unique_ptr< GrFragmentProcessor > make_premul_effect(std::unique_ptr< GrFragmentProcessor > fp)
Definition GrDirectContextPriv.cpp:196
GR_CREATE_TRACE_MARKER_CONTEXT
#define GR_CREATE_TRACE_MARKER_CONTEXT(classname, op, context)
Definition GrTracing.h:18
GrSemaphoresSubmitted
GrSemaphoresSubmitted
Definition GrTypes.h:229
color
SkColor4f color
Definition ImageShaderTest.cpp:28
kUnpremul_SkAlphaType
kUnpremul_SkAlphaType
Definition ReadPixBench.cpp:58
kPremul_SkAlphaType
@ kPremul_SkAlphaType
pixel components are premultiplied by alpha
Definition SkAlphaType.h:29
SkASSERT
#define SkASSERT(cond)
Definition SkAssert.h:116
SkColorType
SkColorType
Definition SkColorType.h:19
kRGBA_8888_SkColorType
@ kRGBA_8888_SkColorType
pixel with 8 bits for red, green, blue, alpha; in 32-bit word
Definition SkColorType.h:24
SkDebugf
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1
GrMakeUncachedBitmapProxyView
std::tuple< GrSurfaceProxyView, GrColorType > GrMakeUncachedBitmapProxyView(GrRecordingContext *rContext, const SkBitmap &bitmap, skgpu::Mipmapped mipmapped, SkBackingFit fit, skgpu::Budgeted budgeted)
Definition SkGr.cpp:253
colorType
static SkColorType colorType(AImageDecoder *decoder, const AImageDecoderHeaderInfo *headerInfo)
Definition SkImageGeneratorNDK.cpp:53
kNeedNewImageUniqueID
@ kNeedNewImageUniqueID
Definition SkImage_Base.h:33
sk_ref_sp
sk_sp< T > sk_ref_sp(T *obj)
Definition SkRefCnt.h:381
SkMakeRuntimeEffect
SkRuntimeEffect * SkMakeRuntimeEffect(SkRuntimeEffect::Result(*make)(SkString, const SkRuntimeEffect::Options &), const char *sksl, SkRuntimeEffect::Options options=SkRuntimeEffect::Options{})
Definition SkRuntimeEffectPriv.h:162
GrDirectContextPriv::createDDLTask
void createDDLTask(sk_sp< const GrDeferredDisplayList >, sk_sp< GrRenderTargetProxy > newDest)
Definition GrDirectContextPriv.cpp:70
GrDirectContextPriv::createPMToUPMEffect
std::unique_ptr< GrFragmentProcessor > createPMToUPMEffect(std::unique_ptr< GrFragmentProcessor >)
Definition GrDirectContextPriv.cpp:330
GrDirectContextPriv::createUPMToPMEffect
std::unique_ptr< GrFragmentProcessor > createUPMToPMEffect(std::unique_ptr< GrFragmentProcessor >)
Definition GrDirectContextPriv.cpp:341
GrDirectContextPriv::getAtlasManager
GrAtlasManager * getAtlasManager()
Definition GrDirectContextPriv.h:109
GrDirectContextPriv::compile
bool compile(const GrProgramDesc &, const GrProgramInfo &)
Definition GrDirectContextPriv.cpp:75
GrDirectContextPriv::flushSurfaces
GrSemaphoresSubmitted flushSurfaces(SkSpan< GrSurfaceProxy * >, SkSurfaces::BackendSurfaceAccess=SkSurfaces::BackendSurfaceAccess::kNoAccess, const GrFlushInfo &={}, const skgpu::MutableTextureState *newState=nullptr)
Definition GrDirectContextPriv.cpp:43
GrDirectContextPriv::context
GrDirectContext * context()
Definition GrDirectContextPriv.h:53
GrDirectContext::flushAndSubmit
void flushAndSubmit(GrSyncCpu sync=GrSyncCpu::kNo)
Definition GrDirectContext.h:332
GrDirectContext::priv
GrDirectContextPriv priv()
Definition GrDirectContextPriv.h:186
GrDrawingManager::createDDLTask
void createDDLTask(sk_sp< const GrDeferredDisplayList >, sk_sp< GrRenderTargetProxy > newDest)
Definition GrDrawingManager.cpp:596
GrDrawingManager::flushSurfaces
GrSemaphoresSubmitted flushSurfaces(SkSpan< GrSurfaceProxy * >, SkSurfaces::BackendSurfaceAccess, const GrFlushInfo &, const skgpu::MutableTextureState *newState)
Definition GrDrawingManager.cpp:497
GrFragmentProcessor::HighPrecision
static std::unique_ptr< GrFragmentProcessor > HighPrecision(std::unique_ptr< GrFragmentProcessor >)
Definition GrFragmentProcessor.cpp:799
GrGpu
Definition GrGpu.h:62
GrGpu::compile
virtual bool compile(const GrProgramDesc &, const GrProgramInfo &)=0
GrRecordingContextPriv::makeSFC
std::unique_ptr< skgpu::ganesh::SurfaceFillContext > makeSFC(GrImageInfo, std::string_view label, SkBackingFit=SkBackingFit::kExact, int sampleCount=1, skgpu::Mipmapped=skgpu::Mipmapped::kNo, skgpu::Protected=skgpu::Protected::kNo, GrSurfaceOrigin=kTopLeft_GrSurfaceOrigin, skgpu::Budgeted=skgpu::Budgeted::kYes)
Definition GrRecordingContextPriv.cpp:160
GrRecordingContext::drawingManager
GrDrawingManager * drawingManager()
Definition GrRecordingContext.cpp:96
GrSkSLFP::Make
static std::unique_ptr< GrSkSLFP > Make(const SkRuntimeEffect *effect, const char *name, std::unique_ptr< GrFragmentProcessor > inputFP, OptFlags optFlags, Args &&... args)
Definition GrSkSLFP.h:158
GrTextureEffect::Make
static std::unique_ptr< GrFragmentProcessor > Make(GrSurfaceProxyView, SkAlphaType, const SkMatrix &=SkMatrix::I(), GrSamplerState::Filter=GrSamplerState::Filter::kNearest, GrSamplerState::MipmapMode mipmapMode=GrSamplerState::MipmapMode::kNone)
SkRuntimeEffect::MakeForColorFilter
static Result MakeForColorFilter(SkString sksl, const Options &)
Definition SkRuntimeEffect.cpp:656
sk_sp
Definition SkRefCnt.h:220
skia_private::AutoTMalloc
Definition SkTemplates.h:278
skia_private::TArray
Definition SkTArray.h:40
kSize
static constexpr int kSize
Definition clip_sierpinski_region.cpp:14
priv
FlPixelBufferTexturePrivate * priv
Definition fl_pixel_buffer_texture.cc:30
format
uint32_t uint32_t * format
Definition fl_texture_registrar_test.cc:41
ASSERT_SINGLE_OWNER
#define ASSERT_SINGLE_OWNER
Definition Device.cpp:120
y
double y
Definition mouse-input-test.cc:83
x
double x
Definition mouse-input-test.cc:82
SkSurfaces::BackendSurfaceAccess
BackendSurfaceAccess
Definition SkSurface.h:44
dart::fp
const uint32_t fp
Definition method_recognizer.cc:136
dump_adb_log.out
out
Definition dump_adb_log.py:10
flutter::data
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot data
Definition switches.h:41
skgpu::MaskFormatToColorType
static constexpr SkColorType MaskFormatToColorType(MaskFormat format)
Definition AtlasTypes.h:122
GrFlushInfo::fSubmittedProc
GrGpuSubmittedProc fSubmittedProc
Definition GrTypes.h:221
SkIRect::MakeWH
static constexpr SkIRect MakeWH(int32_t w, int32_t h)
Definition SkRect.h:56
SkImageInfo::makeAlphaType
SkImageInfo makeAlphaType(SkAlphaType newAlphaType) const
Definition SkImageInfo.h:466
SkImageInfo::Make
static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at)
Definition SkImageInfo.cpp:127

◆ ASSERT_SINGLE_OWNER

#define ASSERT_SINGLE_OWNER   SKGPU_ASSERT_SINGLE_OWNER(this->context()->singleOwner())

Definition at line 40 of file GrDirectContextPriv.cpp.

◆ RETURN_VALUE_IF_ABANDONED

#define RETURN_VALUE_IF_ABANDONED (   value)    if (this->context()->abandoned()) { return (value); }

Definition at line 41 of file GrDirectContextPriv.cpp.

Typedef Documentation

◆ MaskFormat

using MaskFormat = skgpu::MaskFormat

Definition at line 36 of file GrDirectContextPriv.cpp.

Function Documentation

◆ make_premul_effect()

static std::unique_ptr< GrFragmentProcessor > make_premul_effect ( std::unique_ptr< GrFragmentProcessor >  fp)
static

Definition at line 196 of file GrDirectContextPriv.cpp.

197 {
198 if (!fp) {
199 return nullptr;
200 }
201
202 static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
203 "half4 main(half4 halfColor) {"
204 "float4 color = float4(halfColor);"
205 "color = floor(color * 255 + 0.5) / 255;"
206 "color.rgb = floor(color.rgb * color.a * 255 + 0.5) / 255;"
207 "return color;"
208 "}"
209 );
210
211 fp = GrSkSLFP::Make(effect, "ToPremul", std::move(fp), GrSkSLFP::OptFlags::kNone);
212 return GrFragmentProcessor::HighPrecision(std::move(fp));
213}

◆ make_unpremul_effect()

static std::unique_ptr< GrFragmentProcessor > make_unpremul_effect ( std::unique_ptr< GrFragmentProcessor >  fp)
static

Definition at line 215 of file GrDirectContextPriv.cpp.

216 {
217 if (!fp) {
218 return nullptr;
219 }
220
221 static const SkRuntimeEffect* effect = SkMakeRuntimeEffect(SkRuntimeEffect::MakeForColorFilter,
222 "half4 main(half4 halfColor) {"
223 "float4 color = float4(halfColor);"
224 "color = floor(color * 255 + 0.5) / 255;"
225 "color.rgb = color.a <= 0 ? half3(0) : floor(color.rgb / color.a * 255 + 0.5) / 255;"
226 "return color;"
227 "}"
228 );
229
230 fp = GrSkSLFP::Make(effect, "ToUnpremul", std::move(fp), GrSkSLFP::OptFlags::kNone);
231 return GrFragmentProcessor::HighPrecision(std::move(fp));
232}

◆ test_for_preserving_PM_conversions()

static bool test_for_preserving_PM_conversions ( GrDirectContext *  dContext)
static

Definition at line 234 of file GrDirectContextPriv.cpp.

234 {
235 static constexpr int kSize = 256;
236 AutoTMalloc<uint32_t> data(kSize * kSize * 3);
237 uint32_t* srcData = data.get();
238
239 // Fill with every possible premultiplied A, color channel value. There will be 256-y duplicate
240 // values in row y. We set r, g, and b to the same value since they are handled identically.
241 for (int y = 0; y < kSize; ++y) {
242 for (int x = 0; x < kSize; ++x) {
243 uint8_t* color = reinterpret_cast<uint8_t*>(&srcData[kSize*y + x]);
244 color[3] = y;
245 color[2] = std::min(x, y);
246 color[1] = std::min(x, y);
247 color[0] = std::min(x, y);
248 }
249 }
250
251 const SkImageInfo pmII =
252 SkImageInfo::Make(kSize, kSize, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
253 const SkImageInfo upmII = pmII.makeAlphaType(kUnpremul_SkAlphaType);
254
255 auto readSFC =
256 dContext->priv().makeSFC(upmII, "ReadSfcForPMUPMConversion", SkBackingFit::kExact);
257 auto tempSFC =
258 dContext->priv().makeSFC(pmII, "TempSfcForPMUPMConversion", SkBackingFit::kExact);
259 if (!readSFC || !tempSFC) {
260 return false;
261 }
262
263 // This function is only ever called if we are in a GrDirectContext since we are calling read
264 // pixels here. Thus the pixel data will be uploaded immediately and we don't need to keep the
265 // pixel data alive in the proxy. Therefore the ReleaseProc is nullptr.
266 SkBitmap bitmap;
267 bitmap.installPixels(pmII, srcData, 4 * kSize);
268 bitmap.setImmutable();
269
270 auto dataView = std::get<0>(GrMakeUncachedBitmapProxyView(dContext, bitmap));
271 if (!dataView) {
272 return false;
273 }
274
275 uint32_t* firstRead = data.get() + kSize*kSize;
276 uint32_t* secondRead = data.get() + 2*kSize*kSize;
277 std::fill_n( firstRead, kSize*kSize, 0);
278 std::fill_n(secondRead, kSize*kSize, 0);
279
280 GrPixmap firstReadPM( upmII, firstRead, kSize*sizeof(uint32_t));
281 GrPixmap secondReadPM(upmII, secondRead, kSize*sizeof(uint32_t));
282
283 // We do a PM->UPM draw from dataTex to readTex and read the data. Then we do a UPM->PM draw
284 // from readTex to tempTex followed by a PM->UPM draw to readTex and finally read the data.
285 // We then verify that two reads produced the same values.
286
287 auto fp1 = make_unpremul_effect(GrTextureEffect::Make(std::move(dataView), bitmap.alphaType()));
288 readSFC->fillRectWithFP(SkIRect::MakeWH(kSize, kSize), std::move(fp1));
289 if (!readSFC->readPixels(dContext, firstReadPM, {0, 0})) {
290 return false;
291 }
292
293 auto fp2 = make_premul_effect(
294 GrTextureEffect::Make(readSFC->readSurfaceView(), readSFC->colorInfo().alphaType()));
295 tempSFC->fillRectWithFP(SkIRect::MakeWH(kSize, kSize), std::move(fp2));
296
297 auto fp3 = make_unpremul_effect(
298 GrTextureEffect::Make(tempSFC->readSurfaceView(), tempSFC->colorInfo().alphaType()));
299 readSFC->fillRectWithFP(SkIRect::MakeWH(kSize, kSize), std::move(fp3));
300
301 if (!readSFC->readPixels(dContext, secondReadPM, {0, 0})) {
302 return false;
303 }
304
305 for (int y = 0; y < kSize; ++y) {
306 for (int x = 0; x <= y; ++x) {
307 if (firstRead[kSize*y + x] != secondRead[kSize*y + x]) {
308 return false;
309 }
310 }
311 }
312
313 return true;
314}
Generated on Fri Apr 26 2024 06:18:46 for Flutter Engine by doxygen 1.9.8