[SkSVGDevice] drawBitmap* support

src/svg/SkSVGDevice.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkSVGDevice.h"
 
+#include "SkBase64.h"
 #include "SkBitmap.h"
 #include "SkChecksum.h"
+#include "SkData.h"
 #include "SkDraw.h"
+#include "SkImageEncoder.h"
 #include "SkPaint.h"
 #include "SkParsePath.h"
-#include "SkPathOps.h"
 #include "SkShader.h"
 #include "SkStream.h"
 #include "SkTHash.h"
 #include "SkTypeface.h"
 #include "SkUtils.h"
 #include "SkXMLWriter.h"
 
 namespace {
 
 static SkString svg_color(SkColor color) {
@@ skipping 218 matching lines @@
     SkString fText, fPosX, fPosY;
     bool     fLastCharWasWhitespace;
 };
 
 }
 
 // For now all this does is serve unique serial IDs, but it will eventually evolve to track
 // and deduplicate resources.
 class SkSVGDevice::ResourceBucket : ::SkNoncopyable {
 public:
-    ResourceBucket() : fGradientCount(0), fClipCount(0), fPathCount(0) {}
+    ResourceBucket() : fGradientCount(0), fClipCount(0), fPathCount(0), fImageCount(0) {}
 
     SkString addLinearGradient() {
         return SkStringPrintf("gradient_%d", fGradientCount++);
     }
 
     SkString addClip() {
         return SkStringPrintf("clip_%d", fClipCount++);
     }
 
     SkString addPath() {
         return SkStringPrintf("path_%d", fPathCount++);
     }
 
+    SkString addImage() {
+        return SkStringPrintf("img_%d", fImageCount++);
+    }
+
 private:
     uint32_t fGradientCount;
     uint32_t fClipCount;
     uint32_t fPathCount;
+    uint32_t fImageCount;
 };
 
 class SkSVGDevice::AutoElement : ::SkNoncopyable {
 public:
     AutoElement(const char name[], SkXMLWriter* writer)
         : fWriter(writer)
         , fResourceBucket(NULL) {
         fWriter->startElement(name);
     }
 
     AutoElement(const char name[], SkXMLWriter* writer, ResourceBucket* bucket,
                 const SkDraw& draw, const SkPaint& paint)
         : fWriter(writer)
         , fResourceBucket(bucket) {
 
         Resources res = this->addResources(draw, paint);
+        if (!res.fClip.isEmpty()) {
+            // The clip is in device space. Apply it via a <g> wrapper to avoid local transform
+            // interference.
+            fClipGroup.reset(SkNEW_ARGS(AutoElement, ("g", fWriter)));
+            fClipGroup->addAttribute("clip-path",res.fClip);
+        }
 
         fWriter->startElement(name);
 
         this->addPaint(paint, res);
 
         if (!draw.fMatrix->isIdentity()) {
             this->addAttribute("transform", svg_transform(*draw.fMatrix));
         }
     }
 
@@ skipping 27 matching lines @@
 
 private:
     Resources addResources(const SkDraw& draw, const SkPaint& paint);
     void addClipResources(const SkDraw& draw, Resources* resources);
     void addShaderResources(const SkPaint& paint, Resources* resources);
 
     void addPaint(const SkPaint& paint, const Resources& resources);
 
     SkString addLinearGradientDef(const SkShader::GradientInfo& info, const SkShader* shader);
 
-    SkXMLWriter*    fWriter;
-    ResourceBucket* fResourceBucket;
+    SkXMLWriter*               fWriter;
+    ResourceBucket*            fResourceBucket;
+    SkAutoTDelete<AutoElement> fClipGroup;
 };
 
 void SkSVGDevice::AutoElement::addPaint(const SkPaint& paint, const Resources& resources) {
     SkPaint::Style style = paint.getStyle();
     if (style == SkPaint::kFill_Style || style == SkPaint::kStrokeAndFill_Style) {
         this->addAttribute("fill", resources.fPaintServer);
 
         if (SK_AlphaOPAQUE != SkColorGetA(paint.getColor())) {
             this->addAttribute("fill-opacity", svg_opacity(paint.getColor()));
         }
@@ skipping 25 matching lines @@
             this->addAttribute("stroke-miterlimit", paint.getStrokeMiter());
         }
 
         if (SK_AlphaOPAQUE != SkColorGetA(paint.getColor())) {
             this->addAttribute("stroke-opacity", svg_opacity(paint.getColor()));
         }
     } else {
         SkASSERT(style == SkPaint::kFill_Style);
         this->addAttribute("stroke", "none");
     }
-
-    if (!resources.fClip.isEmpty()) {
-        this->addAttribute("clip-path", resources.fClip);
-    }
 }
 
 Resources SkSVGDevice::AutoElement::addResources(const SkDraw& draw, const SkPaint& paint) {
     Resources resources(paint);
 
     // FIXME: this is a weak heuristic and we end up with LOTS of redundant clips.
     bool hasClip   = !draw.fClipStack->isWideOpen();
     bool hasShader = SkToBool(paint.getShader());
 
     if (hasClip || hasShader) {
@@ skipping 226 matching lines @@
     // todo
     SkDebugf("unsupported operation: drawRRect()\n");
 }
 
 void SkSVGDevice::drawPath(const SkDraw& draw, const SkPath& path, const SkPaint& paint,
                            const SkMatrix* prePathMatrix, bool pathIsMutable) {
     AutoElement elem("path", fWriter, fResourceBucket, draw, paint);
     elem.addPathAttributes(path);
 }
 
-void SkSVGDevice::drawBitmap(const SkDraw&, const SkBitmap& bitmap,
-                             const SkMatrix& matrix, const SkPaint& paint) {
-    // todo
-    SkDebugf("unsupported operation: drawBitmap()\n");
+void SkSVGDevice::drawBitmapCommon(const SkDraw& draw, const SkBitmap& bm,
+                                   const SkPaint& paint) {
+    SkAutoTUnref<const SkData> pngData(
+        SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, SkImageEncoder::kDefaultQuality));
+    if (!pngData) {
+        return;
+    }
+
+    size_t b64Size = SkBase64::Encode(pngData->data(), pngData->size(), NULL);
+    SkAutoTMalloc<char> b64Data(b64Size);
+    SkBase64::Encode(pngData->data(), pngData->size(), b64Data.get());
+
+    SkString svgImageData("data:image/png;base64,");
+    svgImageData.append(b64Data.get(), b64Size);
+
+    SkString imageID = fResourceBucket->addImage();
+    {
+        AutoElement defs("defs", fWriter);
+        {
+            AutoElement image("image", fWriter);
+            image.addAttribute("id", imageID);
+            image.addAttribute("width", bm.width());
+            image.addAttribute("height", bm.height());
+            image.addAttribute("xlink:href", svgImageData);
+        }
+    }
+
+    {
+        AutoElement imageUse("use", fWriter, fResourceBucket, draw, paint);
+        imageUse.addAttribute("xlink:href", SkStringPrintf("#%s", imageID.c_str()));
+    }
 }
 
-void SkSVGDevice::drawSprite(const SkDraw&, const SkBitmap& bitmap,
-                             int x, int y, const SkPaint& paint) {
-    // todo
-    SkDebugf("unsupported operation: drawSprite()\n");
+void SkSVGDevice::drawBitmap(const SkDraw& draw, const SkBitmap& bitmap,
+                             const SkMatrix& matrix, const SkPaint& paint) {
+    SkMatrix adjustedMatrix = *draw.fMatrix;
+    adjustedMatrix.preConcat(matrix);
+    SkDraw adjustedDraw(draw);
+    adjustedDraw.fMatrix = &adjustedMatrix;
+
+    drawBitmapCommon(adjustedDraw, bitmap, paint);
 }
 
-void SkSVGDevice::drawBitmapRect(const SkDraw&, const SkBitmap&, const SkRect* srcOrNull,
+void SkSVGDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
+                             int x, int y, const SkPaint& paint) {
+    SkMatrix adjustedMatrix = *draw.fMatrix;
+    adjustedMatrix.preTranslate(SkIntToScalar(x), SkIntToScalar(y));
+    SkDraw adjustedDraw(draw);
+    adjustedDraw.fMatrix = &adjustedMatrix;
+
+    drawBitmapCommon(adjustedDraw, bitmap, paint);
+}
+
+void SkSVGDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bm, const SkRect* srcOrNull,
                                  const SkRect& dst, const SkPaint& paint,
-                                 SkCanvas::DrawBitmapRectFlags flags) {
-    // todo
-    SkDebugf("unsupported operation: drawBitmapRect()\n");
+                                 SkCanvas::DrawBitmapRectFlags) {
+    SkMatrix adjustedMatrix;
+    adjustedMatrix.setRectToRect(srcOrNull ? *srcOrNull : SkRect::Make(bm.bounds()),
+                                 dst,
+                                 SkMatrix::kFill_ScaleToFit);
+    adjustedMatrix.postConcat(*draw.fMatrix);
+
+    SkDraw adjustedDraw(draw);
+    adjustedDraw.fMatrix = &adjustedMatrix;
+
+    SkClipStack adjustedClipStack;
+    if (srcOrNull && *srcOrNull != SkRect::Make(bm.bounds())) {
+        SkRect devClipRect;
+        draw.fMatrix->mapRect(&devClipRect, dst);
+
+        adjustedClipStack = *draw.fClipStack;
+        adjustedClipStack.clipDevRect(devClipRect, SkRegion::kIntersect_Op, paint.isAntiAlias());
+        adjustedDraw.fClipStack = &adjustedClipStack;
+    }
+
+    drawBitmapCommon(adjustedDraw, bm, paint);
 }
 
 void SkSVGDevice::drawText(const SkDraw& draw, const void* text, size_t len,
                            SkScalar x, SkScalar y, const SkPaint& paint) {
     AutoElement elem("text", fWriter, fResourceBucket, draw, paint);
     elem.addTextAttributes(paint);
 
     SVGTextBuilder builder(text, len, paint, SkPoint::Make(x, y), 0);
     elem.addAttribute("x", builder.posX());
     elem.addAttribute("y", builder.posY());
@@ skipping 58 matching lines @@
                                const SkPaint& paint) {
     // todo
     SkDebugf("unsupported operation: drawVertices()\n");
 }
 
 void SkSVGDevice::drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
                              const SkPaint&) {
     // todo
     SkDebugf("unsupported operation: drawDevice()\n");
 }