text: /*
   * Copyright 2013 Google Inc.
   *
   * Use of this source code is governed by a BSD-style license that can be
   * found in the LICENSE file.
   */
  
  #include "SkBitmapDevice.h"
  #include "SkDraw.h"
  #include "SkGlyphRun.h"
  #include "SkImageFilter.h"
  #include "SkImageFilterCache.h"
  #include "SkMakeUnique.h"
  #include "SkMatrix.h"
  #include "SkPaint.h"
  #include "SkPath.h"
  #include "SkPixmap.h"
  #include "SkRasterClip.h"
  #include "SkRasterHandleAllocator.h"
  #include "SkShader.h"
  #include "SkSpecialImage.h"
  #include "SkStrikeCache.h"
  #include "SkSurface.h"
  #include "SkTLazy.h"
  #include "SkVertices.h"
  
  struct Bounder {
      SkRect  fBounds;
      bool    fHasBounds;
  
      Bounder(const SkRect& r, const SkPaint& paint) {
          if ((fHasBounds = paint.canComputeFastBounds())) {
              fBounds = paint.computeFastBounds(r, &fBounds);
          }
      }
  
      bool hasBounds() const { return fHasBounds; }
      const SkRect* bounds() const { return fHasBounds ? &fBounds : nullptr; }
      operator const SkRect* () const { return this->bounds(); }
  };
  
  class SkDrawTiler {
      enum {
          // 8K is 1 too big, since 8K << supersample == 32768 which is too big for SkFixed
          kMaxDim = 8192 - 1
      };
  
      SkBitmapDevice* fDevice;
      SkPixmap        fRootPixmap;
      SkIRect         fSrcBounds;
  
      // Used for tiling and non-tiling
      SkDraw          fDraw;
  
      // fCurr... are only used if fNeedTiling
      SkMatrix        fTileMatrix;
      SkRasterClip    fTileRC;
      SkIPoint        fOrigin;
  
      bool            fDone, fNeedsTiling;
  
  public:
      static bool NeedsTiling(SkBitmapDevice* dev) {
          return dev->width() > kMaxDim || dev->height() > kMaxDim;
      }
  
      SkDrawTiler(SkBitmapDevice* dev, const SkRect* bounds) : fDevice(dev) {
          fDone = false;
  
          // we need fDst to be set, and if we're actually drawing, to dirty the genID
          if (!dev->accessPixels(&fRootPixmap)) {
              // NoDrawDevice uses us (why?) so we have to catch this case w/ no pixels
              fRootPixmap.reset(dev->imageInfo(), nullptr, 0);
          }
  
          // do a quick check, so we don't even have to process "bounds" if there is no need
          const SkIRect clipR = dev->fRCStack.rc().getBounds();
          fNeedsTiling = clipR.right() > kMaxDim || clipR.bottom() > kMaxDim;
          if (fNeedsTiling) {
              if (bounds) {
                  // Make sure we round first, and then intersect. We can't rely on promoting the
                  // clipR to floats (and then intersecting with devBounds) since promoting
                  // int --> float can make the float larger than the int.
                  // rounding(out) first runs the risk of clamping if the float is larger an intmax
                  // but our roundOut() is saturating, which is fine for this use case
                  //
                  // e.g. the older version of this code did this:
                  //    devBounds = mapRect(bounds);
                  //    if (devBounds.intersect(SkRect::Make(clipR))) {
                  //        fSrcBounds = devBounds.roundOut();
                  // The problem being that the promotion of clipR to SkRect was unreliable
                  //
                  fSrcBounds = dev->ctm().mapRect(*bounds).roundOut();
                  if (fSrcBounds.intersect(clipR)) {
                      // Check again, now that we have computed srcbounds.
                      fNeedsTiling = fSrcBounds.right() > kMaxDim || fSrcBounds.bottom() > kMaxDim;
                  } else {
                      fNeedsTiling = false;
                      fDone = true;
                  }
              } else {
                  fSrcBounds = clipR;
              }
          }
  
          if (fNeedsTiling) {
              // fDraw.fDst is reset each time in setupTileDraw()
              fDraw.fMatrix = &fTileMatrix;
              fDraw.fRC = &fTileRC;
              // we'll step/increase it before using it
              fOrigin.set(fSrcBounds.fLeft - kMaxDim, fSrcBounds.fTop);
          } else {
              // don't reference fSrcBounds, as it may not have been set
              fDraw.fDst = fRootPixmap;
              fDraw.fMatrix = &dev->ctm();
              fDraw.fRC = &dev->fRCStack.rc();
              fOrigin.set(0, 0);
  
              fDraw.fCoverage = dev->accessCoverage();
          }
      }
  
      bool needsTiling() const { return fNeedsTiling; }
  
      const SkDraw* next() {
          if (fDone) {
              return nullptr;
          }
          if (fNeedsTiling) {
              do {
                  this->stepAndSetupTileDraw();  // might set the clip to empty and fDone to true
              } while (!fDone && fTileRC.isEmpty());
              // if we exit the loop and we're still empty, we're (past) done
              if (fTileRC.isEmpty()) {
                  SkASSERT(fDone);
                  return nullptr;
              }
              SkASSERT(!fTileRC.isEmpty());
          } else {
              fDone = true;   // only draw untiled once
          }
          return &fDraw;
      }
  
  private:
      void stepAndSetupTileDraw() {
          SkASSERT(!fDone);
          SkASSERT(fNeedsTiling);
  
          // We do fRootPixmap.width() - kMaxDim instead of fOrigin.fX + kMaxDim to avoid overflow.
          if (fOrigin.fX >= fSrcBounds.fRight - kMaxDim) {    // too far
              fOrigin.fX = fSrcBounds.fLeft;
              fOrigin.fY += kMaxDim;
          } else {
              fOrigin.fX += kMaxDim;
          }
          // fDone = next origin will be invalid.
          fDone = fOrigin.fX >= fSrcBounds.fRight - kMaxDim &&
                  fOrigin.fY >= fSrcBounds.fBottom - kMaxDim;
  
          SkIRect bounds = SkIRect::MakeXYWH(fOrigin.x(), fOrigin.y(), kMaxDim, kMaxDim);
          SkASSERT(!bounds.isEmpty());
          bool success = fRootPixmap.extractSubset(&fDraw.fDst, bounds);
          SkASSERT_RELEASE(success);
          // now don't use bounds, since fDst has the clipped dimensions.
  
          fTileMatrix = fDevice->ctm();
          fTileMatrix.postTranslate(SkIntToScalar(-fOrigin.x()), SkIntToScalar(-fOrigin.y()));
          fDevice->fRCStack.rc().translate(-fOrigin.x(), -fOrigin.y(), &fTileRC);
          fTileRC.op(SkIRect::MakeWH(fDraw.fDst.width(), fDraw.fDst.height()),
                     SkRegion::kIntersect_Op);
      }
  };
  
  // Passing a bounds allows the tiler to only visit the dst-tiles that might intersect the
  // drawing. If null is passed, the tiler has to visit everywhere. The bounds is expected to be
  // in local coordinates, as the tiler itself will transform that into device coordinates.
  //
  #define LOOP_TILER(code, boundsPtr)                         \
      SkDrawTiler priv_tiler(this, boundsPtr);                \
      while (const SkDraw* priv_draw = priv_tiler.next()) {   \
          priv_draw->code;                                    \
      }
  
  // Helper to create an SkDraw from a device
  class SkBitmapDevice::BDDraw : public SkDraw {
  public:
      BDDraw(SkBitmapDevice* dev) {
          // we need fDst to be set, and if we're actually drawing, to dirty the genID
          if (!dev->accessPixels(&fDst)) {
              // NoDrawDevice uses us (why?) so we have to catch this case w/ no pixels
              fDst.reset(dev->imageInfo(), nullptr, 0);
          }
          fMatrix = &dev->ctm();
          fRC = &dev->fRCStack.rc();
          fCoverage = dev->accessCoverage();
      }
  };
  
  static bool valid_for_bitmap_device(const SkImageInfo& info,
                                      SkAlphaType* newAlphaType) {
      if (info.width() < 0 || info.height() < 0 || kUnknown_SkColorType == info.colorType()) {
          return false;
      }
  
      if (newAlphaType) {
          *newAlphaType = SkColorTypeIsAlwaysOpaque(info.colorType()) ? kOpaque_SkAlphaType
                                                                      : info.alphaType();
      }
  
      return true;
  }
  
  SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap)
          : INHERITED(bitmap.info(), SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType))
          , fBitmap(bitmap)
          , fRCStack(bitmap.width(), bitmap.height())
          , fGlyphPainter(this->surfaceProps(),
                          bitmap.colorType(),
                          bitmap.colorSpace(),
                          SkStrikeCache::GlobalStrikeCache()) {
      SkASSERT(valid_for_bitmap_device(bitmap.info(), nullptr));
  }
  
  SkBitmapDevice* SkBitmapDevice::Create(const SkImageInfo& info) {
      return Create(info, SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType));
  }
  
  SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap, const SkSurfaceProps& surfaceProps,
                                 SkRasterHandleAllocator::Handle hndl, const SkBitmap* coverage)
          : INHERITED(bitmap.info(), surfaceProps)
          , fBitmap(bitmap)
          , fRasterHandle(hndl)
          , fRCStack(bitmap.width(), bitmap.height())
          , fGlyphPainter(this->surfaceProps(),
                          bitmap.colorType(),
                          bitmap.colorSpace(),
                          SkStrikeCache::GlobalStrikeCache()) {
      SkASSERT(valid_for_bitmap_device(bitmap.info(), nullptr));
  
      if (coverage) {
          SkASSERT(coverage->width() == bitmap.width());
          SkASSERT(coverage->height() == bitmap.height());
          fCoverage = skstd::make_unique<SkBitmap>(*coverage);
      }
  }
  
  SkBitmapDevice* SkBitmapDevice::Create(const SkImageInfo& origInfo,
                                         const SkSurfaceProps& surfaceProps,
                                         bool trackCoverage,
                                         SkRasterHandleAllocator* allocator) {
      SkAlphaType newAT = origInfo.alphaType();
      if (!valid_for_bitmap_device(origInfo, &newAT)) {
          return nullptr;
      }
  
      SkRasterHandleAllocator::Handle hndl = nullptr;
      const SkImageInfo info = origInfo.makeAlphaType(newAT);
      SkBitmap bitmap;
  
      if (kUnknown_SkColorType == info.colorType()) {
          if (!bitmap.setInfo(info)) {
              return nullptr;
          }
      } else if (allocator) {
          hndl = allocator->allocBitmap(info, &bitmap);
          if (!hndl) {
              return nullptr;
          }
      } else if (info.isOpaque()) {
          // If this bitmap is opaque, we don't have any sensible default color,
          // so we just return uninitialized pixels.
          if (!bitmap.tryAllocPixels(info)) {
              return nullptr;
          }
      } else {
          // This bitmap has transparency, so we'll zero the pixels (to transparent).
          // We use the flag as a faster alloc-then-eraseColor(SK_ColorTRANSPARENT).
          if (!bitmap.tryAllocPixelsFlags(info, SkBitmap::kZeroPixels_AllocFlag)) {
              return nullptr;
          }
      }
  
      SkBitmap coverage;
      if (trackCoverage) {
          SkImageInfo ci = SkImageInfo::Make(info.width(), info.height(), kAlpha_8_SkColorType,
                                             kPremul_SkAlphaType);
          if (!coverage.tryAllocPixelsFlags(ci, SkBitmap::kZeroPixels_AllocFlag)) {
              return nullptr;
          }
      }
  
      return new SkBitmapDevice(bitmap, surfaceProps, hndl, trackCoverage ? &coverage : nullptr);
  }
  
  void SkBitmapDevice::replaceBitmapBackendForRasterSurface(const SkBitmap& bm) {
      SkASSERT(bm.width() == fBitmap.width());
      SkASSERT(bm.height() == fBitmap.height());
      fBitmap = bm;   // intent is to use bm's pixelRef (and rowbytes/config)
      this->privateResize(fBitmap.info().width(), fBitmap.info().height());
  }
  
  SkBaseDevice* SkBitmapDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint*) {
      const SkSurfaceProps surfaceProps(this->surfaceProps().flags(), cinfo.fPixelGeometry);
      return SkBitmapDevice::Create(cinfo.fInfo, surfaceProps, cinfo.fTrackCoverage,
                                    cinfo.fAllocator);
  }
  
  bool SkBitmapDevice::onAccessPixels(SkPixmap* pmap) {
      if (this->onPeekPixels(pmap)) {
          fBitmap.notifyPixelsChanged();
          return true;
      }
      return false;
  }
  
  bool SkBitmapDevice::onPeekPixels(SkPixmap* pmap) {
      const SkImageInfo info = fBitmap.info();
      if (fBitmap.getPixels() && (kUnknown_SkColorType != info.colorType())) {
          pmap->reset(fBitmap.info(), fBitmap.getPixels(), fBitmap.rowBytes());
          return true;
      }
      return false;
  }
  
  bool SkBitmapDevice::onWritePixels(const SkPixmap& pm, int x, int y) {
      // since we don't stop creating un-pixeled devices yet, check for no pixels here
      if (nullptr == fBitmap.getPixels()) {
          return false;
      }
  
      if (fBitmap.writePixels(pm, x, y)) {
          fBitmap.notifyPixelsChanged();
          return true;
      }
      return false;
  }
  
  bool SkBitmapDevice::onReadPixels(const SkPixmap& pm, int x, int y) {
      return fBitmap.readPixels(pm, x, y);
  }
  
  ///////////////////////////////////////////////////////////////////////////////
  
  void SkBitmapDevice::drawPaint(const SkPaint& paint) {
      BDDraw(this).drawPaint(paint);
  }
  
  void SkBitmapDevice::drawPoints(SkCanvas::PointMode mode, size_t count,
                                  const SkPoint pts[], const SkPaint& paint) {
      LOOP_TILER( drawPoints(mode, count, pts, paint, nullptr), nullptr)
  }
  
  void SkBitmapDevice::drawRect(const SkRect& r, const SkPaint& paint) {
      LOOP_TILER( drawRect(r, paint), Bounder(r, paint))
  }
  
  void SkBitmapDevice::drawOval(const SkRect& oval, const SkPaint& paint) {
      SkPath path;
      path.addOval(oval);
      // call the VIRTUAL version, so any subclasses who do handle drawPath aren't
      // required to override drawOval.
      this->drawPath(path, paint, true);
  }
  
  void SkBitmapDevice::drawRRect(const SkRRect& rrect, const SkPaint& paint) {
  #ifdef SK_IGNORE_BLURRED_RRECT_OPT
      SkPath  path;
  
      path.addRRect(rrect);
      // call the VIRTUAL version, so any subclasses who do handle drawPath aren't
      // required to override drawRRect.
      this->drawPath(path, paint, true);
  #else
      LOOP_TILER( drawRRect(rrect, paint), Bounder(rrect.getBounds(), paint))
  #endif
  }
  
  void SkBitmapDevice::drawPath(const SkPath& path,
                                const SkPaint& paint,
                                bool pathIsMutable) {
      const SkRect* bounds = nullptr;
      if (SkDrawTiler::NeedsTiling(this) && !path.isInverseFillType()) {
          bounds = &path.getBounds();
      }
      SkDrawTiler tiler(this, bounds ? Bounder(*bounds, paint).bounds() : nullptr);
      if (tiler.needsTiling()) {
          pathIsMutable = false;
      }
      while (const SkDraw* draw = tiler.next()) {
          draw->drawPath(path, paint, nullptr, pathIsMutable);
      }
  }
  
  void SkBitmapDevice::drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix,
                                  const SkRect* dstOrNull, const SkPaint& paint) {
      const SkRect* bounds = dstOrNull;
      SkRect storage;
      if (!bounds && SkDrawTiler::NeedsTiling(this)) {
          matrix.mapRect(&storage, SkRect::MakeIWH(bitmap.width(), bitmap.height()));
          Bounder b(storage, paint);
          if (b.hasBounds()) {
              storage = *b.bounds();
              bounds = &storage;
          }
      }
      LOOP_TILER(drawBitmap(bitmap, matrix, dstOrNull, paint), bounds)
  }
  
  static inline bool CanApplyDstMatrixAsCTM(const SkMatrix& m, const SkPaint& paint) {
      if (!paint.getMaskFilter()) {
          return true;
      }
  
      // Some mask filters parameters (sigma) depend on the CTM/scale.
      return m.getType() <= SkMatrix::kTranslate_Mask;
  }
  
  void SkBitmapDevice::drawBitmapRect(const SkBitmap& bitmap,
                                      const SkRect* src, const SkRect& dst,
                                      const SkPaint& paint, SkCanvas::SrcRectConstraint constraint) {
      SkASSERT(dst.isFinite());
      SkASSERT(dst.isSorted());
  
      SkMatrix    matrix;
      SkRect      bitmapBounds, tmpSrc, tmpDst;
      SkBitmap    tmpBitmap;
  
      bitmapBounds.isetWH(bitmap.width(), bitmap.height());
  
      // Compute matrix from the two rectangles
      if (src) {
          tmpSrc = *src;
      } else {
          tmpSrc = bitmapBounds;
      }
      matrix.setRectToRect(tmpSrc, dst, SkMatrix::kFill_ScaleToFit);
  
      LogDrawScaleFactor(this->ctm(), matrix, paint.getFilterQuality());
  
      const SkRect* dstPtr = &dst;
      const SkBitmap* bitmapPtr = &bitmap;
  
      // clip the tmpSrc to the bounds of the bitmap, and recompute dstRect if
      // needed (if the src was clipped). No check needed if src==null.
      if (src) {
          if (!bitmapBounds.contains(*src)) {
              if (!tmpSrc.intersect(bitmapBounds)) {
                  return; // nothing to draw
              }
              // recompute dst, based on the smaller tmpSrc
              matrix.mapRect(&tmpDst, tmpSrc);
              if (!tmpDst.isFinite()) {
                  return;
              }
              dstPtr = &tmpDst;
          }
      }
  
      if (src && !src->contains(bitmapBounds) &&
          SkCanvas::kFast_SrcRectConstraint == constraint &&
          paint.getFilterQuality() != kNone_SkFilterQuality) {
          // src is smaller than the bounds of the bitmap, and we are filtering, so we don't know
          // how much more of the bitmap we need, so we can't use extractSubset or drawBitmap,
          // but we must use a shader w/ dst bounds (which can access all of the bitmap needed).
          goto USE_SHADER;
      }
  
      if (src) {
          // since we may need to clamp to the borders of the src rect within
          // the bitmap, we extract a subset.
          const SkIRect srcIR = tmpSrc.roundOut();
          if (!bitmap.extractSubset(&tmpBitmap, srcIR)) {
              return;
          }
          bitmapPtr = &tmpBitmap;
  
          // Since we did an extract, we need to adjust the matrix accordingly
          SkScalar dx = 0, dy = 0;
          if (srcIR.fLeft > 0) {
              dx = SkIntToScalar(srcIR.fLeft);
          }
          if (srcIR.fTop > 0) {
              dy = SkIntToScalar(srcIR.fTop);
          }
          if (dx || dy) {
              matrix.preTranslate(dx, dy);
          }
  
  #ifdef SK_DRAWBITMAPRECT_FAST_OFFSET
          SkRect extractedBitmapBounds = SkRect::MakeXYWH(dx, dy,
                                                          SkIntToScalar(bitmapPtr->width()),
                                                          SkIntToScalar(bitmapPtr->height()));
  #else
          SkRect extractedBitmapBounds;
          extractedBitmapBounds.isetWH(bitmapPtr->width(), bitmapPtr->height());
  #endif
          if (extractedBitmapBounds == tmpSrc) {
              // no fractional part in src, we can just call drawBitmap
              goto USE_DRAWBITMAP;
          }
      } else {
          USE_DRAWBITMAP:
          // We can go faster by just calling drawBitmap, which will concat the
          // matrix with the CTM, and try to call drawSprite if it can. If not,
          // it will make a shader and call drawRect, as we do below.
          if (CanApplyDstMatrixAsCTM(matrix, paint)) {
              this->drawBitmap(*bitmapPtr, matrix, dstPtr, paint);
              return;
          }
      }
  
      USE_SHADER:
  
      // TODO(herb): Move this over to SkArenaAlloc when arena alloc has a facility to return sk_sps.
      // Since the shader need only live for our stack-frame, pass in a custom allocator. This
      // can save malloc calls, and signals to SkMakeBitmapShader to not try to copy the bitmap
      // if its mutable, since that precaution is not needed (give the short lifetime of the shader).
  
      // construct a shader, so we can call drawRect with the dst
      auto s = SkMakeBitmapShader(*bitmapPtr, SkShader::kClamp_TileMode, SkShader::kClamp_TileMode,
                                  &matrix, kNever_SkCopyPixelsMode);
      if (!s) {
          return;
      }
  
      SkPaint paintWithShader(paint);
      paintWithShader.setStyle(SkPaint::kFill_Style);
      paintWithShader.setShader(s);
  
      // Call ourself, in case the subclass wanted to share this setup code
      // but handle the drawRect code themselves.
      this->drawRect(*dstPtr, paintWithShader);
  }
  
  void SkBitmapDevice::drawSprite(const SkBitmap& bitmap, int x, int y, const SkPaint& paint) {
      BDDraw(this).drawSprite(bitmap, x, y, paint);
  }
  
  void SkBitmapDevice::drawGlyphRunList(const SkGlyphRunList& glyphRunList) {
      LOOP_TILER( drawGlyphRunList(glyphRunList, &fGlyphPainter), nullptr )
  }
  
  void SkBitmapDevice::drawVertices(const SkVertices* vertices, const SkVertices::Bone bones[],
                                    int boneCount, SkBlendMode bmode, const SkPaint& paint) {
      BDDraw(this).drawVertices(vertices->mode(), vertices->vertexCount(), vertices->positions(),
                                vertices->texCoords(), vertices->colors(), vertices->boneIndices(),
                                vertices->boneWeights(), bmode, vertices->indices(),
                                vertices->indexCount(), paint, bones, boneCount);
  }
  
  void SkBitmapDevice::drawDevice(SkBaseDevice* device, int x, int y, const SkPaint& origPaint) {
      SkASSERT(!origPaint.getImageFilter());
  
      // todo: can we unify with similar adjustment in SkGpuDevice?
      SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
      if (paint->getMaskFilter()) {
          paint.writable()->setMaskFilter(paint->getMaskFilter()->makeWithMatrix(this->ctm()));
      }
  
      // hack to test coverage
      SkBitmapDevice* src = static_cast<SkBitmapDevice*>(device);
      if (src->fCoverage) {
          SkDraw draw;
          draw.fDst = fBitmap.pixmap();
          draw.fMatrix = &SkMatrix::I();
          draw.fRC = &fRCStack.rc();
          SkPaint paint(origPaint);
          paint.setShader(SkShader::MakeBitmapShader(src->fBitmap, SkShader::kClamp_TileMode,
                                                     SkShader::kClamp_TileMode, nullptr));
          draw.drawBitmap(*src->fCoverage.get(),
                          SkMatrix::MakeTrans(SkIntToScalar(x),SkIntToScalar(y)), nullptr, paint);
      } else {
          this->drawSprite(src->fBitmap, x, y, *paint);
      }
  }
  
  ///////////////////////////////////////////////////////////////////////////////
  
  namespace {
  
  class SkAutoDeviceClipRestore {
  public:
      SkAutoDeviceClipRestore(SkBaseDevice* device, const SkIRect& clip)
          : fDevice(device)
          , fPrevCTM(device->ctm()) {
          fDevice->save();
          fDevice->setCTM(SkMatrix::I());
          fDevice->clipRect(SkRect::Make(clip), SkClipOp::kIntersect, false);
          fDevice->setCTM(fPrevCTM);
      }
  
      ~SkAutoDeviceClipRestore() {
          fDevice->restore(fPrevCTM);
      }
  
  private:
      SkBaseDevice*  fDevice;
      const SkMatrix fPrevCTM;
  };
  
  }  // anonymous ns
  
  void SkBitmapDevice::drawSpecial(SkSpecialImage* src, int x, int y, const SkPaint& origPaint,
                                   SkImage* clipImage, const SkMatrix& clipMatrix) {
      SkASSERT(!src->isTextureBacked());
  
      sk_sp<SkSpecialImage> filteredImage;
      SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
  
      if (SkImageFilter* filter = paint->getImageFilter()) {
          SkIPoint offset = SkIPoint::Make(0, 0);
          const SkMatrix matrix = SkMatrix::Concat(
              SkMatrix::MakeTrans(SkIntToScalar(-x), SkIntToScalar(-y)), this->ctm());
          const SkIRect clipBounds = fRCStack.rc().getBounds().makeOffset(-x, -y);
          sk_sp<SkImageFilterCache> cache(this->getImageFilterCache());
          SkImageFilter::OutputProperties outputProperties(fBitmap.colorType(), fBitmap.colorSpace());
          SkImageFilter::Context ctx(matrix, clipBounds, cache.get(), outputProperties);
  
          filteredImage = filter->filterImage(src, ctx, &offset);
          if (!filteredImage) {
              return;
          }
  
          src = filteredImage.get();
          paint.writable()->setImageFilter(nullptr);
          x += offset.x();
          y += offset.y();
      }
  
      if (paint->getMaskFilter()) {
          paint.writable()->setMaskFilter(paint->getMaskFilter()->makeWithMatrix(this->ctm()));
      }
  
      if (!clipImage) {
          SkBitmap resultBM;
          if (src->getROPixels(&resultBM)) {
              this->drawSprite(resultBM, x, y, *paint);
          }
          return;
      }
  
      // Clip image case.
      sk_sp<SkImage> srcImage(src->asImage());
      if (!srcImage) {
          return;
      }
  
      const SkMatrix totalMatrix = SkMatrix::Concat(this->ctm(), clipMatrix);
      SkRect clipBounds;
      totalMatrix.mapRect(&clipBounds, SkRect::Make(clipImage->bounds()));
      const SkIRect srcBounds = srcImage->bounds().makeOffset(x, y);
  
      SkIRect maskBounds = fRCStack.rc().getBounds();
      if (!maskBounds.intersect(clipBounds.roundOut()) || !maskBounds.intersect(srcBounds)) {
          return;
      }
  
      sk_sp<SkImage> mask;
      SkMatrix maskMatrix, shaderMatrix;
      SkTLazy<SkAutoDeviceClipRestore> autoClipRestore;
  
      SkMatrix totalInverse;
      if (clipImage->isAlphaOnly() && totalMatrix.invert(&totalInverse)) {
          // If the mask is already in A8 format, we can draw it directly
          // (while compensating in the shader matrix).
          mask = sk_ref_sp(clipImage);
          maskMatrix = totalMatrix;
          shaderMatrix = SkMatrix::Concat(totalInverse, SkMatrix::MakeTrans(x, y));
  
          // If the mask is not fully contained within the src layer, we must clip.
          if (!srcBounds.contains(clipBounds)) {
              autoClipRestore.init(this, srcBounds);
          }
  
          maskBounds.offsetTo(0, 0);
      } else {
          // Otherwise, we convert the mask to A8 explicitly.
          sk_sp<SkSurface> surf = SkSurface::MakeRaster(SkImageInfo::MakeA8(maskBounds.width(),
                                                                            maskBounds.height()));
          SkCanvas* canvas = surf->getCanvas();
          canvas->translate(-maskBounds.x(), -maskBounds.y());
          canvas->concat(totalMatrix);
          canvas->drawImage(clipImage, 0, 0);
  
          mask = surf->makeImageSnapshot();
          maskMatrix = SkMatrix::I();
          shaderMatrix = SkMatrix::MakeTrans(x - maskBounds.x(), y - maskBounds.y());
      }
  
      SkAutoDeviceCTMRestore adctmr(this, maskMatrix);
      paint.writable()->setShader(srcImage->makeShader(&shaderMatrix));
      this->drawImageRect(mask.get(), nullptr,
                          SkRect::MakeXYWH(maskBounds.x(), maskBounds.y(),
                                           mask->width(), mask->height()),
                          *paint, SkCanvas::kFast_SrcRectConstraint);
  }
  
  sk_sp<SkSpecialImage> SkBitmapDevice::makeSpecial(const SkBitmap& bitmap) {
      return SkSpecialImage::MakeFromRaster(bitmap.bounds(), bitmap);
  }
  
  sk_sp<SkSpecialImage> SkBitmapDevice::makeSpecial(const SkImage* image) {
      return SkSpecialImage::MakeFromImage(nullptr, SkIRect::MakeWH(image->width(), image->height()),
                                           image->makeNonTextureImage());
  }
  
  sk_sp<SkSpecialImage> SkBitmapDevice::snapSpecial() {
      return this->makeSpecial(fBitmap);
  }
  
  sk_sp<SkSpecialImage> SkBitmapDevice::snapBackImage(const SkIRect& bounds) {
      return SkSpecialImage::CopyFromRaster(bounds, fBitmap, &this->surfaceProps());
  }
  
  ///////////////////////////////////////////////////////////////////////////////
  
  sk_sp<SkSurface> SkBitmapDevice::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
      return SkSurface::MakeRaster(info, &props);
  }
  
  SkImageFilterCache* SkBitmapDevice::getImageFilterCache() {
      SkImageFilterCache* cache = SkImageFilterCache::Get();
      cache->ref();
      return cache;
  }
  
  ///////////////////////////////////////////////////////////////////////////////////////////////////
  
  void SkBitmapDevice::onSave() {
      fRCStack.save();
  }
  
  void SkBitmapDevice::onRestore() {
      fRCStack.restore();
  }
  
  void SkBitmapDevice::onClipRect(const SkRect& rect, SkClipOp op, bool aa) {
      fRCStack.clipRect(this->ctm(), rect, op, aa);
  }
  
  void SkBitmapDevice::onClipRRect(const SkRRect& rrect, SkClipOp op, bool aa) {
      fRCStack.clipRRect(this->ctm(), rrect, op, aa);
  }
  
  void SkBitmapDevice::onClipPath(const SkPath& path, SkClipOp op, bool aa) {
      fRCStack.clipPath(this->ctm(), path, op, aa);
  }
  
  void SkBitmapDevice::onClipRegion(const SkRegion& rgn, SkClipOp op) {
      SkIPoint origin = this->getOrigin();
      SkRegion tmp;
      const SkRegion* ptr = &rgn;
      if (origin.fX | origin.fY) {
          // translate from "global/canvas" coordinates to relative to this device
          rgn.translate(-origin.fX, -origin.fY, &tmp);
          ptr = &tmp;
      }
      fRCStack.clipRegion(*ptr, op);
  }
  
  void SkBitmapDevice::onSetDeviceClipRestriction(SkIRect* mutableClipRestriction) {
      fRCStack.setDeviceClipRestriction(mutableClipRestriction);
      if (!mutableClipRestriction->isEmpty()) {
          SkRegion rgn(*mutableClipRestriction);
          fRCStack.clipRegion(rgn, SkClipOp::kIntersect);
      }
  }
  
  bool SkBitmapDevice::onClipIsAA() const {
      const SkRasterClip& rc = fRCStack.rc();
      return !rc.isEmpty() && rc.isAA();
  }
  
  void SkBitmapDevice::onAsRgnClip(SkRegion* rgn) const {
      const SkRasterClip& rc = fRCStack.rc();
      if (rc.isAA()) {
          rgn->setRect(rc.getBounds());
      } else {
          *rgn = rc.bwRgn();
      }
  }
  
  void SkBitmapDevice::validateDevBounds(const SkIRect& drawClipBounds) {
  #ifdef SK_DEBUG
      const SkIRect& stackBounds = fRCStack.rc().getBounds();
      SkASSERT(drawClipBounds == stackBounds);
  #endif
  }
  
  SkBaseDevice::ClipType SkBitmapDevice::onGetClipType() const {
      const SkRasterClip& rc = fRCStack.rc();
      if (rc.isEmpty()) {
          return kEmpty_ClipType;
      } else if (rc.isRect()) {
          return kRect_ClipType;
      } else {
          return kComplex_ClipType;
      }
  }
  