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 "SkBitmap.h"
9 #include "SkCanvas.h"
10 #include "SkColorData.h"
11 #include "SkConvertPixels.h"
12 #include "SkData.h"
13 #include "SkImageInfoPriv.h"
14 #include "SkImageShader.h"
15 #include "SkHalf.h"
16 #include "SkMask.h"
17 #include "SkNx.h"
18 #include "SkPM4f.h"
19 #include "SkPixmapPriv.h"
20 #include "SkReadPixelsRec.h"
21 #include "SkSurface.h"
22 #include "SkTemplates.h"
23 #include "SkUnPreMultiply.h"
24 #include "SkUtils.h"
25 
26 /////////////////////////////////////////////////////////////////////////////////////////////////
27 
28 void SkPixmap::reset() {
29     fPixels = nullptr;
30     fRowBytes = 0;
31     fInfo = SkImageInfo::MakeUnknown();
32 }
33 
34 void SkPixmap::reset(const SkImageInfo& info, const void* addr, size_t rowBytes) {
35     if (addr) {
36         SkASSERT(info.validRowBytes(rowBytes));
37     }
38     fPixels = addr;
39     fRowBytes = rowBytes;
40     fInfo = info;
41 }
42 
43 bool SkPixmap::reset(const SkMask& src) {
44     if (SkMask::kA8_Format == src.fFormat) {
45         this->reset(SkImageInfo::MakeA8(src.fBounds.width(), src.fBounds.height()),
46                     src.fImage, src.fRowBytes);
47         return true;
48     }
49     this->reset();
50     return false;
51 }
52 
53 void SkPixmap::setColorSpace(sk_sp<SkColorSpace> cs) {
54     fInfo = fInfo.makeColorSpace(std::move(cs));
55 }
56 
57 bool SkPixmap::extractSubset(SkPixmap* result, const SkIRect& subset) const {
58     SkIRect srcRect, r;
59     srcRect.set(0, 0, this->width(), this->height());
60     if (!r.intersect(srcRect, subset)) {
61         return false;   // r is empty (i.e. no intersection)
62     }
63 
64     // If the upper left of the rectangle was outside the bounds of this SkBitmap, we should have
65     // exited above.
66     SkASSERT(static_cast<unsigned>(r.fLeft) < static_cast<unsigned>(this->width()));
67     SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
68 
69     const void* pixels = nullptr;
70     if (fPixels) {
71         const size_t bpp = fInfo.bytesPerPixel();
72         pixels = (const uint8_t*)fPixels + r.fTop * fRowBytes + r.fLeft * bpp;
73     }
74     result->reset(fInfo.makeWH(r.width(), r.height()), pixels, fRowBytes);
75     return true;
76 }
77 
78 bool SkPixmap::readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB, int x, int y,
79                           SkTransferFunctionBehavior behavior) const {
80     if (!SkImageInfoValidConversion(dstInfo, fInfo)) {
81         return false;
82     }
83 
84     SkReadPixelsRec rec(dstInfo, dstPixels, dstRB, x, y);
85     if (!rec.trim(fInfo.width(), fInfo.height())) {
86         return false;
87     }
88 
89     const void* srcPixels = this->addr(rec.fX, rec.fY);
90     const SkImageInfo srcInfo = fInfo.makeWH(rec.fInfo.width(), rec.fInfo.height());
91     SkConvertPixels(rec.fInfo, rec.fPixels, rec.fRowBytes, srcInfo, srcPixels, this->rowBytes(),
92                     nullptr, behavior);
93     return true;
94 }
95 
96 static uint16_t pack_8888_to_4444(unsigned a, unsigned r, unsigned g, unsigned b) {
97     unsigned pixel = (SkA32To4444(a) << SK_A4444_SHIFT) |
98     (SkR32To4444(r) << SK_R4444_SHIFT) |
99     (SkG32To4444(g) << SK_G4444_SHIFT) |
100     (SkB32To4444(b) << SK_B4444_SHIFT);
101     return SkToU16(pixel);
102 }
103 
104 bool SkPixmap::erase(SkColor color, const SkIRect& inArea) const {
105     if (nullptr == fPixels) {
106         return false;
107     }
108     SkIRect area;
109     if (!area.intersect(this->bounds(), inArea)) {
110         return false;
111     }
112 
113     U8CPU a = SkColorGetA(color);
114     U8CPU r = SkColorGetR(color);
115     U8CPU g = SkColorGetG(color);
116     U8CPU b = SkColorGetB(color);
117 
118     int height = area.height();
119     const int width = area.width();
120     const int rowBytes = this->rowBytes();
121 
122     if (color == 0
123           && width == this->rowBytesAsPixels()
124           && inArea == this->bounds()) {
125         // All formats represent SkColor(0) as byte 0.
126         memset(this->writable_addr(), 0, (int64_t)height * rowBytes);
127         return true;
128     }
129 
130     switch (this->colorType()) {
131         case kGray_8_SkColorType: {
132             if (255 != a) {
133                 r = SkMulDiv255Round(r, a);
134                 g = SkMulDiv255Round(g, a);
135                 b = SkMulDiv255Round(b, a);
136             }
137             int gray = SkComputeLuminance(r, g, b);
138             uint8_t* p = this->writable_addr8(area.fLeft, area.fTop);
139             while (--height >= 0) {
140                 memset(p, gray, width);
141                 p += rowBytes;
142             }
143             break;
144         }
145         case kAlpha_8_SkColorType: {
146             uint8_t* p = this->writable_addr8(area.fLeft, area.fTop);
147             while (--height >= 0) {
148                 memset(p, a, width);
149                 p += rowBytes;
150             }
151             break;
152         }
153         case kARGB_4444_SkColorType:
154         case kRGB_565_SkColorType: {
155             uint16_t* p = this->writable_addr16(area.fLeft, area.fTop);
156             uint16_t v;
157 
158             // make rgb premultiplied
159             if (255 != a) {
160                 r = SkMulDiv255Round(r, a);
161                 g = SkMulDiv255Round(g, a);
162                 b = SkMulDiv255Round(b, a);
163             }
164 
165             if (kARGB_4444_SkColorType == this->colorType()) {
166                 v = pack_8888_to_4444(a, r, g, b);
167             } else {
168                 v = SkPackRGB16(r >> (8 - SK_R16_BITS),
169                                 g >> (8 - SK_G16_BITS),
170                                 b >> (8 - SK_B16_BITS));
171             }
172             while (--height >= 0) {
173                 sk_memset16(p, v, width);
174                 p = (uint16_t*)((char*)p + rowBytes);
175             }
176             break;
177         }
178         case kBGRA_8888_SkColorType:
179         case kRGBA_8888_SkColorType: {
180             uint32_t* p = this->writable_addr32(area.fLeft, area.fTop);
181 
182             if (255 != a && kPremul_SkAlphaType == this->alphaType()) {
183                 r = SkMulDiv255Round(r, a);
184                 g = SkMulDiv255Round(g, a);
185                 b = SkMulDiv255Round(b, a);
186             }
187             uint32_t v = kRGBA_8888_SkColorType == this->colorType()
188                              ? SkPackARGB_as_RGBA(a, r, g, b)
189                              : SkPackARGB_as_BGRA(a, r, g, b);
190 
191             while (--height >= 0) {
192                 sk_memset32(p, v, width);
193                 p = (uint32_t*)((char*)p + rowBytes);
194             }
195             break;
196         }
197         case kRGBA_F16_SkColorType:
198             // The colorspace is unspecified, so assume linear just like getColor().
199             this->erase(SkColor4f{(1 / 255.0f) * r,
200                                   (1 / 255.0f) * g,
201                                   (1 / 255.0f) * b,
202                                   (1 / 255.0f) * a}, &area);
203             break;
204         default:
205             return false; // no change, so don't call notifyPixelsChanged()
206     }
207     return true;
208 }
209 
210 bool SkPixmap::erase(const SkColor4f& origColor, const SkIRect* subset) const {
211     SkPixmap pm;
212     if (subset) {
213         if (!this->extractSubset(&pm, *subset)) {
214             return false;
215         }
216     } else {
217         pm = *this;
218     }
219 
220     const SkColor4f color = origColor.pin();
221 
222     if (kRGBA_F16_SkColorType != pm.colorType()) {
223         return pm.erase(color.toSkColor());
224     }
225 
226     const uint64_t half4 = color.premul().toF16();
227     for (int y = 0; y < pm.height(); ++y) {
228         sk_memset64(pm.writable_addr64(0, y), half4, pm.width());
229     }
230     return true;
231 }
232 
233 bool SkPixmap::scalePixels(const SkPixmap& actualDst, SkFilterQuality quality) const {
234     // We may need to tweak how we interpret these just a little below, so we make copies.
235     SkPixmap src = *this,
236              dst = actualDst;
237 
238     // Can't do anthing with empty src or dst
239     if (src.width() <= 0 || src.height() <= 0 ||
240         dst.width() <= 0 || dst.height() <= 0) {
241         return false;
242     }
243 
244     // no scaling involved?
245     if (src.width() == dst.width() && src.height() == dst.height()) {
246         return src.readPixels(dst);
247     }
248 
249     // If src and dst are both unpremul, we'll fake them out to appear as if premul.
250     bool clampAsIfUnpremul = false;
251     if (src.alphaType() == kUnpremul_SkAlphaType &&
252         dst.alphaType() == kUnpremul_SkAlphaType) {
253         src.reset(src.info().makeAlphaType(kPremul_SkAlphaType), src.addr(), src.rowBytes());
254         dst.reset(dst.info().makeAlphaType(kPremul_SkAlphaType), dst.addr(), dst.rowBytes());
255 
256         // In turn, we'll need to tell the image shader to clamp to [0,1] instead
257         // of the usual [0,a] when using a bicubic scaling (kHigh_SkFilterQuality)
258         // or a gamut transformation.
259         clampAsIfUnpremul = true;
260     }
261 
262     SkBitmap bitmap;
263     if (!bitmap.installPixels(src)) {
264         return false;
265     }
266     bitmap.setImmutable();        // Don't copy when we create an image.
267     bitmap.setIsVolatile(true);   // Disable any caching.
268 
269     SkMatrix scale = SkMatrix::MakeRectToRect(SkRect::Make(src.bounds()),
270                                               SkRect::Make(dst.bounds()),
271                                               SkMatrix::kFill_ScaleToFit);
272 
273     // We'll create a shader to do this draw so we have control over the bicubic clamp.
274     sk_sp<SkShader> shader = SkImageShader::Make(SkImage::MakeFromBitmap(bitmap),
275                                                  SkShader::kClamp_TileMode,
276                                                  SkShader::kClamp_TileMode,
277                                                  &scale,
278                                                  clampAsIfUnpremul);
279 
280     sk_sp<SkSurface> surface = SkSurface::MakeRasterDirect(dst.info(),
281                                                            dst.writable_addr(),
282                                                            dst.rowBytes());
283     if (!shader || !surface) {
284         return false;
285     }
286 
287     SkPaint paint;
288     paint.setBlendMode(SkBlendMode::kSrc);
289     paint.setFilterQuality(quality);
290     paint.setShader(std::move(shader));
291     surface->getCanvas()->drawPaint(paint);
292     return true;
293 }
294 
295 //////////////////////////////////////////////////////////////////////////////////////////////////
296 
297 SkColor SkPixmap::getColor(int x, int y) const {
298     SkASSERT(this->addr());
299     SkASSERT((unsigned)x < (unsigned)this->width());
300     SkASSERT((unsigned)y < (unsigned)this->height());
301 
302     const bool needsUnpremul = (kPremul_SkAlphaType == fInfo.alphaType());
303     auto toColor = [needsUnpremul](uint32_t maybePremulColor) {
304         return needsUnpremul ? SkUnPreMultiply::PMColorToColor(maybePremulColor)
305                              : SkSwizzle_BGRA_to_PMColor(maybePremulColor);
306     };
307 
308     switch (this->colorType()) {
309         case kGray_8_SkColorType: {
310             uint8_t value = *this->addr8(x, y);
311             return SkColorSetRGB(value, value, value);
312         }
313         case kAlpha_8_SkColorType: {
314             return SkColorSetA(0, *this->addr8(x, y));
315         }
316         case kRGB_565_SkColorType: {
317             return SkPixel16ToColor(*this->addr16(x, y));
318         }
319         case kARGB_4444_SkColorType: {
320             uint16_t value = *this->addr16(x, y);
321             SkPMColor c = SkPixel4444ToPixel32(value);
322             return toColor(c);
323         }
324         case kBGRA_8888_SkColorType: {
325             uint32_t value = *this->addr32(x, y);
326             SkPMColor c = SkSwizzle_BGRA_to_PMColor(value);
327             return toColor(c);
328         }
329         case kRGBA_8888_SkColorType: {
330             uint32_t value = *this->addr32(x, y);
331             SkPMColor c = SkSwizzle_RGBA_to_PMColor(value);
332             return toColor(c);
333         }
334         case kRGBA_F16_SkColorType: {
335              const uint64_t* addr =
336                  (const uint64_t*)fPixels + y * (fRowBytes >> 3) + x;
337              Sk4f p4 = SkHalfToFloat_finite_ftz(*addr);
338              if (p4[3] && needsUnpremul) {
339                  float inva = 1 / p4[3];
340                  p4 = p4 * Sk4f(inva, inva, inva, 1);
341              }
342              SkColor c;
343              SkNx_cast<uint8_t>(p4 * Sk4f(255) + Sk4f(0.5f)).store(&c);
344              // p4 is RGBA, but we want BGRA, so we need to swap next
345              return SkSwizzle_RB(c);
346         }
347         default:
348             SkDEBUGFAIL("");
349             return SkColorSetARGB(0, 0, 0, 0);
350     }
351 }
352 
353 bool SkPixmap::computeIsOpaque() const {
354     const int height = this->height();
355     const int width = this->width();
356 
357     switch (this->colorType()) {
358         case kAlpha_8_SkColorType: {
359             unsigned a = 0xFF;
360             for (int y = 0; y < height; ++y) {
361                 const uint8_t* row = this->addr8(0, y);
362                 for (int x = 0; x < width; ++x) {
363                     a &= row[x];
364                 }
365                 if (0xFF != a) {
366                     return false;
367                 }
368             }
369             return true;
370         } break;
371         case kRGB_565_SkColorType:
372         case kGray_8_SkColorType:
373             return true;
374             break;
375         case kARGB_4444_SkColorType: {
376             unsigned c = 0xFFFF;
377             for (int y = 0; y < height; ++y) {
378                 const SkPMColor16* row = this->addr16(0, y);
379                 for (int x = 0; x < width; ++x) {
380                     c &= row[x];
381                 }
382                 if (0xF != SkGetPackedA4444(c)) {
383                     return false;
384                 }
385             }
386             return true;
387         } break;
388         case kBGRA_8888_SkColorType:
389         case kRGBA_8888_SkColorType: {
390             SkPMColor c = (SkPMColor)~0;
391             for (int y = 0; y < height; ++y) {
392                 const SkPMColor* row = this->addr32(0, y);
393                 for (int x = 0; x < width; ++x) {
394                     c &= row[x];
395                 }
396                 if (0xFF != SkGetPackedA32(c)) {
397                     return false;
398                 }
399             }
400             return true;
401         }
402         case kRGBA_F16_SkColorType: {
403             const SkHalf* row = (const SkHalf*)this->addr();
404             for (int y = 0; y < height; ++y) {
405                 for (int x = 0; x < width; ++x) {
406                     if (row[4 * x + 3] < SK_Half1) {
407                         return false;
408                     }
409                 }
410                 row += this->rowBytes() >> 1;
411             }
412             return true;
413         }
414         default:
415             break;
416     }
417     return false;
418 }
419 
420 //////////////////////////////////////////////////////////////////////////////////////////////////
421 
422 static bool draw_orientation(const SkPixmap& dst, const SkPixmap& src, unsigned flags) {
423     auto surf = SkSurface::MakeRasterDirect(dst.info(), dst.writable_addr(), dst.rowBytes());
424     if (!surf) {
425         return false;
426     }
427 
428     SkBitmap bm;
429     bm.installPixels(src);
430 
431     SkMatrix m;
432     m.setIdentity();
433 
434     SkScalar W = SkIntToScalar(src.width());
435     SkScalar H = SkIntToScalar(src.height());
436     if (flags & SkPixmapPriv::kSwapXY) {
437         SkMatrix s;
438         s.setAll(0, 1, 0, 1, 0, 0, 0, 0, 1);
439         m.postConcat(s);
440         SkTSwap(W, H);
441     }
442     if (flags & SkPixmapPriv::kMirrorX) {
443         m.postScale(-1, 1);
444         m.postTranslate(W, 0);
445     }
446     if (flags & SkPixmapPriv::kMirrorY) {
447         m.postScale(1, -1);
448         m.postTranslate(0, H);
449     }
450     SkPaint p;
451     p.setBlendMode(SkBlendMode::kSrc);
452     surf->getCanvas()->concat(m);
453     surf->getCanvas()->drawBitmap(bm, 0, 0, &p);
454     return true;
455 }
456 
457 bool SkPixmapPriv::Orient(const SkPixmap& dst, const SkPixmap& src, OrientFlags flags) {
458     SkASSERT((flags & ~(kMirrorX | kMirrorY | kSwapXY)) == 0);
459     if (src.colorType() != dst.colorType()) {
460         return false;
461     }
462     // note: we just ignore alphaType and colorSpace for this transformation
463 
464     int w = src.width();
465     int h = src.height();
466     if (flags & kSwapXY) {
467         SkTSwap(w, h);
468     }
469     if (dst.width() != w || dst.height() != h) {
470         return false;
471     }
472     if (w == 0 || h == 0) {
473         return true;
474     }
475 
476     // check for aliasing to self
477     if (src.addr() == dst.addr()) {
478         return flags == 0;
479     }
480     return draw_orientation(dst, src, flags);
481 }
482 
483 #define kMirrorX    SkPixmapPriv::kMirrorX
484 #define kMirrorY    SkPixmapPriv::kMirrorY
485 #define kSwapXY     SkPixmapPriv::kSwapXY
486 
487 static constexpr uint8_t gOrientationFlags[] = {
488     0,                              // kTopLeft_SkEncodedOrigin
489     kMirrorX,                       // kTopRight_SkEncodedOrigin
490     kMirrorX | kMirrorY,            // kBottomRight_SkEncodedOrigin
491                kMirrorY,            // kBottomLeft_SkEncodedOrigin
492                           kSwapXY,  // kLeftTop_SkEncodedOrigin
493     kMirrorX            | kSwapXY,  // kRightTop_SkEncodedOrigin
494     kMirrorX | kMirrorY | kSwapXY,  // kRightBottom_SkEncodedOrigin
495                kMirrorY | kSwapXY,  // kLeftBottom_SkEncodedOrigin
496 };
497 
498 SkPixmapPriv::OrientFlags SkPixmapPriv::OriginToOrient(SkEncodedOrigin o) {
499     unsigned io = static_cast<int>(o) - 1;
500     SkASSERT(io < SK_ARRAY_COUNT(gOrientationFlags));
501     return static_cast<SkPixmapPriv::OrientFlags>(gOrientationFlags[io]);
502 }
503 
504 bool SkPixmapPriv::ShouldSwapWidthHeight(SkEncodedOrigin o) {
505     return SkToBool(OriginToOrient(o) & kSwapXY);
506 }
507 
508 SkImageInfo SkPixmapPriv::SwapWidthHeight(const SkImageInfo& info) {
509     return info.makeWH(info.height(), info.width());
510 }
511 
512