Fix some bugs and performance issues with skiaserve

tools/skiaserve/Request.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 "Request.h"
 
 #include "png.h"
 
 #include "SkPictureRecorder.h"
 #include "SkPixelSerializer.h"
 
+static int kDefaultWidth = 1920;
+static int kDefaultHeight = 1080;
+
 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);
@@ skipping 27 matching lines @@
     : fUploadContext(nullptr)
     , fUrlDataManager(rootUrl)
     , fGPUEnabled(false) {
     // create surface
     GrContextOptions grContextOpts;
     fContextFactory.reset(new GrContextFactory(grContextOpts));
 }
 
 SkBitmap* Request::getBitmapFromCanvas(SkCanvas* canvas) {
     SkBitmap* bmp = new SkBitmap();
-    SkIRect bounds = fPicture->cullRect().roundOut();
+    SkIRect bounds = this->getBounds();
     SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(),
                                          kRGBA_8888_SkColorType, kOpaque_SkAlphaType);
     bmp->setInfo(info);
     if (!canvas->readPixels(bmp, 0, 0)) {
         fprintf(stderr, "Can't read pixels\n");
         return nullptr;
     }
     return bmp;
 }
 
@@ skipping 28 matching lines @@
     fDebugCanvas->drawTo(target, n, m);
 }
 
 SkData* Request::drawToPng(int n, int m) {
     this->drawToCanvas(n, m);
     return writeCanvasToPng(this->getCanvas());
 }
 
 SkData* Request::writeOutSkp() {
     // Playback into picture recorder
-    SkIRect bounds = fPicture->cullRect().roundOut();
+    SkIRect bounds = this->getBounds();
     SkPictureRecorder recorder;
     SkCanvas* canvas = recorder.beginRecording(bounds.width(), bounds.height());
 
     fDebugCanvas->draw(canvas);
 
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 
     SkDynamicMemoryWStream outStream;
 
     SkAutoTUnref<SkPixelSerializer> serializer(SkImageEncoder::CreatePixelSerializer());
     picture->serialize(&outStream, serializer);
 
     return outStream.copyToData();
 }
 
+GrContext* Request::getContext() {
+  return fContextFactory->get(GrContextFactory::kNative_GLContextType,
+                              GrContextFactory::kNone_GLContextOptions);
+}
+
+SkIRect Request::getBounds() {
+    SkIRect bounds;
+    if (fPicture) {
+        bounds = fPicture->cullRect().roundOut();
+        if (fGPUEnabled) {
+            int maxRTSize = this->getContext()->caps()->maxRenderTargetSize();
+            bounds = SkIRect::MakeWH(SkTMin(bounds.width(), maxRTSize),
+                                     SkTMin(bounds.height(), maxRTSize));
+        }
+    } else {
+        bounds = SkIRect::MakeWH(kDefaultWidth, kDefaultHeight);
+    }
+
+    // We clip to kDefaultWidth / kDefaultHeight for performance reasons
+    // TODO make this configurable
+    bounds = SkIRect::MakeWH(SkTMin(bounds.width(), kDefaultWidth),
+                             SkTMin(bounds.height(), kDefaultHeight));
+    return bounds;
+}
+
 SkSurface* Request::createCPUSurface() {
-    SkIRect bounds = fPicture->cullRect().roundOut();
+    SkIRect bounds = this->getBounds();
     SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(), kN32_SkColorType,
                                          kPremul_SkAlphaType);
     return SkSurface::NewRaster(info);
 }
 
 SkSurface* Request::createGPUSurface() {
-    GrContext* context = fContextFactory->get(GrContextFactory::kNative_GLContextType,
-                                              GrContextFactory::kNone_GLContextOptions);
-    SkIRect bounds = fPicture->cullRect().roundOut();
+    GrContext* context = this->getContext();
+    SkIRect bounds = this->getBounds();
     SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(),
                                          kN32_SkColorType, kPremul_SkAlphaType);
     uint32_t flags = 0;
     SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
     SkSurface* surface = SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0,
                                                     &props);
     return surface;
 }
 
 bool Request::enableGPU(bool enable) {    
@@ skipping 12 matching lines @@
 } 
 
 bool Request::initPictureFromStream(SkStream* stream) {
     // parse picture from stream
     fPicture.reset(SkPicture::CreateFromStream(stream));
     if (!fPicture.get()) {
         fprintf(stderr, "Could not create picture from stream.\n");
         return false;
     }
 
+    // reinitialize canvas with the new picture dimensions
+    this->enableGPU(fGPUEnabled);
+
     // pour picture into debug canvas
-    SkIRect bounds = fPicture->cullRect().roundOut();
+    SkIRect bounds = this->getBounds();
     fDebugCanvas.reset(new SkDebugCanvas(bounds.width(), bounds.height()));
     fDebugCanvas->drawPicture(fPicture);
 
     // for some reason we need to 'flush' the debug canvas by drawing all of the ops
     fDebugCanvas->drawTo(this->getCanvas(), this->getLastOp());
     this->getCanvas()->flush();
     return true;
 }
 
-GrAuditTrail* Request::getAuditTrail(SkCanvas* canvas) {
-    GrAuditTrail* at = nullptr;
-#if SK_SUPPORT_GPU
-    GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
-    if (rt) {
-        GrContext* ctx = rt->getContext();
-        if (ctx) {
-            at = ctx->getAuditTrail();
-        }
-    }
-#endif
-    return at;
-}
-
-void Request::cleanupAuditTrail(SkCanvas* canvas) {
-    GrAuditTrail* at = this->getAuditTrail(canvas);
-    if (at) {
-        GrAuditTrail::AutoEnable ae(at);
-        at->fullReset();
-    }
-}
-
 SkData* Request::getJsonOps(int n) {
     SkCanvas* canvas = this->getCanvas();
     Json::Value root = fDebugCanvas->toJSON(fUrlDataManager, n, canvas);
     root["mode"] = Json::Value(fGPUEnabled ? "gpu" : "cpu");
     root["drawGpuBatchBounds"] = Json::Value(fDebugCanvas->getDrawGpuBatchBounds());
     SkDynamicMemoryWStream stream;
     stream.writeText(Json::FastWriter().write(root).c_str());
 
-    this->cleanupAuditTrail(canvas);
-
     return stream.copyToData();
 }
 
 SkData* Request::getJsonBatchList(int n) {
     SkCanvas* canvas = this->getCanvas();
     SkASSERT(fGPUEnabled);
 
-    // TODO if this is inefficient we could add a method to GrAuditTrail which takes
-    // a Json::Value and is only compiled in this file
-    Json::Value parsedFromString;
-#if SK_SUPPORT_GPU
-    // we use the toJSON method on debug canvas, but then just ignore the results and pull
-    // the information we care about from the audit trail
-    fDebugCanvas->toJSON(fUrlDataManager, n, canvas); 
-
-    GrAuditTrail* at = this->getAuditTrail(canvas);
-    GrAuditTrail::AutoManageBatchList enable(at);
-    Json::Reader reader;
-    SkDEBUGCODE(bool parsingSuccessful = )reader.parse(at->toJson().c_str(),
-                                                       parsedFromString);
-    SkASSERT(parsingSuccessful);
-#endif
+    Json::Value result = fDebugCanvas->toJSONBatchList(n, canvas);
 
     SkDynamicMemoryWStream stream;
-    stream.writeText(Json::FastWriter().write(parsedFromString).c_str());
+    stream.writeText(Json::FastWriter().write(result).c_str());
 
     return stream.copyToData();
 }
 
 SkData* Request::getJsonInfo(int n) {
     // drawTo
     SkAutoTUnref<SkSurface> surface(this->createCPUSurface());
     SkCanvas* canvas = surface->getCanvas();
 
     // TODO this is really slow and we should cache the matrix and clip
@@ skipping 17 matching lines @@
     canvas->flush();
     SkAutoTDelete<SkBitmap> bitmap(this->getBitmapFromCanvas(canvas));
     SkASSERT(bitmap);
     bitmap->lockPixels();
     uint8_t* start = ((uint8_t*) bitmap->getPixels()) + (y * bitmap->width() + x) * 4;
     SkColor result = SkColorSetARGB(start[3], start[0], start[1], start[2]);
     bitmap->unlockPixels();
     return result;
 }