Improved support for images/bitmaps in SkJSONCanvas

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"
@@ skipping 141 matching lines @@
     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) {
+        SkDebugf("no factory for loading '%s'\n", name);
         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()) {
+        SkDebugf("invalid buffer loading flattenable\n");
         return nullptr;
     }
     return result;
 }
 
+static SkColorType colortype_from_name(const char* name) {
+    if (!strcmp(name, SKJSONCANVAS_COLORTYPE_ARGB4444)) {
+        return kARGB_4444_SkColorType;
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_RGBA8888)) {
+        return kRGBA_8888_SkColorType;
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_BGRA8888)) {
+        return kBGRA_8888_SkColorType;
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_565)) {
+        return kRGB_565_SkColorType;
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_GRAY8)) {
+        return kGray_8_SkColorType;
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_INDEX8)) {
+        return kIndex_8_SkColorType;
+    }
+    else if (!strcmp(name, SKJSONCANVAS_COLORTYPE_ALPHA8)) {
+        return kAlpha_8_SkColorType;
+    }
+    SkASSERT(false);
+    return kN32_SkColorType;
+}
+
+static SkBitmap* convert_colortype(SkBitmap* bitmap, SkColorType colorType) {
+    if (bitmap->colorType() == colorType  ) {
+        return bitmap;
+    }
+    SkBitmap* dst = new SkBitmap();
+    if (bitmap->copyTo(dst, colorType)) {
+        delete bitmap;
+        return dst;
+    }
+    SkASSERT(false);
+    delete dst;
+    return bitmap;
+}
+
 // caller is responsible for freeing return value
-static SkBitmap* load_bitmap(Json::Value jsonBitmap) {
+static SkBitmap* load_bitmap(const Json::Value& jsonBitmap) {
     if (!jsonBitmap.isMember(SKJSONCANVAS_ATTRIBUTE_BYTES)) {
+        SkDebugf("invalid bitmap\n");
         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);
+        if (jsonBitmap.isMember(SKJSONCANVAS_ATTRIBUTE_COLOR)) {
+            const char* ctName = jsonBitmap[SKJSONCANVAS_ATTRIBUTE_COLOR].asCString();
+            SkColorType ct = colortype_from_name(ctName);
+            if (ct != kIndex_8_SkColorType) {
+                bitmap = convert_colortype(bitmap, ct);
+            }
+        }
         return bitmap;
     }
-    SkDebugf("image decode failed");
+    SkDebugf("image decode failed\n");
     free(data);
     return nullptr;
 }
 
-static SkImage* load_image(Json::Value jsonImage) {
+static SkImage* load_image(const Json::Value& jsonImage) {
     SkBitmap* bitmap = load_bitmap(jsonImage);
     if (bitmap == nullptr) {
         return nullptr;
     }
     SkImage* result = SkImage::NewFromBitmap(*bitmap);
-    free(bitmap);
+    delete 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();
@@ skipping 27 matching lines @@
     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_imagefilter(Json::Value& jsonPaint, SkPaint* target) {
+    if (jsonPaint.isMember(SKJSONCANVAS_ATTRIBUTE_IMAGEFILTER)) {
+        Json::Value jsonImageFilter = jsonPaint[SKJSONCANVAS_ATTRIBUTE_IMAGEFILTER];
+        SkImageFilter* imageFilter = (SkImageFilter*) load_flattenable(jsonImageFilter);
+        if (imageFilter != nullptr) {
+            target->setImageFilter(imageFilter);
+            imageFilter->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)) {
             target->setStyle(SkPaint::kFill_Style);
         }
         else if (!strcmp(style, SKJSONCANVAS_STYLE_STROKE)) {
             target->setStyle(SkPaint::kStroke_Style);
         }
         else if (!strcmp(style, SKJSONCANVAS_STYLE_STROKEANDFILL)) {
@@ skipping 132 matching lines @@
     }
 }
 
 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_imagefilter(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);
@@ skipping 367 matching lines @@
             renderer.processCommand(commands[i], target);
         }
     }
     else {
         SkDebugf(json);
         SkFAIL("json parse failure");
     }
 }
 
 } // namespace