src/effects/SkImageSource.cpp

   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 "SkImageSource.h"
   9
  10 #include "SkCanvas.h"
  11 #include "SkImage.h"
  12 #include "SkReadBuffer.h"
  13 #include "SkSpecialImage.h"
  14 #include "SkSpecialSurface.h"
  15 #include "SkWriteBuffer.h"
  16 #include "SkString.h"
  17
  18 sk_sp<SkImageFilter> SkImageSource::Make(sk_sp<SkImage> image) {
  19     if (!image) {
  20         return nullptr;
  21     }
  22
  23     return sk_sp<SkImageFilter>(new SkImageSource(std::move(image)));
  24 }
  25
  26 sk_sp<SkImageFilter> SkImageSource::Make(sk_sp<SkImage> image,
  27                                          const SkRect& srcRect,
  28                                          const SkRect& dstRect,
  29                                          SkFilterQuality filterQuality) {
  30     if (!image) {
  31         return nullptr;
  32     }
  33
  34     return sk_sp<SkImageFilter>(new SkImageSource(std::move(image),
  35                                                   srcRect, dstRect,
  36                                                   filterQuality));
  37 }
  38
  39 SkImageSource::SkImageSource(sk_sp<SkImage> image)
  40     : INHERITED(nullptr, 0, nullptr)
  41     , fImage(std::move(image))
  42     , fSrcRect(SkRect::MakeIWH(fImage->width(), fImage->height()))
  43     , fDstRect(fSrcRect)
  44     , fFilterQuality(kHigh_SkFilterQuality) {
  45 }
  46
  47 SkImageSource::SkImageSource(sk_sp<SkImage> image,
  48                              const SkRect& srcRect,
  49                              const SkRect& dstRect,
  50                              SkFilterQuality filterQuality)
  51     : INHERITED(nullptr, 0, nullptr)
  52     , fImage(std::move(image))
  53     , fSrcRect(srcRect)
  54     , fDstRect(dstRect)
  55     , fFilterQuality(filterQuality) {
  56 }
  57
  58 sk_sp<SkFlattenable> SkImageSource::CreateProc(SkReadBuffer& buffer) {
  59     SkFilterQuality filterQuality = (SkFilterQuality)buffer.readInt();
  60
  61     SkRect src, dst;
  62     buffer.readRect(&src);
  63     buffer.readRect(&dst);
  64
  65     sk_sp<SkImage> image(buffer.readImage());
  66     if (!image) {
  67         return nullptr;
  68     }
  69
  70     return SkImageSource::Make(std::move(image), src, dst, filterQuality);
  71 }
  72
  73 void SkImageSource::flatten(SkWriteBuffer& buffer) const {
  74     buffer.writeInt(fFilterQuality);
  75     buffer.writeRect(fSrcRect);
  76     buffer.writeRect(fDstRect);
  77     buffer.writeImage(fImage.get());
  78 }
  79
  80 sk_sp<SkSpecialImage> SkImageSource::onFilterImage(SkSpecialImage* source, const Context& ctx,
  81                                                    SkIPoint* offset) const {
  82     SkRect dstRect;
  83     ctx.ctm().mapRect(&dstRect, fDstRect);
  84
  85     SkRect bounds = SkRect::MakeIWH(fImage->width(), fImage->height());
  86     if (fSrcRect == bounds && dstRect == bounds) {
  87         // No regions cropped out or resized; return entire image.
  88         offset->fX = offset->fY = 0;
  89         return SkSpecialImage::MakeFromImage(SkIRect::MakeWH(fImage->width(), fImage->height()),
  90                                              fImage, ctx.outputProperties().colorSpace(),
  91                                              &source->props());
  92     }
  93
  94     const SkIRect dstIRect = dstRect.roundOut();
  95
  96     sk_sp<SkSpecialSurface> surf(source->makeSurface(ctx.outputProperties(), dstIRect.size()));
  97     if (!surf) {
  98         return nullptr;
  99     }
 100
 101     SkCanvas* canvas = surf->getCanvas();
 102     SkASSERT(canvas);
 103
 104     // TODO: it seems like this clear shouldn't be necessary (see skbug.com/5075)
 105     canvas->clear(0x0);
 106
 107     SkPaint paint;
 108
 109     // Subtract off the integer component of the translation (will be applied in offset, below).
 110     dstRect.offset(-SkIntToScalar(dstIRect.fLeft), -SkIntToScalar(dstIRect.fTop));
 111     paint.setBlendMode(SkBlendMode::kSrc);
 112     // FIXME: this probably shouldn't be necessary, but drawImageRect asserts
 113     // None filtering when it's translate-only
 114     paint.setFilterQuality(
 115         fSrcRect.width() == dstRect.width() && fSrcRect.height() == dstRect.height() ?
 116                kNone_SkFilterQuality : fFilterQuality);
 117     canvas->drawImageRect(fImage.get(), fSrcRect, dstRect, &paint,
 118                           SkCanvas::kStrict_SrcRectConstraint);
 119
 120     offset->fX = dstIRect.fLeft;
 121     offset->fY = dstIRect.fTop;
 122     return surf->makeImageSnapshot();
 123 }
 124
 125 SkRect SkImageSource::computeFastBounds(const SkRect& src) const {
 126     return fDstRect;
 127 }
 128
 129 #ifndef SK_IGNORE_TO_STRING
 130 void SkImageSource::toString(SkString* str) const {
 131     str->appendf("SkImageSource: (");
 132     str->appendf("src: (%f,%f,%f,%f) dst: (%f,%f,%f,%f) ",
 133                  fSrcRect.fLeft, fSrcRect.fTop, fSrcRect.fRight, fSrcRect.fBottom,
 134                  fDstRect.fLeft, fDstRect.fTop, fDstRect.fRight, fDstRect.fBottom);
 135     str->appendf("image: (%d,%d)",
 136                  fImage->width(), fImage->height());
 137     str->append(")");
 138 }
 139 #endif