1 /*
2 * Copyright 2010 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8
9 #include "SkGr.h"
10
11 #include "GrCaps.h"
12 #include "GrContext.h"
13 #include "GrTextureParamsAdjuster.h"
14 #include "GrGpuResourcePriv.h"
15 #include "GrImageIDTextureAdjuster.h"
16 #include "GrXferProcessor.h"
17 #include "GrYUVProvider.h"
18
19 #include "SkColorFilter.h"
20 #include "SkConfig8888.h"
21 #include "SkCanvas.h"
22 #include "SkData.h"
23 #include "SkErrorInternals.h"
24 #include "SkGrPixelRef.h"
25 #include "SkMessageBus.h"
26 #include "SkPixelRef.h"
27 #include "SkResourceCache.h"
28 #include "SkTextureCompressor.h"
29 #include "SkYUVPlanesCache.h"
30 #include "effects/GrBicubicEffect.h"
31 #include "effects/GrConstColorProcessor.h"
32 #include "effects/GrDitherEffect.h"
33 #include "effects/GrPorterDuffXferProcessor.h"
34 #include "effects/GrXfermodeFragmentProcessor.h"
35 #include "effects/GrYUVEffect.h"
36
37 #ifndef SK_IGNORE_ETC1_SUPPORT
38 # include "ktx.h"
39 # include "etc1.h"
40 #endif
41
GrImageInfoToSurfaceDesc(const SkImageInfo & info)42 GrSurfaceDesc GrImageInfoToSurfaceDesc(const SkImageInfo& info) {
43 GrSurfaceDesc desc;
44 desc.fFlags = kNone_GrSurfaceFlags;
45 desc.fWidth = info.width();
46 desc.fHeight = info.height();
47 desc.fConfig = SkImageInfo2GrPixelConfig(info);
48 desc.fSampleCnt = 0;
49 return desc;
50 }
51
GrMakeKeyFromImageID(GrUniqueKey * key,uint32_t imageID,const SkIRect & imageBounds)52 void GrMakeKeyFromImageID(GrUniqueKey* key, uint32_t imageID, const SkIRect& imageBounds) {
53 SkASSERT(key);
54 SkASSERT(imageID);
55 SkASSERT(!imageBounds.isEmpty());
56 static const GrUniqueKey::Domain kImageIDDomain = GrUniqueKey::GenerateDomain();
57 GrUniqueKey::Builder builder(key, kImageIDDomain, 5);
58 builder[0] = imageID;
59 builder[1] = imageBounds.fLeft;
60 builder[2] = imageBounds.fTop;
61 builder[3] = imageBounds.fRight;
62 builder[4] = imageBounds.fBottom;
63 }
64
GrIsCompressedTextureDataSupported(GrContext * ctx,SkData * data,int expectedW,int expectedH,const void ** outStartOfDataToUpload)65 GrPixelConfig GrIsCompressedTextureDataSupported(GrContext* ctx, SkData* data,
66 int expectedW, int expectedH,
67 const void** outStartOfDataToUpload) {
68 *outStartOfDataToUpload = nullptr;
69 #ifndef SK_IGNORE_ETC1_SUPPORT
70 if (!ctx->caps()->isConfigTexturable(kETC1_GrPixelConfig)) {
71 return kUnknown_GrPixelConfig;
72 }
73
74 const uint8_t* bytes = data->bytes();
75 if (data->size() > ETC_PKM_HEADER_SIZE && etc1_pkm_is_valid(bytes)) {
76 // Does the data match the dimensions of the bitmap? If not,
77 // then we don't know how to scale the image to match it...
78 if (etc1_pkm_get_width(bytes) != (unsigned)expectedW ||
79 etc1_pkm_get_height(bytes) != (unsigned)expectedH)
80 {
81 return kUnknown_GrPixelConfig;
82 }
83
84 *outStartOfDataToUpload = bytes + ETC_PKM_HEADER_SIZE;
85 return kETC1_GrPixelConfig;
86 } else if (SkKTXFile::is_ktx(bytes)) {
87 SkKTXFile ktx(data);
88
89 // Is it actually an ETC1 texture?
90 if (!ktx.isCompressedFormat(SkTextureCompressor::kETC1_Format)) {
91 return kUnknown_GrPixelConfig;
92 }
93
94 // Does the data match the dimensions of the bitmap? If not,
95 // then we don't know how to scale the image to match it...
96 if (ktx.width() != expectedW || ktx.height() != expectedH) {
97 return kUnknown_GrPixelConfig;
98 }
99
100 *outStartOfDataToUpload = ktx.pixelData();
101 return kETC1_GrPixelConfig;
102 }
103 #endif
104 return kUnknown_GrPixelConfig;
105 }
106
107 //////////////////////////////////////////////////////////////////////////////
108
109 /**
110 * Fill out buffer with the compressed format Ganesh expects from a colortable
111 * based bitmap. [palette (colortable) + indices].
112 *
113 * At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
114 * we could detect that the colortable.count is <= 16, and then repack the
115 * indices as nibbles to save RAM, but it would take more time (i.e. a lot
116 * slower than memcpy), so skipping that for now.
117 *
118 * Ganesh wants a full 256 palette entry, even though Skia's ctable is only as big
119 * as the colortable.count says it is.
120 */
build_index8_data(void * buffer,const SkBitmap & bitmap)121 static void build_index8_data(void* buffer, const SkBitmap& bitmap) {
122 SkASSERT(kIndex_8_SkColorType == bitmap.colorType());
123
124 SkAutoLockPixels alp(bitmap);
125 if (!bitmap.readyToDraw()) {
126 SkDEBUGFAIL("bitmap not ready to draw!");
127 return;
128 }
129
130 SkColorTable* ctable = bitmap.getColorTable();
131 char* dst = (char*)buffer;
132
133 const int count = ctable->count();
134
135 SkDstPixelInfo dstPI;
136 dstPI.fColorType = kRGBA_8888_SkColorType;
137 dstPI.fAlphaType = kPremul_SkAlphaType;
138 dstPI.fPixels = buffer;
139 dstPI.fRowBytes = count * sizeof(SkPMColor);
140
141 SkSrcPixelInfo srcPI;
142 srcPI.fColorType = kN32_SkColorType;
143 srcPI.fAlphaType = kPremul_SkAlphaType;
144 srcPI.fPixels = ctable->readColors();
145 srcPI.fRowBytes = count * sizeof(SkPMColor);
146
147 srcPI.convertPixelsTo(&dstPI, count, 1);
148
149 // always skip a full 256 number of entries, even if we memcpy'd fewer
150 dst += 256 * sizeof(GrColor);
151
152 if ((unsigned)bitmap.width() == bitmap.rowBytes()) {
153 memcpy(dst, bitmap.getPixels(), bitmap.getSize());
154 } else {
155 // need to trim off the extra bytes per row
156 size_t width = bitmap.width();
157 size_t rowBytes = bitmap.rowBytes();
158 const char* src = (const char*)bitmap.getPixels();
159 for (int y = 0; y < bitmap.height(); y++) {
160 memcpy(dst, src, width);
161 src += rowBytes;
162 dst += width;
163 }
164 }
165 }
166
167 /**
168 * Once we have made SkImages handle all lazy/deferred/generated content, the YUV apis will
169 * be gone from SkPixelRef, and we can remove this subclass entirely.
170 */
171 class PixelRef_GrYUVProvider : public GrYUVProvider {
172 SkPixelRef* fPR;
173
174 public:
PixelRef_GrYUVProvider(SkPixelRef * pr)175 PixelRef_GrYUVProvider(SkPixelRef* pr) : fPR(pr) {}
176
onGetID()177 uint32_t onGetID() override { return fPR->getGenerationID(); }
onGetYUVSizes(SkISize sizes[3])178 bool onGetYUVSizes(SkISize sizes[3]) override {
179 return fPR->getYUV8Planes(sizes, nullptr, nullptr, nullptr);
180 }
onGetYUVPlanes(SkISize sizes[3],void * planes[3],size_t rowBytes[3],SkYUVColorSpace * space)181 bool onGetYUVPlanes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
182 SkYUVColorSpace* space) override {
183 return fPR->getYUV8Planes(sizes, planes, rowBytes, space);
184 }
185 };
186
create_texture_from_yuv(GrContext * ctx,const SkBitmap & bm,const GrSurfaceDesc & desc)187 static GrTexture* create_texture_from_yuv(GrContext* ctx, const SkBitmap& bm,
188 const GrSurfaceDesc& desc) {
189 // Subsets are not supported, the whole pixelRef is loaded when using YUV decoding
190 SkPixelRef* pixelRef = bm.pixelRef();
191 if ((nullptr == pixelRef) ||
192 (pixelRef->info().width() != bm.info().width()) ||
193 (pixelRef->info().height() != bm.info().height())) {
194 return nullptr;
195 }
196
197 PixelRef_GrYUVProvider provider(pixelRef);
198
199 return provider.refAsTexture(ctx, desc, !bm.isVolatile());
200 }
201
load_etc1_texture(GrContext * ctx,const SkBitmap & bm,GrSurfaceDesc desc)202 static GrTexture* load_etc1_texture(GrContext* ctx, const SkBitmap &bm, GrSurfaceDesc desc) {
203 SkAutoTUnref<SkData> data(bm.pixelRef()->refEncodedData());
204 if (!data) {
205 return nullptr;
206 }
207
208 const void* startOfTexData;
209 desc.fConfig = GrIsCompressedTextureDataSupported(ctx, data, bm.width(), bm.height(),
210 &startOfTexData);
211 if (kUnknown_GrPixelConfig == desc.fConfig) {
212 return nullptr;
213 }
214
215 return ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes, startOfTexData, 0);
216 }
217
GrUploadBitmapToTexture(GrContext * ctx,const SkBitmap & bmp)218 GrTexture* GrUploadBitmapToTexture(GrContext* ctx, const SkBitmap& bmp) {
219 SkASSERT(!bmp.getTexture());
220
221 SkBitmap tmpBitmap;
222 const SkBitmap* bitmap = &bmp;
223
224 GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap->info());
225 const GrCaps* caps = ctx->caps();
226
227 if (kIndex_8_SkColorType == bitmap->colorType()) {
228 if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) {
229 size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
230 bitmap->width(), bitmap->height());
231 SkAutoMalloc storage(imageSize);
232 build_index8_data(storage.get(), bmp);
233
234 // our compressed data will be trimmed, so pass width() for its
235 // "rowBytes", since they are the same now.
236 return ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes, storage.get(),
237 bitmap->width());
238 } else {
239 bmp.copyTo(&tmpBitmap, kN32_SkColorType);
240 // now bitmap points to our temp, which has been promoted to 32bits
241 bitmap = &tmpBitmap;
242 desc.fConfig = SkImageInfo2GrPixelConfig(bitmap->info());
243 }
244 } else if (!bitmap->readyToDraw()) {
245 // If the bitmap had compressed data and was then uncompressed, it'll still return
246 // compressed data on 'refEncodedData' and upload it. Probably not good, since if
247 // the bitmap has available pixels, then they might not be what the decompressed
248 // data is.
249
250 // Really?? We aren't doing this with YUV.
251
252 GrTexture *texture = load_etc1_texture(ctx, *bitmap, desc);
253 if (texture) {
254 return texture;
255 }
256 }
257
258 GrTexture *texture = create_texture_from_yuv(ctx, *bitmap, desc);
259 if (texture) {
260 return texture;
261 }
262
263 SkAutoLockPixels alp(*bitmap);
264 if (!bitmap->readyToDraw()) {
265 return nullptr;
266 }
267
268 return ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes, bitmap->getPixels(),
269 bitmap->rowBytes());
270 }
271
272
273 ////////////////////////////////////////////////////////////////////////////////
274
GrInstallBitmapUniqueKeyInvalidator(const GrUniqueKey & key,SkPixelRef * pixelRef)275 void GrInstallBitmapUniqueKeyInvalidator(const GrUniqueKey& key, SkPixelRef* pixelRef) {
276 class Invalidator : public SkPixelRef::GenIDChangeListener {
277 public:
278 explicit Invalidator(const GrUniqueKey& key) : fMsg(key) {}
279 private:
280 GrUniqueKeyInvalidatedMessage fMsg;
281
282 void onChange() override { SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg); }
283 };
284
285 pixelRef->addGenIDChangeListener(new Invalidator(key));
286 }
287
GrRefCachedBitmapTexture(GrContext * ctx,const SkBitmap & bitmap,const GrTextureParams & params)288 GrTexture* GrRefCachedBitmapTexture(GrContext* ctx, const SkBitmap& bitmap,
289 const GrTextureParams& params) {
290 if (bitmap.getTexture()) {
291 return GrBitmapTextureAdjuster(&bitmap).refTextureSafeForParams(params, nullptr);
292 }
293 return GrBitmapTextureMaker(ctx, bitmap).refTextureForParams(params);
294 }
295
296 ///////////////////////////////////////////////////////////////////////////////
297
298 // alphatype is ignore for now, but if GrPixelConfig is expanded to encompass
299 // alpha info, that will be considered.
SkImageInfo2GrPixelConfig(SkColorType ct,SkAlphaType,SkColorProfileType pt)300 GrPixelConfig SkImageInfo2GrPixelConfig(SkColorType ct, SkAlphaType, SkColorProfileType pt) {
301 switch (ct) {
302 case kUnknown_SkColorType:
303 return kUnknown_GrPixelConfig;
304 case kAlpha_8_SkColorType:
305 return kAlpha_8_GrPixelConfig;
306 case kRGB_565_SkColorType:
307 return kRGB_565_GrPixelConfig;
308 case kARGB_4444_SkColorType:
309 return kRGBA_4444_GrPixelConfig;
310 case kRGBA_8888_SkColorType:
311 //if (kSRGB_SkColorProfileType == pt) {
312 // return kSRGBA_8888_GrPixelConfig;
313 //}
314 return kRGBA_8888_GrPixelConfig;
315 case kBGRA_8888_SkColorType:
316 return kBGRA_8888_GrPixelConfig;
317 case kIndex_8_SkColorType:
318 return kIndex_8_GrPixelConfig;
319 case kGray_8_SkColorType:
320 return kAlpha_8_GrPixelConfig; // TODO: gray8 support on gpu
321 case kRGBA_F16_SkColorType:
322 return kRGBA_half_GrPixelConfig;
323 }
324 SkASSERT(0); // shouldn't get here
325 return kUnknown_GrPixelConfig;
326 }
327
GrPixelConfig2ColorAndProfileType(GrPixelConfig config,SkColorType * ctOut,SkColorProfileType * ptOut)328 bool GrPixelConfig2ColorAndProfileType(GrPixelConfig config, SkColorType* ctOut,
329 SkColorProfileType* ptOut) {
330 SkColorType ct;
331 SkColorProfileType pt = kLinear_SkColorProfileType;
332 switch (config) {
333 case kAlpha_8_GrPixelConfig:
334 ct = kAlpha_8_SkColorType;
335 break;
336 case kIndex_8_GrPixelConfig:
337 ct = kIndex_8_SkColorType;
338 break;
339 case kRGB_565_GrPixelConfig:
340 ct = kRGB_565_SkColorType;
341 break;
342 case kRGBA_4444_GrPixelConfig:
343 ct = kARGB_4444_SkColorType;
344 break;
345 case kRGBA_8888_GrPixelConfig:
346 ct = kRGBA_8888_SkColorType;
347 break;
348 case kBGRA_8888_GrPixelConfig:
349 ct = kBGRA_8888_SkColorType;
350 break;
351 case kSRGBA_8888_GrPixelConfig:
352 ct = kRGBA_8888_SkColorType;
353 pt = kSRGB_SkColorProfileType;
354 break;
355 default:
356 return false;
357 }
358 if (ctOut) {
359 *ctOut = ct;
360 }
361 if (ptOut) {
362 *ptOut = pt;
363 }
364 return true;
365 }
366
367 ////////////////////////////////////////////////////////////////////////////////////////////////
368
blend_requires_shader(const SkXfermode::Mode mode,bool primitiveIsSrc)369 static inline bool blend_requires_shader(const SkXfermode::Mode mode, bool primitiveIsSrc) {
370 if (primitiveIsSrc) {
371 return SkXfermode::kSrc_Mode != mode;
372 } else {
373 return SkXfermode::kDst_Mode != mode;
374 }
375 }
376
skpaint_to_grpaint_impl(GrContext * context,const SkPaint & skPaint,const SkMatrix & viewM,const GrFragmentProcessor ** shaderProcessor,SkXfermode::Mode * primColorMode,bool primitiveIsSrc,GrPaint * grPaint)377 static inline bool skpaint_to_grpaint_impl(GrContext* context,
378 const SkPaint& skPaint,
379 const SkMatrix& viewM,
380 const GrFragmentProcessor** shaderProcessor,
381 SkXfermode::Mode* primColorMode,
382 bool primitiveIsSrc,
383 GrPaint* grPaint) {
384 grPaint->setAntiAlias(skPaint.isAntiAlias());
385
386 // Setup the initial color considering the shader, the SkPaint color, and the presence or not
387 // of per-vertex colors.
388 SkAutoTUnref<const GrFragmentProcessor> aufp;
389 const GrFragmentProcessor* shaderFP = nullptr;
390 if (!primColorMode || blend_requires_shader(*primColorMode, primitiveIsSrc)) {
391 if (shaderProcessor) {
392 shaderFP = *shaderProcessor;
393 } else if (const SkShader* shader = skPaint.getShader()) {
394 aufp.reset(shader->asFragmentProcessor(context, viewM, nullptr,
395 skPaint.getFilterQuality()));
396 shaderFP = aufp;
397 if (!shaderFP) {
398 return false;
399 }
400 }
401 }
402
403 // Set this in below cases if the output of the shader/paint-color/paint-alpha/primXfermode is
404 // a known constant value. In that case we can simply apply a color filter during this
405 // conversion without converting the color filter to a GrFragmentProcessor.
406 bool applyColorFilterToPaintColor = false;
407 if (shaderFP) {
408 if (primColorMode) {
409 // There is a blend between the primitive color and the shader color. The shader sees
410 // the opaque paint color. The shader's output is blended using the provided mode by
411 // the primitive color. The blended color is then modulated by the paint's alpha.
412
413 // The geometry processor will insert the primitive color to start the color chain, so
414 // the GrPaint color will be ignored.
415
416 GrColor shaderInput = SkColorToOpaqueGrColor(skPaint.getColor());
417
418 shaderFP = GrFragmentProcessor::OverrideInput(shaderFP, shaderInput);
419 aufp.reset(shaderFP);
420
421 if (primitiveIsSrc) {
422 shaderFP = GrXfermodeFragmentProcessor::CreateFromDstProcessor(shaderFP,
423 *primColorMode);
424 } else {
425 shaderFP = GrXfermodeFragmentProcessor::CreateFromSrcProcessor(shaderFP,
426 *primColorMode);
427 }
428 aufp.reset(shaderFP);
429 // The above may return null if compose results in a pass through of the prim color.
430 if (shaderFP) {
431 grPaint->addColorFragmentProcessor(shaderFP);
432 }
433
434 GrColor paintAlpha = SkColorAlphaToGrColor(skPaint.getColor());
435 if (GrColor_WHITE != paintAlpha) {
436 grPaint->addColorFragmentProcessor(GrConstColorProcessor::Create(
437 paintAlpha, GrConstColorProcessor::kModulateRGBA_InputMode))->unref();
438 }
439 } else {
440 // The shader's FP sees the paint unpremul color
441 grPaint->setColor(SkColorToUnpremulGrColor(skPaint.getColor()));
442 grPaint->addColorFragmentProcessor(shaderFP);
443 }
444 } else {
445 if (primColorMode) {
446 // There is a blend between the primitive color and the paint color. The blend considers
447 // the opaque paint color. The paint's alpha is applied to the post-blended color.
448 SkAutoTUnref<const GrFragmentProcessor> processor(
449 GrConstColorProcessor::Create(SkColorToOpaqueGrColor(skPaint.getColor()),
450 GrConstColorProcessor::kIgnore_InputMode));
451 if (primitiveIsSrc) {
452 processor.reset(GrXfermodeFragmentProcessor::CreateFromDstProcessor(processor,
453 *primColorMode));
454 } else {
455 processor.reset(GrXfermodeFragmentProcessor::CreateFromSrcProcessor(processor,
456 *primColorMode));
457
458 }
459 if (processor) {
460 grPaint->addColorFragmentProcessor(processor);
461 }
462
463 grPaint->setColor(SkColorToOpaqueGrColor(skPaint.getColor()));
464
465 GrColor paintAlpha = SkColorAlphaToGrColor(skPaint.getColor());
466 if (GrColor_WHITE != paintAlpha) {
467 grPaint->addColorFragmentProcessor(GrConstColorProcessor::Create(
468 paintAlpha, GrConstColorProcessor::kModulateRGBA_InputMode))->unref();
469 }
470 } else {
471 // No shader, no primitive color.
472 grPaint->setColor(SkColorToPremulGrColor(skPaint.getColor()));
473 applyColorFilterToPaintColor = true;
474 }
475 }
476
477 SkColorFilter* colorFilter = skPaint.getColorFilter();
478 if (colorFilter) {
479 if (applyColorFilterToPaintColor) {
480 grPaint->setColor(SkColorToPremulGrColor(colorFilter->filterColor(skPaint.getColor())));
481 } else {
482 SkAutoTUnref<const GrFragmentProcessor> cfFP(
483 colorFilter->asFragmentProcessor(context));
484 if (cfFP) {
485 grPaint->addColorFragmentProcessor(cfFP);
486 } else {
487 return false;
488 }
489 }
490 }
491
492 // When the xfermode is null on the SkPaint (meaning kSrcOver) we need the XPFactory field on
493 // the GrPaint to also be null (also kSrcOver).
494 SkASSERT(!grPaint->getXPFactory());
495 SkXfermode* xfermode = skPaint.getXfermode();
496 if (xfermode) {
497 // SafeUnref in case a new xfermode is added that returns null.
498 // In such cases we will fall back to kSrcOver_Mode.
499 SkSafeUnref(grPaint->setXPFactory(xfermode->asXPFactory()));
500 }
501
502 #ifndef SK_IGNORE_GPU_DITHER
503 if (skPaint.isDither() && grPaint->numColorFragmentProcessors() > 0) {
504 grPaint->addColorFragmentProcessor(GrDitherEffect::Create())->unref();
505 }
506 #endif
507 return true;
508 }
509
SkPaintToGrPaint(GrContext * context,const SkPaint & skPaint,const SkMatrix & viewM,GrPaint * grPaint)510 bool SkPaintToGrPaint(GrContext* context, const SkPaint& skPaint, const SkMatrix& viewM,
511 GrPaint* grPaint) {
512 return skpaint_to_grpaint_impl(context, skPaint, viewM, nullptr, nullptr, false, grPaint);
513 }
514
515 /** Replaces the SkShader (if any) on skPaint with the passed in GrFragmentProcessor. */
SkPaintToGrPaintReplaceShader(GrContext * context,const SkPaint & skPaint,const GrFragmentProcessor * shaderFP,GrPaint * grPaint)516 bool SkPaintToGrPaintReplaceShader(GrContext* context,
517 const SkPaint& skPaint,
518 const GrFragmentProcessor* shaderFP,
519 GrPaint* grPaint) {
520 if (!shaderFP) {
521 return false;
522 }
523 return skpaint_to_grpaint_impl(context, skPaint, SkMatrix::I(), &shaderFP, nullptr, false,
524 grPaint);
525 }
526
527 /** Ignores the SkShader (if any) on skPaint. */
SkPaintToGrPaintNoShader(GrContext * context,const SkPaint & skPaint,GrPaint * grPaint)528 bool SkPaintToGrPaintNoShader(GrContext* context,
529 const SkPaint& skPaint,
530 GrPaint* grPaint) {
531 // Use a ptr to a nullptr to to indicate that the SkShader is ignored and not replaced.
532 static const GrFragmentProcessor* kNullShaderFP = nullptr;
533 static const GrFragmentProcessor** kIgnoreShader = &kNullShaderFP;
534 return skpaint_to_grpaint_impl(context, skPaint, SkMatrix::I(), kIgnoreShader, nullptr, false,
535 grPaint);
536 }
537
538 /** Blends the SkPaint's shader (or color if no shader) with a per-primitive color which must
539 be setup as a vertex attribute using the specified SkXfermode::Mode. */
SkPaintToGrPaintWithXfermode(GrContext * context,const SkPaint & skPaint,const SkMatrix & viewM,SkXfermode::Mode primColorMode,bool primitiveIsSrc,GrPaint * grPaint)540 bool SkPaintToGrPaintWithXfermode(GrContext* context,
541 const SkPaint& skPaint,
542 const SkMatrix& viewM,
543 SkXfermode::Mode primColorMode,
544 bool primitiveIsSrc,
545 GrPaint* grPaint) {
546 return skpaint_to_grpaint_impl(context, skPaint, viewM, nullptr, &primColorMode, primitiveIsSrc,
547 grPaint);
548 }
549
SkPaintToGrPaintWithTexture(GrContext * context,const SkPaint & paint,const SkMatrix & viewM,const GrFragmentProcessor * fp,bool textureIsAlphaOnly,GrPaint * grPaint)550 bool SkPaintToGrPaintWithTexture(GrContext* context,
551 const SkPaint& paint,
552 const SkMatrix& viewM,
553 const GrFragmentProcessor* fp,
554 bool textureIsAlphaOnly,
555 GrPaint* grPaint) {
556 SkAutoTUnref<const GrFragmentProcessor> shaderFP;
557 if (textureIsAlphaOnly) {
558 if (const SkShader* shader = paint.getShader()) {
559 shaderFP.reset(shader->asFragmentProcessor(context,
560 viewM,
561 nullptr,
562 paint.getFilterQuality()));
563 if (!shaderFP) {
564 return false;
565 }
566 const GrFragmentProcessor* fpSeries[] = { shaderFP.get(), fp };
567 shaderFP.reset(GrFragmentProcessor::RunInSeries(fpSeries, 2));
568 } else {
569 shaderFP.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
570 }
571 } else {
572 shaderFP.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
573 }
574
575 return SkPaintToGrPaintReplaceShader(context, paint, shaderFP.get(), grPaint);
576 }
577
578
579 ////////////////////////////////////////////////////////////////////////////////////////////////
580
GrMakeInfoFromTexture(GrTexture * tex,int w,int h,bool isOpaque)581 SkImageInfo GrMakeInfoFromTexture(GrTexture* tex, int w, int h, bool isOpaque) {
582 #ifdef SK_DEBUG
583 const GrSurfaceDesc& desc = tex->desc();
584 SkASSERT(w <= desc.fWidth);
585 SkASSERT(h <= desc.fHeight);
586 #endif
587 const GrPixelConfig config = tex->config();
588 SkColorType ct;
589 SkAlphaType at = isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
590 if (!GrPixelConfig2ColorAndProfileType(config, &ct, nullptr)) {
591 ct = kUnknown_SkColorType;
592 }
593 return SkImageInfo::Make(w, h, ct, at);
594 }
595
596
GrWrapTextureInBitmap(GrTexture * src,int w,int h,bool isOpaque,SkBitmap * dst)597 void GrWrapTextureInBitmap(GrTexture* src, int w, int h, bool isOpaque, SkBitmap* dst) {
598 const SkImageInfo info = GrMakeInfoFromTexture(src, w, h, isOpaque);
599 dst->setInfo(info);
600 dst->setPixelRef(new SkGrPixelRef(info, src))->unref();
601 }
602
GrSkFilterQualityToGrFilterMode(SkFilterQuality paintFilterQuality,const SkMatrix & viewM,const SkMatrix & localM,bool * doBicubic)603 GrTextureParams::FilterMode GrSkFilterQualityToGrFilterMode(SkFilterQuality paintFilterQuality,
604 const SkMatrix& viewM,
605 const SkMatrix& localM,
606 bool* doBicubic) {
607 *doBicubic = false;
608 GrTextureParams::FilterMode textureFilterMode;
609 switch (paintFilterQuality) {
610 case kNone_SkFilterQuality:
611 textureFilterMode = GrTextureParams::kNone_FilterMode;
612 break;
613 case kLow_SkFilterQuality:
614 textureFilterMode = GrTextureParams::kBilerp_FilterMode;
615 break;
616 case kMedium_SkFilterQuality: {
617 SkMatrix matrix;
618 matrix.setConcat(viewM, localM);
619 if (matrix.getMinScale() < SK_Scalar1) {
620 textureFilterMode = GrTextureParams::kMipMap_FilterMode;
621 } else {
622 // Don't trigger MIP level generation unnecessarily.
623 textureFilterMode = GrTextureParams::kBilerp_FilterMode;
624 }
625 break;
626 }
627 case kHigh_SkFilterQuality: {
628 SkMatrix matrix;
629 matrix.setConcat(viewM, localM);
630 *doBicubic = GrBicubicEffect::ShouldUseBicubic(matrix, &textureFilterMode);
631 break;
632 }
633 default:
634 SkErrorInternals::SetError( kInvalidPaint_SkError,
635 "Sorry, I don't understand the filtering "
636 "mode you asked for. Falling back to "
637 "MIPMaps.");
638 textureFilterMode = GrTextureParams::kMipMap_FilterMode;
639 break;
640
641 }
642 return textureFilterMode;
643 }
644