reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 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 | |
Mike Klein | f447dee | 2016-11-29 16:37:12 -0500 | [diff] [blame] | 8 | #include "SkBitmapController.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 9 | #include "SkBitmapProcShader.h" |
| 10 | #include "SkBitmapProvider.h" |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 11 | #include "SkColorShader.h" |
| 12 | #include "SkColorTable.h" |
| 13 | #include "SkEmptyShader.h" |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 14 | #include "SkFixedAlloc.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 15 | #include "SkImage_Base.h" |
| 16 | #include "SkImageShader.h" |
Mike Klein | 46e66a2 | 2016-11-21 16:19:34 -0500 | [diff] [blame] | 17 | #include "SkImageShaderContext.h" |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 18 | #include "SkPM4fPriv.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 19 | #include "SkReadBuffer.h" |
| 20 | #include "SkWriteBuffer.h" |
| 21 | |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 22 | SkImageShader::SkImageShader(sk_sp<SkImage> img, TileMode tmx, TileMode tmy, const SkMatrix* matrix) |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 23 | : INHERITED(matrix) |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 24 | , fImage(std::move(img)) |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 25 | , fTileModeX(tmx) |
| 26 | , fTileModeY(tmy) |
| 27 | {} |
| 28 | |
reed | 60c9b58 | 2016-04-03 09:11:13 -0700 | [diff] [blame] | 29 | sk_sp<SkFlattenable> SkImageShader::CreateProc(SkReadBuffer& buffer) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 30 | const TileMode tx = (TileMode)buffer.readUInt(); |
| 31 | const TileMode ty = (TileMode)buffer.readUInt(); |
| 32 | SkMatrix matrix; |
| 33 | buffer.readMatrix(&matrix); |
reed | a9ca05c | 2016-08-11 03:55:15 -0700 | [diff] [blame] | 34 | sk_sp<SkImage> img = buffer.readImage(); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 35 | if (!img) { |
| 36 | return nullptr; |
| 37 | } |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 38 | return SkImageShader::Make(std::move(img), tx, ty, &matrix); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 39 | } |
| 40 | |
| 41 | void SkImageShader::flatten(SkWriteBuffer& buffer) const { |
| 42 | buffer.writeUInt(fTileModeX); |
| 43 | buffer.writeUInt(fTileModeY); |
| 44 | buffer.writeMatrix(this->getLocalMatrix()); |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 45 | buffer.writeImage(fImage.get()); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 46 | } |
| 47 | |
| 48 | bool SkImageShader::isOpaque() const { |
| 49 | return fImage->isOpaque(); |
| 50 | } |
| 51 | |
reed | 773ceda | 2016-03-03 18:18:25 -0800 | [diff] [blame] | 52 | size_t SkImageShader::onContextSize(const ContextRec& rec) const { |
fmalita | dc87a7d | 2016-10-17 06:09:26 -0700 | [diff] [blame] | 53 | return SkBitmapProcLegacyShader::ContextSize(rec, as_IB(fImage)->onImageInfo()); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 54 | } |
| 55 | |
| 56 | SkShader::Context* SkImageShader::onCreateContext(const ContextRec& rec, void* storage) const { |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 57 | return SkBitmapProcLegacyShader::MakeContext(*this, fTileModeX, fTileModeY, |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame^] | 58 | SkBitmapProvider(fImage.get(), rec.fDstColorSpace), |
Brian Osman | 7992da3 | 2016-11-18 11:28:24 -0500 | [diff] [blame] | 59 | rec, storage); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 60 | } |
| 61 | |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 62 | SkImage* SkImageShader::onIsAImage(SkMatrix* texM, TileMode xy[]) const { |
| 63 | if (texM) { |
| 64 | *texM = this->getLocalMatrix(); |
| 65 | } |
| 66 | if (xy) { |
| 67 | xy[0] = (TileMode)fTileModeX; |
| 68 | xy[1] = (TileMode)fTileModeY; |
| 69 | } |
| 70 | return const_cast<SkImage*>(fImage.get()); |
| 71 | } |
| 72 | |
Mike Reed | 627778d | 2016-09-28 17:13:38 -0400 | [diff] [blame] | 73 | #ifdef SK_SUPPORT_LEGACY_SHADER_ISABITMAP |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 74 | bool SkImageShader::onIsABitmap(SkBitmap* texture, SkMatrix* texM, TileMode xy[]) const { |
| 75 | const SkBitmap* bm = as_IB(fImage)->onPeekBitmap(); |
| 76 | if (!bm) { |
| 77 | return false; |
| 78 | } |
| 79 | |
| 80 | if (texture) { |
| 81 | *texture = *bm; |
| 82 | } |
| 83 | if (texM) { |
| 84 | *texM = this->getLocalMatrix(); |
| 85 | } |
| 86 | if (xy) { |
| 87 | xy[0] = (TileMode)fTileModeX; |
| 88 | xy[1] = (TileMode)fTileModeY; |
| 89 | } |
| 90 | return true; |
| 91 | } |
Mike Reed | 627778d | 2016-09-28 17:13:38 -0400 | [diff] [blame] | 92 | #endif |
reed | f1ac182 | 2016-08-01 11:24:14 -0700 | [diff] [blame] | 93 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 94 | static bool bitmap_is_too_big(int w, int h) { |
| 95 | // SkBitmapProcShader stores bitmap coordinates in a 16bit buffer, as it |
| 96 | // communicates between its matrix-proc and its sampler-proc. Until we can |
| 97 | // widen that, we have to reject bitmaps that are larger. |
| 98 | // |
| 99 | static const int kMaxSize = 65535; |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 100 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 101 | return w > kMaxSize || h > kMaxSize; |
| 102 | } |
| 103 | |
| 104 | // returns true and set color if the bitmap can be drawn as a single color |
| 105 | // (for efficiency) |
| 106 | static bool can_use_color_shader(const SkImage* image, SkColor* color) { |
| 107 | #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK |
| 108 | // HWUI does not support color shaders (see b/22390304) |
| 109 | return false; |
| 110 | #endif |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 111 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 112 | if (1 != image->width() || 1 != image->height()) { |
| 113 | return false; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 114 | } |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 115 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 116 | SkPixmap pmap; |
| 117 | if (!image->peekPixels(&pmap)) { |
| 118 | return false; |
| 119 | } |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 120 | |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 121 | switch (pmap.colorType()) { |
| 122 | case kN32_SkColorType: |
| 123 | *color = SkUnPreMultiply::PMColorToColor(*pmap.addr32(0, 0)); |
| 124 | return true; |
| 125 | case kRGB_565_SkColorType: |
| 126 | *color = SkPixel16ToColor(*pmap.addr16(0, 0)); |
| 127 | return true; |
| 128 | case kIndex_8_SkColorType: { |
| 129 | const SkColorTable& ctable = *pmap.ctable(); |
| 130 | *color = SkUnPreMultiply::PMColorToColor(ctable[*pmap.addr8(0, 0)]); |
| 131 | return true; |
| 132 | } |
| 133 | default: // just skip the other configs for now |
| 134 | break; |
| 135 | } |
| 136 | return false; |
| 137 | } |
| 138 | |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 139 | sk_sp<SkShader> SkImageShader::Make(sk_sp<SkImage> image, TileMode tx, TileMode ty, |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 140 | const SkMatrix* localMatrix, |
| 141 | SkTBlitterAllocator* allocator) { |
| 142 | SkShader* shader; |
| 143 | SkColor color; |
| 144 | if (!image || bitmap_is_too_big(image->width(), image->height())) { |
| 145 | if (nullptr == allocator) { |
| 146 | shader = new SkEmptyShader; |
| 147 | } else { |
| 148 | shader = allocator->createT<SkEmptyShader>(); |
| 149 | } |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 150 | } else if (can_use_color_shader(image.get(), &color)) { |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 151 | if (nullptr == allocator) { |
| 152 | shader = new SkColorShader(color); |
| 153 | } else { |
| 154 | shader = allocator->createT<SkColorShader>(color); |
| 155 | } |
| 156 | } else { |
| 157 | if (nullptr == allocator) { |
| 158 | shader = new SkImageShader(image, tx, ty, localMatrix); |
| 159 | } else { |
| 160 | shader = allocator->createT<SkImageShader>(image, tx, ty, localMatrix); |
| 161 | } |
| 162 | } |
| 163 | return sk_sp<SkShader>(shader); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 164 | } |
| 165 | |
| 166 | #ifndef SK_IGNORE_TO_STRING |
| 167 | void SkImageShader::toString(SkString* str) const { |
| 168 | const char* gTileModeName[SkShader::kTileModeCount] = { |
| 169 | "clamp", "repeat", "mirror" |
| 170 | }; |
| 171 | |
| 172 | str->appendf("ImageShader: ((%s %s) ", gTileModeName[fTileModeX], gTileModeName[fTileModeY]); |
| 173 | fImage->toString(str); |
| 174 | this->INHERITED::toString(str); |
| 175 | str->append(")"); |
| 176 | } |
| 177 | #endif |
| 178 | |
| 179 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 180 | |
| 181 | #if SK_SUPPORT_GPU |
| 182 | |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 183 | #include "SkGr.h" |
bsalomon | f276ac5 | 2015-10-09 13:36:42 -0700 | [diff] [blame] | 184 | #include "SkGrPriv.h" |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 185 | #include "effects/GrSimpleTextureEffect.h" |
| 186 | #include "effects/GrBicubicEffect.h" |
| 187 | #include "effects/GrSimpleTextureEffect.h" |
| 188 | |
brianosman | 839345d | 2016-07-22 11:04:53 -0700 | [diff] [blame] | 189 | sk_sp<GrFragmentProcessor> SkImageShader::asFragmentProcessor(const AsFPArgs& args) const { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 190 | SkMatrix matrix; |
| 191 | matrix.setIDiv(fImage->width(), fImage->height()); |
| 192 | |
| 193 | SkMatrix lmInverse; |
| 194 | if (!this->getLocalMatrix().invert(&lmInverse)) { |
| 195 | return nullptr; |
| 196 | } |
brianosman | 839345d | 2016-07-22 11:04:53 -0700 | [diff] [blame] | 197 | if (args.fLocalMatrix) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 198 | SkMatrix inv; |
brianosman | 839345d | 2016-07-22 11:04:53 -0700 | [diff] [blame] | 199 | if (!args.fLocalMatrix->invert(&inv)) { |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 200 | return nullptr; |
| 201 | } |
| 202 | lmInverse.postConcat(inv); |
| 203 | } |
| 204 | matrix.preConcat(lmInverse); |
| 205 | |
| 206 | SkShader::TileMode tm[] = { fTileModeX, fTileModeY }; |
| 207 | |
| 208 | // Must set wrap and filter on the sampler before requesting a texture. In two places below |
| 209 | // we check the matrix scale factors to determine how to interpret the filter quality setting. |
| 210 | // This completely ignores the complexity of the drawVertices case where explicit local coords |
| 211 | // are provided by the caller. |
| 212 | bool doBicubic; |
Brian Salomon | 514baff | 2016-11-17 15:17:07 -0500 | [diff] [blame] | 213 | GrSamplerParams::FilterMode textureFilterMode = |
brianosman | 839345d | 2016-07-22 11:04:53 -0700 | [diff] [blame] | 214 | GrSkFilterQualityToGrFilterMode(args.fFilterQuality, *args.fViewMatrix, this->getLocalMatrix(), |
| 215 | &doBicubic); |
Brian Salomon | 514baff | 2016-11-17 15:17:07 -0500 | [diff] [blame] | 216 | GrSamplerParams params(tm, textureFilterMode); |
Brian Osman | 7992da3 | 2016-11-18 11:28:24 -0500 | [diff] [blame] | 217 | sk_sp<SkColorSpace> texColorSpace; |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame^] | 218 | sk_sp<GrTexture> texture(as_IB(fImage)->asTextureRef(args.fContext, params, args.fDstColorSpace, |
Brian Osman | 7992da3 | 2016-11-18 11:28:24 -0500 | [diff] [blame] | 219 | &texColorSpace)); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 220 | if (!texture) { |
| 221 | return nullptr; |
| 222 | } |
| 223 | |
Brian Osman | 7992da3 | 2016-11-18 11:28:24 -0500 | [diff] [blame] | 224 | sk_sp<GrColorSpaceXform> colorSpaceXform = GrColorSpaceXform::Make(texColorSpace.get(), |
brianosman | 5192475 | 2016-09-12 08:50:19 -0700 | [diff] [blame] | 225 | args.fDstColorSpace); |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 226 | sk_sp<GrFragmentProcessor> inner; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 227 | if (doBicubic) { |
Hal Canary | 67b39de | 2016-11-07 11:47:44 -0500 | [diff] [blame] | 228 | inner = GrBicubicEffect::Make(texture.get(), std::move(colorSpaceXform), matrix, tm); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 229 | } else { |
Hal Canary | 67b39de | 2016-11-07 11:47:44 -0500 | [diff] [blame] | 230 | inner = GrSimpleTextureEffect::Make(texture.get(), std::move(colorSpaceXform), |
| 231 | matrix, params); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 232 | } |
| 233 | |
| 234 | if (GrPixelConfigIsAlphaOnly(texture->config())) { |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 235 | return inner; |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 236 | } |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 237 | return sk_sp<GrFragmentProcessor>(GrFragmentProcessor::MulOutputByInputAlpha(std::move(inner))); |
reed | 856e9d9 | 2015-09-30 12:21:45 -0700 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | #endif |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 241 | |
| 242 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 243 | #include "SkImagePriv.h" |
| 244 | |
| 245 | sk_sp<SkShader> SkMakeBitmapShader(const SkBitmap& src, SkShader::TileMode tmx, |
| 246 | SkShader::TileMode tmy, const SkMatrix* localMatrix, |
reed | 1ec04d9 | 2016-08-05 12:07:41 -0700 | [diff] [blame] | 247 | SkCopyPixelsMode cpm, SkTBlitterAllocator* allocator) { |
| 248 | // Until we learn otherwise, it seems that any caller that is passing an allocator must be |
| 249 | // assuming that the returned shader will have a stack-frame lifetime, so we assert that |
| 250 | // they are also asking for kNever_SkCopyPixelsMode. If that proves otherwise, we can remove |
| 251 | // or modify this assert. |
| 252 | SkASSERT(!allocator || (kNever_SkCopyPixelsMode == cpm)); |
| 253 | |
reed | 6b2d7ac | 2016-08-11 06:42:26 -0700 | [diff] [blame] | 254 | return SkImageShader::Make(SkMakeImageFromRasterBitmap(src, cpm, allocator), |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 255 | tmx, tmy, localMatrix, allocator); |
| 256 | } |
| 257 | |
| 258 | static sk_sp<SkFlattenable> SkBitmapProcShader_CreateProc(SkReadBuffer& buffer) { |
| 259 | SkMatrix lm; |
| 260 | buffer.readMatrix(&lm); |
reed | a9ca05c | 2016-08-11 03:55:15 -0700 | [diff] [blame] | 261 | sk_sp<SkImage> image = buffer.readBitmapAsImage(); |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 262 | SkShader::TileMode mx = (SkShader::TileMode)buffer.readUInt(); |
| 263 | SkShader::TileMode my = (SkShader::TileMode)buffer.readUInt(); |
reed | a9ca05c | 2016-08-11 03:55:15 -0700 | [diff] [blame] | 264 | return image ? image->makeShader(mx, my, &lm) : nullptr; |
reed | 320a40d | 2016-08-02 06:12:06 -0700 | [diff] [blame] | 265 | } |
| 266 | |
| 267 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkShader) |
| 268 | SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkImageShader) |
| 269 | SkFlattenable::Register("SkBitmapProcShader", SkBitmapProcShader_CreateProc, kSkShader_Type); |
| 270 | SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
| 271 | |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 272 | |
| 273 | bool SkImageShader::onAppendStages(SkRasterPipeline* p, SkColorSpace* dst, SkFallbackAlloc* scratch, |
Mike Klein | 7a14734d | 2016-11-29 15:33:39 -0500 | [diff] [blame] | 274 | const SkMatrix& ctm, const SkPaint& paint) const { |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 275 | auto matrix = SkMatrix::Concat(ctm, this->getLocalMatrix()); |
| 276 | if (!matrix.invert(&matrix)) { |
| 277 | return false; |
| 278 | } |
Mike Klein | 7a14734d | 2016-11-29 15:33:39 -0500 | [diff] [blame] | 279 | auto quality = paint.getFilterQuality(); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 280 | |
Brian Osman | 61624f0 | 2016-12-09 14:51:59 -0500 | [diff] [blame^] | 281 | SkBitmapProvider provider(fImage.get(), dst); |
Brian Osman | 13bf622 | 2016-12-06 10:34:51 -0500 | [diff] [blame] | 282 | SkDefaultBitmapController controller; |
Mike Klein | f447dee | 2016-11-29 16:37:12 -0500 | [diff] [blame] | 283 | std::unique_ptr<SkBitmapController::State> state { |
| 284 | controller.requestBitmap(provider, matrix, quality) |
| 285 | }; |
| 286 | if (!state) { |
| 287 | return false; |
| 288 | } |
| 289 | |
| 290 | const SkPixmap& pm = state->pixmap(); |
| 291 | matrix = state->invMatrix(); |
| 292 | quality = state->quality(); |
| 293 | auto info = pm.info(); |
| 294 | |
Mike Klein | 7776029 | 2016-11-17 14:04:22 -0500 | [diff] [blame] | 295 | // When the matrix is just an integer translate, bilerp == nearest neighbor. |
| 296 | if (matrix.getType() <= SkMatrix::kTranslate_Mask && |
| 297 | matrix.getTranslateX() == (int)matrix.getTranslateX() && |
| 298 | matrix.getTranslateY() == (int)matrix.getTranslateY()) { |
| 299 | quality = kNone_SkFilterQuality; |
| 300 | } |
| 301 | |
Mike Klein | bf178a7 | 2016-11-17 15:56:24 -0500 | [diff] [blame] | 302 | // See skia:4649 and the GM image_scale_aligned. |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 303 | if (quality == kNone_SkFilterQuality) { |
| 304 | if (matrix.getScaleX() >= 0) { |
| 305 | matrix.setTranslateX(nextafterf(matrix.getTranslateX(), |
| 306 | floorf(matrix.getTranslateX()))); |
| 307 | } |
| 308 | if (matrix.getScaleY() >= 0) { |
| 309 | matrix.setTranslateY(nextafterf(matrix.getTranslateY(), |
| 310 | floorf(matrix.getTranslateY()))); |
| 311 | } |
| 312 | } |
| 313 | |
Mike Klein | 46e66a2 | 2016-11-21 16:19:34 -0500 | [diff] [blame] | 314 | auto ctx = scratch->make<SkImageShaderContext>(); |
Mike Klein | f447dee | 2016-11-29 16:37:12 -0500 | [diff] [blame] | 315 | ctx->state = std::move(state); // Extend lifetime to match the pipeline's. |
Mike Klein | 7a14734d | 2016-11-29 15:33:39 -0500 | [diff] [blame] | 316 | ctx->pixels = pm.addr(); |
| 317 | ctx->ctable = pm.ctable(); |
| 318 | ctx->color4f = SkColor4f_from_SkColor(paint.getColor(), dst); |
| 319 | ctx->stride = pm.rowBytesAsPixels(); |
| 320 | ctx->width = pm.width(); |
| 321 | ctx->height = pm.height(); |
Mike Klein | c01e7df | 2016-11-17 16:27:10 -0500 | [diff] [blame] | 322 | if (matrix.asAffine(ctx->matrix)) { |
| 323 | p->append(SkRasterPipeline::matrix_2x3, ctx->matrix); |
| 324 | } else { |
| 325 | matrix.get9(ctx->matrix); |
| 326 | p->append(SkRasterPipeline::matrix_perspective, ctx->matrix); |
| 327 | } |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 328 | |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 329 | auto append_tiling_and_gather = [&] { |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 330 | switch (fTileModeX) { |
| 331 | case kClamp_TileMode: p->append(SkRasterPipeline::clamp_x, &ctx->width); break; |
| 332 | case kMirror_TileMode: p->append(SkRasterPipeline::mirror_x, &ctx->width); break; |
| 333 | case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_x, &ctx->width); break; |
| 334 | } |
| 335 | switch (fTileModeY) { |
| 336 | case kClamp_TileMode: p->append(SkRasterPipeline::clamp_y, &ctx->height); break; |
| 337 | case kMirror_TileMode: p->append(SkRasterPipeline::mirror_y, &ctx->height); break; |
| 338 | case kRepeat_TileMode: p->append(SkRasterPipeline::repeat_y, &ctx->height); break; |
| 339 | } |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 340 | switch (info.colorType()) { |
Mike Klein | 7a14734d | 2016-11-29 15:33:39 -0500 | [diff] [blame] | 341 | case kAlpha_8_SkColorType: p->append(SkRasterPipeline::gather_a8, ctx); break; |
Mike Klein | f7657e9 | 2016-11-29 12:57:22 -0500 | [diff] [blame] | 342 | case kIndex_8_SkColorType: p->append(SkRasterPipeline::gather_i8, ctx); break; |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 343 | case kGray_8_SkColorType: p->append(SkRasterPipeline::gather_g8, ctx); break; |
| 344 | case kRGB_565_SkColorType: p->append(SkRasterPipeline::gather_565, ctx); break; |
| 345 | case kARGB_4444_SkColorType: p->append(SkRasterPipeline::gather_4444, ctx); break; |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 346 | case kRGBA_8888_SkColorType: |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 347 | case kBGRA_8888_SkColorType: p->append(SkRasterPipeline::gather_8888, ctx); break; |
| 348 | case kRGBA_F16_SkColorType: p->append(SkRasterPipeline::gather_f16, ctx); break; |
| 349 | default: SkASSERT(false); |
| 350 | } |
| 351 | if (info.gammaCloseToSRGB() && dst != nullptr) { |
Mike Klein | 729b582 | 2016-11-28 18:23:23 -0500 | [diff] [blame] | 352 | p->append(SkRasterPipeline::from_srgb); |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 353 | } |
| 354 | }; |
| 355 | |
Mike Klein | 886cf53 | 2016-12-06 11:31:25 -0500 | [diff] [blame] | 356 | auto sample = [&](SkRasterPipeline::StockStage sampler) { |
| 357 | p->append(sampler, ctx); |
| 358 | append_tiling_and_gather(); |
| 359 | p->append(SkRasterPipeline::accumulate, ctx); |
| 360 | }; |
| 361 | |
Mike Klein | f7f883b | 2016-11-21 15:09:45 -0500 | [diff] [blame] | 362 | if (quality == kNone_SkFilterQuality) { |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 363 | append_tiling_and_gather(); |
Mike Klein | 46e66a2 | 2016-11-21 16:19:34 -0500 | [diff] [blame] | 364 | } else { |
Mike Klein | 886cf53 | 2016-12-06 11:31:25 -0500 | [diff] [blame] | 365 | p->append(SkRasterPipeline::save_xy, ctx); |
| 366 | sample(SkRasterPipeline::bilinear_nn); |
| 367 | sample(SkRasterPipeline::bilinear_np); |
| 368 | sample(SkRasterPipeline::bilinear_pn); |
| 369 | sample(SkRasterPipeline::bilinear_pp); |
Mike Klein | b04c352 | 2016-11-28 11:55:58 -0500 | [diff] [blame] | 370 | p->append(SkRasterPipeline::move_dst_src); |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 371 | } |
| 372 | |
Mike Klein | f7657e9 | 2016-11-29 12:57:22 -0500 | [diff] [blame] | 373 | auto effective_color_type = [](SkColorType ct) { |
| 374 | return ct == kIndex_8_SkColorType ? kN32_SkColorType : ct; |
| 375 | }; |
| 376 | |
| 377 | if (effective_color_type(info.colorType()) == kBGRA_8888_SkColorType) { |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 378 | p->append(SkRasterPipeline::swap_rb); |
| 379 | } |
Mike Klein | 7a14734d | 2016-11-29 15:33:39 -0500 | [diff] [blame] | 380 | if (info.colorType() == kAlpha_8_SkColorType) { |
| 381 | p->append(SkRasterPipeline::set_rgb, &ctx->color4f); |
| 382 | } |
| 383 | if (info.colorType() == kAlpha_8_SkColorType || info.alphaType() == kUnpremul_SkAlphaType) { |
Mike Klein | 06a65e2 | 2016-11-17 12:39:09 -0500 | [diff] [blame] | 384 | p->append(SkRasterPipeline::premul); |
| 385 | } |
| 386 | return append_gamut_transform(p, scratch, info.colorSpace(), dst); |
| 387 | } |