Fix up picture clip bounds in 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"
 
-const int Request::kImageWidth = 1920;
-const int Request::kImageHeight = 1080;
+#include "SkPictureRecorder.h"
+#include "SkPixelSerializer.h"
 
 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);
@@ skipping 24 matching lines @@
     sk_free(rows);
 }
 
 Request::Request(SkString rootUrl)
     : fUploadContext(nullptr)
     , fUrlDataManager(rootUrl)
     , fGPUEnabled(false) {
     // create surface
     GrContextOptions grContextOpts;
     fContextFactory.reset(new GrContextFactory(grContextOpts));
-    fSurface.reset(this->createCPUSurface());
 }
 
 SkBitmap* Request::getBitmapFromCanvas(SkCanvas* canvas) {
     SkBitmap* bmp = new SkBitmap();
-    SkImageInfo info = SkImageInfo::Make(kImageWidth, kImageHeight, kRGBA_8888_SkColorType,
-                kOpaque_SkAlphaType);
+    SkIRect bounds = fPicture->cullRect().roundOut();
+    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;
 }
 
 SkData* Request::writeCanvasToPng(SkCanvas* canvas) {
     // capture pixels
-    SkAutoTDelete<SkBitmap> bmp(getBitmapFromCanvas(canvas));
+    SkAutoTDelete<SkBitmap> bmp(this->getBitmapFromCanvas(canvas));
     SkASSERT(bmp);
 
     // write to png
     SkDynamicMemoryWStream buffer;
     write_png((const png_bytep) bmp->getPixels(), bmp->width(), bmp->height(), buffer);
     return buffer.copyToData();
 }
 
 SkCanvas* Request::getCanvas() {
     GrContextFactory* factory = fContextFactory;
     SkGLContext* gl = factory->getContextInfo(GrContextFactory::kNative_GLContextType,
                                               GrContextFactory::kNone_GLContextOptions).fGLContext;
     gl->makeCurrent();
     SkASSERT(fDebugCanvas);
+
+    // create the appropriate surface if necessary
+    if (!fSurface) {
+        this->enableGPU(fGPUEnabled);
+    }
     SkCanvas* target = fSurface->getCanvas();
     return target;
 }
 
 void Request::drawToCanvas(int n, int m) {
     SkCanvas* target = this->getCanvas();
     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();
+    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();
+}
+
 SkSurface* Request::createCPUSurface() {
-    SkImageInfo info = SkImageInfo::Make(kImageWidth, kImageHeight, kN32_SkColorType,
+    SkIRect bounds = fPicture->cullRect().roundOut();
+    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);
-    int maxRTSize = context->caps()->maxRenderTargetSize();
-    SkImageInfo info = SkImageInfo::Make(SkTMin(kImageWidth, maxRTSize),
-                                         SkTMin(kImageHeight, maxRTSize),
+    SkIRect bounds = fPicture->cullRect().roundOut();
+    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) {    
     if (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;
     }
 
     // pour picture into debug canvas
-    fDebugCanvas.reset(new SkDebugCanvas(kImageWidth, Request::kImageHeight));
+    SkIRect bounds = fPicture->cullRect().roundOut();
+    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;
@@ skipping 69 matching lines @@
     SkIRect clip = fDebugCanvas->getCurrentClip();
     Json::Value info(Json::objectValue);
     info["ViewMatrix"] = SkDrawCommand::MakeJsonMatrix(vm);
     info["ClipRect"] = SkDrawCommand::MakeJsonIRect(clip);
 
     std::string json = Json::FastWriter().write(info);
 
     // We don't want the null terminator so strlen is correct
     return SkData::NewWithCopy(json.c_str(), strlen(json.c_str()));
 }
+
+SkColor Request::getPixel(int x, int y) {
+    SkCanvas* canvas = this->getCanvas();
+    canvas->flush();
+    SkAutoTDelete<SkBitmap> bitmap(this->getBitmapFromCanvas(canvas));
+    SkASSERT(bitmap);
+    bitmap->lockPixels();
+    uint8_t* start = ((uint8_t*) bitmap->getPixels()) + (y * bitmap->width() + x) * 4;

[joshualitt, 2016/03/09 15:34:47]

I changed this to bitmap->width(), is that correct?

[ethannicholas, 2016/03/09 16:32:36]

Yep.

+    SkColor result = SkColorSetARGB(start[3], start[0], start[1], start[2]);
+    bitmap->unlockPixels();
+    return result;
+}
+