tuned skiaserve's png output for better performance

tools/skiaserve/skiaserve.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 "GrCaps.h"
 #include "GrContextFactory.h"
 #include "SkCanvas.h"
 #include "SkCommandLineFlags.h"
 #include "SkDebugCanvas.h"
 #include "SkJSONCanvas.h"
 #include "SkJSONCPP.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPixelSerializer.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 
 #include "UrlDataManager.h"
 
 #include <sys/socket.h>
 #include <microhttpd.h>
+#include "png.h"
 
 // To get image decoders linked in we have to do the below magic
 #include "SkForceLinking.h"
 #include "SkImageDecoder.h"
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 DEFINE_string(source, "https://debugger.skia.org", "Where to load the web UI from.");
 DEFINE_string(faviconDir, "tools/skiaserve", "The directory of the favicon");
 DEFINE_int32(port, 8888, "The port to listen on.");
 
@@ skipping 50 matching lines @@
                                          kN32_SkColorType, kPremul_SkAlphaType);
     uint32_t flags = 0;
     SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
     SkSurface* surface = SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0,
                                                     &props);
     SkASSERT(surface);
 
     return surface;
 }
 
+static void write_png_callback(png_structp png_ptr, png_bytep data, png_size_t length) {
+    SkWStream* out = (SkWStream*) png_get_io_ptr(png_ptr);
+    out->write(data, length);
+}
+
+static void write_png(const png_bytep rgba, png_uint_32 width, png_uint_32 height, SkWStream& out) {
+    png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    SkASSERT(png != nullptr);
+    png_infop info_ptr = png_create_info_struct(png);
+    SkASSERT(info_ptr != nullptr);
+    if (setjmp(png_jmpbuf(png))) {
+        SkFAIL("png encode error");
+    }
+    png_set_IHDR(png, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE,
+                 PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+    png_set_compression_level(png, 1);
+    png_bytepp rows = (png_bytepp) sk_malloc_throw(height * sizeof(png_byte*));
+    for (png_size_t y = 0; y < height; ++y) {
+        rows[y] = (png_bytep) rgba + y * width * 4;
+    }
+    png_set_filter(png, 0, PNG_NO_FILTERS);

[mtklein, 2016/02/16 17:48:52]

If you're interested in trying allowing any filters back into your set, I'd try
them in this order: UP, SUB, AVG, PAETH.  UP is likely super, super fast.

+    png_set_rows(png, info_ptr, &rows[0]);
+    png_set_write_fn(png, &out, write_png_callback, NULL);
+    png_write_png(png, info_ptr, PNG_TRANSFORM_IDENTITY, NULL);
+    png_destroy_write_struct(&png, NULL);
+    sk_free(rows);
+}
+
 SkData* writeCanvasToPng(SkCanvas* canvas) {
     // capture pixels
     SkBitmap bmp;
     bmp.setInfo(canvas->imageInfo());
     if (!canvas->readPixels(&bmp, 0, 0)) {
         fprintf(stderr, "Can't read pixels\n");
         return nullptr;
     }
 
     // write to png
-    // TODO encoding to png can be quite slow, we should investigate bmp
-    SkData* png = SkImageEncoder::EncodeData(bmp, SkImageEncoder::kPNG_Type, 100);
-    if (!png) {
-        fprintf(stderr, "Can't encode to png\n");
-        return nullptr;
-    }
-    return png;
+    SkDynamicMemoryWStream buffer;
+    write_png((const png_bytep) bmp.getPixels(), bmp.width(), bmp.height(), buffer);
+    return buffer.copyToData();
 }
 
 SkData* setupAndDrawToCanvasReturnPng(Request* request, int n) {
     GrContextFactory* factory = request->fContextFactory;
     SkGLContext* gl = factory->getContextInfo(GrContextFactory::kNative_GLContextType,
                                               GrContextFactory::kNone_GLContextOptions).fGLContext;
     gl->makeCurrent();
     SkASSERT(request->fDebugCanvas);
     SkCanvas* target = request->fSurface->getCanvas();
     request->fDebugCanvas->drawTo(target, n);
@@ skipping 476 matching lines @@
     MHD_stop_daemon(daemon);
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return skiaserve_main();
 }
 #endif