further skiaserve image performance improvements

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"
@@ skipping 54 matching lines @@
     MHD_PostProcessor* fPostProcessor;
     MHD_Connection* connection;
 };
 
 struct Request {
     Request(SkString rootUrl) : fUploadContext(nullptr), fUrlDataManager(rootUrl) {}
     UploadContext* fUploadContext;
     SkAutoTUnref<SkPicture> fPicture;
     SkAutoTUnref<SkDebugCanvas> fDebugCanvas;
     SkAutoTDelete<GrContextFactory> fContextFactory;
-    SkAutoTUnref<SkSurface> fSurface;
+    SkAutoTDelete<SkBitmap> fBitmap;
     UrlDataManager fUrlDataManager;
 };
 
 // TODO factor this out into functions, also handle CPU path
 SkSurface* setupSurface(GrContextFactory* factory) {
     GrContext* context = factory->get(GrContextFactory::kNative_GLContextType,
                                       GrContextFactory::kNone_GLContextOptions);
     int maxRTSize = context->caps()->maxRenderTargetSize();
     SkImageInfo info = SkImageInfo::Make(SkTMin(kImageWidth, maxRTSize),
                                          SkTMin(kImageHeight, maxRTSize),
@@ skipping 13 matching lines @@
 }
 
 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_set_IHDR(png, info_ptr, width, height, 8, PNG_COLOR_TYPE_RGB, 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*));
+    png_bytep pixels = (png_bytep) sk_malloc_throw(width * height * 3);
     for (png_size_t y = 0; y < height; ++y) {
-        rows[y] = (png_bytep) rgba + y * width * 4;
+        const png_bytep src = rgba + y * width * 4;
+        rows[y] = pixels + y * width * 3;
+        // convert from RGBA to RGB
+        for (png_size_t x = 0; x < width; ++x) {
+            rows[y][x * 3] = src[x * 4];
+            rows[y][x * 3 + 1] = src[x * 4 + 1];
+            rows[y][x * 3 + 2] = src[x * 4 + 2];
+        }
     }
     png_set_filter(png, 0, PNG_NO_FILTERS);
     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;
-    }
-
+SkData* writeBitmapToPng(SkBitmap& bmp) {
     // write to 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);
-    return writeCanvasToPng(target);
+    SkCanvas target(*request->fBitmap);
+    request->fDebugCanvas->drawTo(&target, n);
+    return writeBitmapToPng(*request->fBitmap);
 }
 
 SkSurface* setupCpuSurface() {
     SkImageInfo info = SkImageInfo::Make(kImageWidth, kImageHeight, kN32_SkColorType,
                                          kPremul_SkAlphaType);
     return SkSurface::NewRaster(info);
 }
 
 static const size_t kBufferSize = 1024;
 
@@ skipping 229 matching lines @@
         request->fPicture.reset(
             SkPicture::CreateFromStream(request->fUploadContext->fStream.detachAsStream()));
         if (!request->fPicture.get()) {
             fprintf(stderr, "Could not create picture from stream.\n");
             return MHD_NO;
         }
 
         // create surface
         GrContextOptions grContextOpts;
         request->fContextFactory.reset(new GrContextFactory(grContextOpts));
-        request->fSurface.reset(setupSurface(request->fContextFactory.get()));
 
         // pour picture into debug canvas
         request->fDebugCanvas.reset(new SkDebugCanvas(kImageWidth, kImageHeight));
         request->fDebugCanvas->drawPicture(request->fPicture);
 
+        request->fBitmap.reset(new SkBitmap);
+        SkImageInfo imageInfo = SkImageInfo::Make(kImageWidth, kImageHeight, kRGBA_8888_SkColorType, 
+                                                  kOpaque_SkAlphaType);
+        request->fBitmap->allocPixels(imageInfo);
+
         // clear upload context
         delete request->fUploadContext;
         request->fUploadContext = nullptr;
 
         return SendTemplate(connection, true, "/");
     }
 };
 
 class DownloadHandler : public UrlHandler {
 public:
@@ skipping 210 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