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