support for more features when rendering to/from JSON

tools/json/SkJSONRenderer.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkJSONRenderer.h"
 
 #include "SkBlurMaskFilter.h"
 #include "SkDashPathEffect.h"
 #include "SkJSONCanvas.h"
 #include "SkJSONCPP.h"
 #include "SkPath.h"
+#include "SkValidatingReadBuffer.h"
 
 namespace SkJSONRenderer {
 
 class Renderer {
 public:
     void getPaint(Json::Value& command, SkPaint* paint);
 
     void getRect(Json::Value& command, const char* name, SkRect* rect);
 
     void getRRect(Json::Value& command, const char* name, SkRRect* rrect);
 
     void getPath(Json::Value& command, SkPath* path);
 
     SkRegion::Op getRegionOp(Json::Value& command);
 
     void processCommand(Json::Value& command, SkCanvas* target);
 
     void processMatrix(Json::Value& command, SkCanvas* target);
 
     void processSave(Json::Value& command, SkCanvas* target);
 
     void processRestore(Json::Value& command, SkCanvas* target);
 
+    void processSaveLayer(Json::Value& command, SkCanvas* target);
+
     void processPaint(Json::Value& command, SkCanvas* target);
 
     void processRect(Json::Value& command, SkCanvas* target);
 
     void processRRect(Json::Value& command, SkCanvas* target);
 
     void processOval(Json::Value& command, SkCanvas* target);
 
     void processPath(Json::Value& command, SkCanvas* target);
 
     void processText(Json::Value& command, SkCanvas* target);
 
     void processPosText(Json::Value& command, SkCanvas* target);
 
     void processPoints(Json::Value& command, SkCanvas* target);
 
+    void processImage(Json::Value& command, SkCanvas* target);
+
+    void processImageRect(Json::Value& command, SkCanvas* target);
+
+    void processBitmap(Json::Value& command, SkCanvas* target);
+
+    void processBitmapRect(Json::Value& command, SkCanvas* target);
+
     void processClipRect(Json::Value& command, SkCanvas* target);
     
     void processClipRRect(Json::Value& command, SkCanvas* target);
 
     void processClipPath(Json::Value& command, SkCanvas* target);
 };
 
 void Renderer::processCommand(Json::Value& command, SkCanvas* target) {
     const char* name = command[SKJSONCANVAS_COMMAND].asCString();
     // TODO speed this up with a hash
     if (!strcmp(name, SKJSONCANVAS_COMMAND_MATRIX)) {
         this->processMatrix(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_SAVE)) {
         this->processSave(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_RESTORE)) {
         this->processRestore(command, target);
     }
+    else if (!strcmp(name, SKJSONCANVAS_COMMAND_SAVELAYER)) {
+        this->processSaveLayer(command, target);
+    }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_PAINT)) {
         this->processPaint(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_RECT)) {
         this->processRect(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_RRECT)) {
         this->processRRect(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_OVAL)) {
         this->processOval(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_PATH)) {
         this->processPath(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_TEXT)) {
         this->processText(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_POSTEXT)) {
         this->processPosText(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_POINTS)) {
         this->processPoints(command, target);
     }
+    else if (!strcmp(name, SKJSONCANVAS_COMMAND_IMAGE)) {
+        this->processImage(command, target);
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COMMAND_IMAGERECT)) {
+        this->processImageRect(command, target);
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COMMAND_BITMAP)) {
+        this->processBitmap(command, target);
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COMMAND_BITMAPRECT)) {
+        this->processBitmapRect(command, target);
+    }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_CLIPRECT)) {
         this->processClipRect(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_CLIPRRECT)) {
         this->processClipRRect(command, target);
     }
     else if (!strcmp(name, SKJSONCANVAS_COMMAND_CLIPPATH)) {
         this->processClipPath(command, target);
     }
     else {
         SkDebugf("unsupported JSON command: %s\n", name);
     }
 }
 
-void Renderer::getPaint(Json::Value& command, SkPaint* result) {
-    Json::Value jsonPaint = command[SKJSONCANVAS_ATTRIBUTE_PAINT];
+static void apply_paint_color(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_COLOR)) {
         Json::Value color = jsonPaint[SKJSONCANVAS_ATTRIBUTE_COLOR];
-        result->setColor(SkColorSetARGB(color[0].asInt(), color[1].asInt(), color[2].asInt(),
+        target->setColor(SkColorSetARGB(color[0].asInt(), color[1].asInt(), color[2].asInt(),
                          color[3].asInt()));
     }
+}
+
+// note that the caller is responsible for freeing the pointer
+static Json::ArrayIndex decode_data(Json::Value bytes, void** target) {
+    Json::ArrayIndex size = bytes.size();
+    *target = sk_malloc_throw(size);
+    for (Json::ArrayIndex i = 0; i < size; i++) {
+        ((uint8_t*) *target)[i] = bytes[i].asInt();
+    }
+    return size;
+}
+
+static SkFlattenable* load_flattenable(Json::Value jsonFlattenable) {
+    if (!jsonFlattenable.isMember(SKJSONCANVAS_ATTRIBUTE_NAME)) {
+        return nullptr;
+    }
+    const char* name = jsonFlattenable[SKJSONCANVAS_ATTRIBUTE_NAME].asCString();
+    SkFlattenable::Factory factory = SkFlattenable::NameToFactory(name);
+    if (factory == nullptr) {
+        return nullptr;
+    }
+    void* data;
+    int size = decode_data(jsonFlattenable[SKJSONCANVAS_ATTRIBUTE_BYTES], &data);
+    SkValidatingReadBuffer buffer(data, size);
+    SkFlattenable* result = factory(buffer);
+    free(data);
+    if (!buffer.isValid()) {
+        return nullptr;
+    }
+    return result;
+}
+
+// caller is responsible for freeing return value
+static SkBitmap* load_bitmap(Json::Value jsonBitmap) {
+    if (!jsonBitmap.isMember(SKJSONCANVAS_ATTRIBUTE_BYTES)) {
+        return nullptr;
+    }
+    void* data;
+    int size = decode_data(jsonBitmap[SKJSONCANVAS_ATTRIBUTE_BYTES], &data);
+    SkMemoryStream stream(data, size);
+    SkImageDecoder* decoder = SkImageDecoder::Factory(&stream);
+    SkBitmap* bitmap = new SkBitmap();
+    SkImageDecoder::Result result = decoder->decode(&stream, bitmap, 
+                                                    SkImageDecoder::kDecodePixels_Mode);
+    free(decoder);
+    if (result != SkImageDecoder::kFailure) {
+        free(data);
+        return bitmap;
+    }
+    SkDebugf("image decode failed");
+    free(data);
+    return nullptr;
+}
+
+static SkImage* load_image(Json::Value jsonImage) {
+    SkBitmap* bitmap = load_bitmap(jsonImage);
+    if (bitmap == nullptr) {
+        return nullptr;
+    }
+    SkImage* result = SkImage::NewFromBitmap(*bitmap);
+    free(bitmap);
+    return result;
+}
+
+static void apply_paint_shader(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_SHADER)) {
+        Json::Value jsonShader = jsonPaint[SKJSONCANVAS_ATTRIBUTE_SHADER];
+        SkShader* shader = (SkShader*) load_flattenable(jsonShader);
+        if (shader != nullptr) {
+            target->setShader(shader);
+            shader->unref();
+        }
+    }
+}
+
+static void apply_paint_patheffect(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_PATHEFFECT)) {
+        Json::Value jsonPathEffect = jsonPaint[SKJSONCANVAS_ATTRIBUTE_PATHEFFECT];
+        SkPathEffect* pathEffect = (SkPathEffect*) load_flattenable(jsonPathEffect);
+        if (pathEffect != nullptr) {
+            target->setPathEffect(pathEffect);
+            pathEffect->unref();
+        }
+    }
+}
+
+static void apply_paint_maskfilter(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_MASKFILTER)) {
+        Json::Value jsonMaskFilter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_MASKFILTER];
+        SkMaskFilter* maskFilter = (SkMaskFilter*) load_flattenable(jsonMaskFilter);
+        if (maskFilter != nullptr) {
+            target->setMaskFilter(maskFilter);
+            maskFilter->unref();
+        }
+    }
+}
+
+static void apply_paint_xfermode(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_XFERMODE)) {
+        Json::Value jsonXfermode = jsonPaint[SKJSONCANVAS_ATTRIBUTE_XFERMODE];
+        SkXfermode* xfermode = (SkXfermode*) load_flattenable(jsonXfermode);
+        if (xfermode != nullptr) {
+            target->setXfermode(xfermode);
+            xfermode->unref();
+        }
+    }
+}
+
+static void apply_paint_style(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_STYLE)) {
         const char* style = jsonPaint[SKJSONCANVAS_ATTRIBUTE_STYLE].asCString();
         if (!strcmp(style, SKJSONCANVAS_STYLE_FILL)) {
-            result->setStyle(SkPaint::kFill_Style);
+            target->setStyle(SkPaint::kFill_Style);
         }
         else if (!strcmp(style, SKJSONCANVAS_STYLE_STROKE)) {
-            result->setStyle(SkPaint::kStroke_Style);
+            target->setStyle(SkPaint::kStroke_Style);
         }
         else if (!strcmp(style, SKJSONCANVAS_STYLE_STROKEANDFILL)) {
-            result->setStyle(SkPaint::kStrokeAndFill_Style);
+            target->setStyle(SkPaint::kStrokeAndFill_Style);
         }
     }
+}
+
+static void apply_paint_strokewidth(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_STROKEWIDTH)) {
         float strokeWidth = jsonPaint[SKJSONCANVAS_ATTRIBUTE_STROKEWIDTH].asFloat();
-        result->setStrokeWidth(strokeWidth);
+        target->setStrokeWidth(strokeWidth);
+    }    
+}
+
+static void apply_paint_strokemiter(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_STROKEMITER)) {
+        float strokeMiter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_STROKEMITER].asFloat();
+        target->setStrokeMiter(strokeMiter);
+    }    
+}
+
+static void apply_paint_cap(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_CAP)) {
+        const char* cap = jsonPaint[SKJSONCANVAS_ATTRIBUTE_CAP].asCString();
+        if (!strcmp(cap, SKJSONCANVAS_CAP_BUTT)) {
+            target->setStrokeCap(SkPaint::kButt_Cap);
+        }
+        else if (!strcmp(cap, SKJSONCANVAS_CAP_ROUND)) {
+            target->setStrokeCap(SkPaint::kRound_Cap);
+        }
+        else if (!strcmp(cap, SKJSONCANVAS_CAP_SQUARE)) {
+            target->setStrokeCap(SkPaint::kSquare_Cap);
+        }
     }
+}
+
+static void apply_paint_antialias(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_ANTIALIAS)) {
-        result->setAntiAlias(jsonPaint[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
+        target->setAntiAlias(jsonPaint[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
     }
+}
+
+static void apply_paint_blur(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_BLUR)) {
         Json::Value blur = jsonPaint[SKJSONCANVAS_ATTRIBUTE_BLUR];
         SkScalar sigma = blur[SKJSONCANVAS_ATTRIBUTE_SIGMA].asFloat();
         SkBlurStyle style;
         const char* jsonStyle = blur[SKJSONCANVAS_ATTRIBUTE_STYLE].asCString();
         if (!strcmp(jsonStyle, SKJSONCANVAS_BLURSTYLE_NORMAL)) {
             style = SkBlurStyle::kNormal_SkBlurStyle;
         }
         else if (!strcmp(jsonStyle, SKJSONCANVAS_BLURSTYLE_SOLID)) {
             style = SkBlurStyle::kSolid_SkBlurStyle;
@@ skipping 13 matching lines @@
         if (!strcmp(jsonQuality, SKJSONCANVAS_BLURQUALITY_LOW)) {
             flags = SkBlurMaskFilter::BlurFlags::kNone_BlurFlag;
         }
         else if (!strcmp(jsonQuality, SKJSONCANVAS_BLURQUALITY_HIGH)) {
             flags = SkBlurMaskFilter::BlurFlags::kHighQuality_BlurFlag;
         }
         else {
             SkASSERT(false);
             flags = SkBlurMaskFilter::BlurFlags::kNone_BlurFlag;
         }
-        result->setMaskFilter(SkBlurMaskFilter::Create(style, sigma, flags));
+        target->setMaskFilter(SkBlurMaskFilter::Create(style, sigma, flags));
     }
+}
+
+static void apply_paint_dashing(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_DASHING)) {
         Json::Value dash = jsonPaint[SKJSONCANVAS_ATTRIBUTE_DASHING];
         Json::Value jsonIntervals = dash[SKJSONCANVAS_ATTRIBUTE_INTERVALS];
         Json::ArrayIndex count = jsonIntervals.size();
         SkScalar* intervals = (SkScalar*) sk_malloc_throw(count * sizeof(SkScalar));
         for (Json::ArrayIndex i = 0; i < count; i++) {
             intervals[i] = jsonIntervals[i].asFloat();
         }
         SkScalar phase = dash[SKJSONCANVAS_ATTRIBUTE_PHASE].asFloat();
-        result->setPathEffect(SkDashPathEffect::Create(intervals, count, phase));
+        target->setPathEffect(SkDashPathEffect::Create(intervals, count, phase));
         free(intervals);
     }
+}
+
+static void apply_paint_textalign(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTALIGN)) {
         SkPaint::Align textAlign;
         const char* jsonAlign = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTALIGN].asCString();
         if (!strcmp(jsonAlign, SKJSONCANVAS_ALIGN_LEFT)) {
             textAlign = SkPaint::kLeft_Align;
         }
         else if (!strcmp(jsonAlign, SKJSONCANVAS_ALIGN_CENTER)) {
             textAlign = SkPaint::kCenter_Align;
         }
         else if (!strcmp(jsonAlign, SKJSONCANVAS_ALIGN_RIGHT)) {
             textAlign = SkPaint::kRight_Align;
         }
         else {
             SkASSERT(false);
             textAlign = SkPaint::kLeft_Align;
         }
-        result->setTextAlign(textAlign);
+        target->setTextAlign(textAlign);
     }
+}
+
+static void apply_paint_textsize(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTSIZE)) {
         float textSize = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTSIZE].asFloat();
-        result->setTextSize(textSize);
+        target->setTextSize(textSize);
     }
+}
+
+static void apply_paint_textscalex(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTSCALEX)) {
         float textScaleX = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTSCALEX].asFloat();
-        result->setTextScaleX(textScaleX);
+        target->setTextScaleX(textScaleX);
     }
+}
+
+static void apply_paint_textskewx(Json::Value& jsonPaint, SkPaint* target) {
     if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_TEXTSKEWX)) {
         float textSkewX = jsonPaint[SKJSONCANVAS_ATTRIBUTE_TEXTSKEWX].asFloat();
-        result->setTextSkewX(textSkewX);
+        target->setTextSkewX(textSkewX);
     }
 }
 
+void Renderer::getPaint(Json::Value& command, SkPaint* result) {
+    Json::Value jsonPaint = command[SKJSONCANVAS_ATTRIBUTE_PAINT];
+    apply_paint_color(jsonPaint, result);
+    apply_paint_shader(jsonPaint, result);
+    apply_paint_patheffect(jsonPaint, result);
+    apply_paint_maskfilter(jsonPaint, result);
+    apply_paint_xfermode(jsonPaint, result);
+    apply_paint_style(jsonPaint, result);
+    apply_paint_strokewidth(jsonPaint, result);
+    apply_paint_strokemiter(jsonPaint, result);
+    apply_paint_cap(jsonPaint, result);
+    apply_paint_antialias(jsonPaint, result);
+    apply_paint_blur(jsonPaint, result);
+    apply_paint_dashing(jsonPaint, result);
+    apply_paint_textalign(jsonPaint, result);
+    apply_paint_textsize(jsonPaint, result);
+    apply_paint_textscalex(jsonPaint, result);
+    apply_paint_textskewx(jsonPaint, result);
+}
+
 void Renderer::getRect(Json::Value& command, const char* name, SkRect* result) {
     Json::Value rect = command[name];
     result->set(rect[0].asFloat(), rect[1].asFloat(), rect[2].asFloat(), rect[3].asFloat());
 }
 
 void Renderer::getRRect(Json::Value& command, const char* name, SkRRect* result) {
     Json::Value rrect = command[name];
     SkVector radii[4] = {
                             { rrect[1][0].asFloat(), rrect[1][1].asFloat() }, 
                             { rrect[2][0].asFloat(), rrect[2][1].asFloat() }, 
@@ skipping 97 matching lines @@
 }
 
 void Renderer::processSave(Json::Value& command, SkCanvas* target) {
     target->save();
 }
 
 void Renderer::processRestore(Json::Value& command, SkCanvas* target) {
     target->restore();
 }
 
+void Renderer::processSaveLayer(Json::Value& command, SkCanvas* target) {
+    SkCanvas::SaveLayerRec rec;
+    SkRect bounds;
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_BOUNDS)) {
+        this->getRect(command, SKJSONCANVAS_ATTRIBUTE_BOUNDS, &bounds);
+        rec.fBounds = &bounds;
+    }
+    SkPaint paint;
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
+        this->getPaint(command, &paint);
+        rec.fPaint = &paint;
+    }
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_BACKDROP)) {
+        rec.fBackdrop = (SkImageFilter*) load_flattenable(command[SKJSONCANVAS_ATTRIBUTE_BACKDROP]);
+    }
+    target->saveLayer(rec);
+    if (rec.fBackdrop != nullptr) {
+        rec.fBackdrop->unref();
+    }
+}
+
 void Renderer::processPaint(Json::Value& command, SkCanvas* target) {
     SkPaint paint;
     this->getPaint(command, &paint);
     target->drawPaint(paint);
 }
 
 void Renderer::processRect(Json::Value& command, SkCanvas* target) {
     SkRect rect;
     this->getRect(command, SKJSONCANVAS_ATTRIBUTE_COORDS, &rect);
     SkPaint paint;
@@ skipping 90 matching lines @@
                       command[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
 void Renderer::processClipPath(Json::Value& command, SkCanvas* target) {
     SkPath path;
     this->getPath(command, &path);
     target->clipPath(path, this->getRegionOp(command), 
                      command[SKJSONCANVAS_ATTRIBUTE_ANTIALIAS].asBool());
 }
 
+void Renderer::processImage(Json::Value& command, SkCanvas* target) {
+    SkImage* image = load_image(command[SKJSONCANVAS_ATTRIBUTE_IMAGE]);
+    if (image == nullptr) {
+        return;
+    }
+    Json::Value point = command[SKJSONCANVAS_ATTRIBUTE_COORDS];
+    SkPaint* paintPtr;
+    SkPaint paint;
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
+        this->getPaint(command, &paint);
+        paintPtr = &paint;
+    }
+    else {
+        paintPtr = nullptr;
+    }
+    target->drawImage(image, point[0].asFloat(), point[1].asFloat(), paintPtr);
+    image->unref();
+}
+
+void Renderer::processImageRect(Json::Value& command, SkCanvas* target) {
+    SkImage* image = load_image(command[SKJSONCANVAS_ATTRIBUTE_IMAGE]);
+    if (image == nullptr) {
+        return;
+    }
+    SkRect dst;
+    this->getRect(command, SKJSONCANVAS_ATTRIBUTE_DST, &dst);
+    SkPaint* paintPtr;
+    SkPaint paint;
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
+        this->getPaint(command, &paint);
+        paintPtr = &paint;
+    }
+    else {
+        paintPtr = nullptr;
+    }
+    SkCanvas::SrcRectConstraint constraint;
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_STRICT) && 
+        command[SKJSONCANVAS_ATTRIBUTE_STRICT].asBool()) {
+        constraint = SkCanvas::kStrict_SrcRectConstraint;
+    }
+    else {
+        constraint = SkCanvas::kFast_SrcRectConstraint;
+    }
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_SRC)) {
+        SkRect src;
+        this->getRect(command, SKJSONCANVAS_ATTRIBUTE_SRC, &src);
+        target->drawImageRect(image, src, dst, paintPtr, constraint);
+    }
+    else {
+        target->drawImageRect(image, dst, paintPtr, constraint);
+    }
+    image->unref();
+}
+
+void Renderer::processBitmap(Json::Value& command, SkCanvas* target) {
+    SkImage* image = load_image(command[SKJSONCANVAS_ATTRIBUTE_BITMAP]);
+    if (image == nullptr) {
+        return;
+    }
+    Json::Value point = command[SKJSONCANVAS_ATTRIBUTE_COORDS];
+    SkPaint* paintPtr;
+    SkPaint paint;
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
+        this->getPaint(command, &paint);
+        paintPtr = &paint;
+    }
+    else {
+        paintPtr = nullptr;
+    }
+    target->drawImage(image, point[0].asFloat(), point[1].asFloat(), paintPtr);
+    image->unref();
+}
+
+void Renderer::processBitmapRect(Json::Value& command, SkCanvas* target) {
+    SkBitmap* bitmap = load_bitmap(command[SKJSONCANVAS_ATTRIBUTE_BITMAP]);
+    if (bitmap == nullptr) {
+        return;
+    }
+    SkRect dst;
+    this->getRect(command, SKJSONCANVAS_ATTRIBUTE_DST, &dst);
+    SkPaint* paintPtr;
+    SkPaint paint;
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_PAINT)) {
+        this->getPaint(command, &paint);
+        paintPtr = &paint;
+    }
+    else {
+        paintPtr = nullptr;
+    }
+    SkCanvas::SrcRectConstraint constraint;
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_STRICT) && 
+        command[SKJSONCANVAS_ATTRIBUTE_STRICT].asBool()) {
+        constraint = SkCanvas::kStrict_SrcRectConstraint;
+    }
+    else {
+        constraint = SkCanvas::kFast_SrcRectConstraint;
+    }
+    if (command.isMember(SKJSONCANVAS_ATTRIBUTE_SRC)) {
+        SkRect src;
+        this->getRect(command, SKJSONCANVAS_ATTRIBUTE_SRC, &src);
+        target->drawBitmapRect(*bitmap, src, dst, paintPtr, constraint);
+    }
+    else {
+        target->drawBitmapRect(*bitmap, dst, paintPtr, constraint);
+    }
+    free(bitmap);
+}
+
 void render(const char* json, SkCanvas* target) {
     Renderer renderer;
     Json::Reader reader;
     Json::Value root;
     if (reader.parse(std::string(json), root)) {
         SkASSERT(root[SKJSONCANVAS_VERSION].asInt() == 1);
         Json::Value commands = root[SKJSONCANVAS_COMMANDS];
         for (Json::ArrayIndex i = 0; i < commands.size(); i++) {
             renderer.processCommand(commands[i], target);
         }
     }
     else {
         SkDebugf(json);
         SkFAIL("json parse failure");
     }
 }
 
 } // namespace