Adding support for playback to L32/S32/F16 canvas.

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 "SkPictureRecorder.h"
 #include "SkPixelSerializer.h"
 
 using namespace sk_gpu_test;
 
 static int kDefaultWidth = 1920;
 static int kDefaultHeight = 1080;
 
 
 Request::Request(SkString rootUrl)
     : fUploadContext(nullptr)
     , fUrlDataManager(rootUrl)
-    , fGPUEnabled(false) {
+    , fGPUEnabled(false)
+    , fColorMode(0) {
     // create surface
 #if SK_SUPPORT_GPU
     GrContextOptions grContextOpts;
     fContextFactory = new GrContextFactory(grContextOpts);
 #else
     fContextFactory = nullptr;
 #endif
 }
 
 Request::~Request() {
 #if SK_SUPPORT_GPU
     if (fContextFactory) {
         delete fContextFactory;
     }
 #endif
 }
 
 SkBitmap* Request::getBitmapFromCanvas(SkCanvas* canvas) {
     SkBitmap* bmp = new SkBitmap();
     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;
+    if (kRGBA_F16_SkColorType == canvas->imageInfo().colorType()) {

[Brian Osman, 2016/04/18 16:17:03]

We have other special-case conversion code in DM, which is actually closer to
what I'd like to do here, but I didn't want to copy-paste all of it. For F16, I
think I'd like to add another case to SkPixelInfo::CopyPixels.

[mtklein, 2016/04/18 17:40:48]

Think this is a sign we should fix readPixels() first?

+        SkBitmap n32TempBmp;
+        SkImageInfo n32Info = SkImageInfo::Make(bounds.width(), bounds.height(),
+                                                kN32_SkColorType, kOpaque_SkAlphaType);
+        n32TempBmp.setInfo(n32Info);
+        if (!canvas->readPixels(&n32TempBmp, 0, 0)) {
+            fprintf(stderr, "Can't read pixels\n");
+            return nullptr;
+        }
+
+        if (!n32TempBmp.copyTo(bmp, kRGBA_8888_SkColorType)) {
+            fprintf(stderr, "Can't copy pixels\n");
+            return nullptr;
+        }
+    } else {
+        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(this->getBitmapFromCanvas(canvas));
     SkASSERT(bmp);
 
     // write to png
@@ skipping 72 matching lines @@
         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;
 }
 
+namespace {
+
+struct ColorAndProfile {
+    SkColorType fColorType;
+    SkColorProfileType fProfileType;
+    bool fGammaCorrect;
+};
+
+ColorAndProfile ColorModes[] = {
+    { kN32_SkColorType, kLinear_SkColorProfileType, false },
+    { kN32_SkColorType, kSRGB_SkColorProfileType, true },
+    { kRGBA_F16_SkColorType, kLinear_SkColorProfileType, true },
+};
+
+}
+
 SkSurface* Request::createCPUSurface() {
     SkIRect bounds = this->getBounds();
-    SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(), kN32_SkColorType,
-                                         kPremul_SkAlphaType);
+    ColorAndProfile cap = ColorModes[fColorMode];
+    SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(), cap.fColorType,
+                                         kPremul_SkAlphaType, cap.fProfileType);
     return SkSurface::MakeRaster(info).release();
 }
 
 SkSurface* Request::createGPUSurface() {
     GrContext* context = this->getContext();
     SkIRect bounds = this->getBounds();
-    SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(),
-                                         kN32_SkColorType, kPremul_SkAlphaType);
-    uint32_t flags = 0;
+    ColorAndProfile cap = ColorModes[fColorMode];
+    SkImageInfo info = SkImageInfo::Make(bounds.width(), bounds.height(), cap.fColorType,
+                                         kPremul_SkAlphaType, cap.fProfileType);
+    uint32_t flags = cap.fGammaCorrect ? SkSurfaceProps::kGammaCorrect_Flag : 0;

[Brian Osman, 2016/04/18 16:17:03]

Need to do this in createCPUSurface, too.

     SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
     SkSurface* surface = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0,
                                                      &props).release();
     return surface;
 }
 
+bool Request::setColorMode(int mode) {
+    fColorMode = mode;
+    return enableGPU(fGPUEnabled);
+}
+
 bool Request::enableGPU(bool enable) {
     if (enable) {
         SkSurface* surface = this->createGPUSurface();
         if (surface) {
             fSurface.reset(surface);
             fGPUEnabled = true;
 
             // When we switch to GPU, there seems to be some mystery draws in the canvas.  So we
             // draw once to flush the pipe
             // TODO understand what is actually happening here
-            fDebugCanvas->drawTo(this->getCanvas(), this->getLastOp());
-            this->getCanvas()->flush();
+            if (fDebugCanvas) {
+                fDebugCanvas->drawTo(this->getCanvas(), this->getLastOp());
+                this->getCanvas()->flush();
+            }
 
             return true;
         }
         return false;
     }
     fSurface.reset(this->createCPUSurface());
     fGPUEnabled = false;
     return true;
 }
 
@@ skipping 17 matching lines @@
     fDebugCanvas->drawTo(this->getCanvas(), this->getLastOp());
     this->getCanvas()->flush();
     return true;
 }
 
 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());
+    root["colorMode"] = Json::Value(fColorMode);
     SkDynamicMemoryWStream stream;
     stream.writeText(Json::FastWriter().write(root).c_str());
 
     return stream.copyToData();
 }
 
 SkData* Request::getJsonBatchList(int n) {
     SkCanvas* canvas = this->getCanvas();
     SkASSERT(fGPUEnabled);
 
@@ skipping 30 matching lines @@
     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;
     SkColor result = SkColorSetARGB(start[3], start[0], start[1], start[2]);
     bitmap->unlockPixels();
     return result;
 }