Display JPGs in Viewer with Split Screen and ColorSpaceXform

tools/viewer/Viewer.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 "Viewer.h"
 
 #include "GMSlide.h"
+#include "ImageSlide.h"
 #include "SKPSlide.h"
 
 #include "SkCanvas.h"
 #include "SkCommonFlags.h"
+#include "SkMetaData.h"
 #include "SkOSFile.h"
 #include "SkRandom.h"
 #include "SkStream.h"
 
 using namespace sk_app;
 
 Application* Application::Create(int argc, char** argv, void* platformData) {
     return new Viewer(argc, argv, platformData);
 }
 
@@ skipping 20 matching lines @@
 DEFINE_string(key, "", "Space-separated key/value pairs to add to JSON identifying this builder.");
 DEFINE_string2(match, m, nullptr,
                "[~][^]substring[$] [...] of bench name to run.\n"
                "Multiple matches may be separated by spaces.\n"
                "~ causes a matching bench to always be skipped\n"
                "^ requires the start of the bench to match\n"
                "$ requires the end of the bench to match\n"
                "^ and $ requires an exact match\n"
                "If a bench does not match any list entry,\n"
                "it is skipped unless some list entry starts with ~");
-DEFINE_string(skps, "skps", "Directory to read skps from.");
 #ifdef SK_BUILD_FOR_ANDROID
+DEFINE_string(skps, "/data/local/tmp/skia", "Directory to read skps from.");
+DEFINE_string(jpgs, "/data/local/tmp/skia", "Directory to read jpgs from.");
 DEFINE_bool(vulkan, false, "Run with Vulkan.");
 #else
+DEFINE_string(skps, "skps", "Directory to read skps from.");
+DEFINE_string(jpgs, "jpgs", "Directory to read jpgs from.");
 DEFINE_bool(vulkan, true, "Run with Vulkan.");
 #endif
 
 const char *kBackendTypeStrings[sk_app::Window::kBackendTypeCount] = {
     " [OpenGL]",
     " [Vulkan]",
     " [Raster]"
 };
 
 const char* kName = "name";
 const char* kValue = "value";
 const char* kOptions = "options";
 const char* kSlideStateName = "Slide";
 const char* kBackendStateName = "Backend";
 const char* kSoftkeyStateName = "Softkey";
 const char* kSoftkeyHint = "Please select a softkey";
 const char* kFpsStateName = "FPS";
+const char* kSplitScreenStateName = "Split screen";
+const char* kON = "ON";
+const char* kOFF = "OFF";
 
 Viewer::Viewer(int argc, char** argv, void* platformData)
     : fCurrentMeasurement(0)
     , fDisplayStats(false)
+    , fSplitScreen(false)
     , fBackendType(sk_app::Window::kVulkan_BackendType)
     , fZoomCenterX(0.0f)
     , fZoomCenterY(0.0f)
     , fZoomLevel(0.0f)
     , fZoomScale(SK_Scalar1)
 {
     memset(fMeasurements, 0, sizeof(fMeasurements));
 
     SkDebugf("Command line arguments: ");
     for (int i = 1; i < argc; ++i) {
@@ skipping 127 matching lines @@
                 }
 
                 SkString path = SkOSPath::Join(FLAGS_skps[i], skpName.c_str());
                 sk_sp<SKPSlide> slide(new SKPSlide(skpName, path));
                 if (slide) {
                     fSlides.push_back(slide);
                 }
             }
         }
     }
+
+    // JPGs
+    for (int i = 0; i < FLAGS_jpgs.count(); i++) {
+        SkOSFile::Iter it(FLAGS_jpgs[i], ".jpg");
+        SkString jpgName;
+        while (it.next(&jpgName)) {
+            SkString path = SkOSPath::Join(FLAGS_jpgs[i], jpgName.c_str());
+            sk_sp<ImageSlide> slide(new ImageSlide(jpgName, path));
+            if (slide) {
+                fSlides.push_back(slide);
+            }
+        }
+    }
 }
 
 
 Viewer::~Viewer() {
     fWindow->detach();
     delete fWindow;
 }
 
 void Viewer::updateTitle() {
     SkString title("Viewer: ");
     title.append(fSlides[fCurrentSlide]->getName());
     if (kSRGB_SkColorProfileType == fWindow->getDisplayParams().fProfileType) {
         title.append(" sRGB");
     }
     title.append(kBackendTypeStrings[fBackendType]);
     fWindow->setTitle(title.c_str());
 }
 
 void Viewer::setupCurrentSlide(int previousSlide) {
     if (fCurrentSlide == previousSlide) {
         return; // no change; do nothing
     }
 
+    // prepare dimensions for image slides
+    fSlides[fCurrentSlide]->load();
+
     fGesture.reset();
     fDefaultMatrix.reset();
     fDefaultMatrixInv.reset();
 
     if (fWindow->supportsContentRect() && fWindow->scaleContentToFit()) {
         const SkRect contentRect = fWindow->getContentRect();
         const SkISize slideSize = fSlides[fCurrentSlide]->getDimensions();
         const SkRect slideBounds = SkRect::MakeIWH(slideSize.width(), slideSize.height());
         if (contentRect.width() > 0 && contentRect.height() > 0) {
             fDefaultMatrix.setRectToRect(slideBounds, contentRect, SkMatrix::kStart_ScaleToFit);
             SkAssertResult(fDefaultMatrix.invert(&fDefaultMatrixInv));
         }
     }
 
     if (fWindow->supportsContentRect()) {
         const SkISize slideSize = fSlides[fCurrentSlide]->getDimensions();
         SkRect windowRect = fWindow->getContentRect();
         fDefaultMatrixInv.mapRect(&windowRect);
         fGesture.setTransLimit(SkRect::MakeWH(SkIntToScalar(slideSize.width()), 
                                               SkIntToScalar(slideSize.height())),
                                windowRect);
     }
 
     this->updateTitle();
     this->updateUIState();
-    fSlides[fCurrentSlide]->load();
     if (previousSlide >= 0) {
         fSlides[previousSlide]->unload();
     }
     fWindow->inval();
 }
 
 #define MAX_ZOOM_LEVEL  8
 #define MIN_ZOOM_LEVEL  -8
 
 void Viewer::changeZoomLevel(float delta) {
@@ skipping 24 matching lines @@
         m.postScale(fZoomScale, fZoomScale);
         m.postTranslate(cx, cy);
     }
 
     m.preConcat(fGesture.localM());
     m.preConcat(fGesture.globalM());
 
     return m;
 }
 
-void Viewer::onPaint(SkCanvas* canvas) {
+void Viewer::drawSlide(SkCanvas* canvas, bool inSplitScreen) {
+    SkASSERT(!inSplitScreen || fWindow->supportsContentRect());
+
     int count = canvas->save();
 
     if (fWindow->supportsContentRect()) {
         SkRect contentRect = fWindow->getContentRect();
+        // If inSplitScreen, translate the image half screen to the right.
+        // Thus we have two copies of the image on each half of the screen.
+        contentRect.fLeft += inSplitScreen ? (contentRect.fRight - contentRect.fLeft) * 0.5 : 0;
         canvas->clipRect(contentRect);
         canvas->translate(contentRect.fLeft, contentRect.fTop);
     }
 
     canvas->clear(SK_ColorWHITE);
     canvas->concat(fDefaultMatrix);
     canvas->concat(computeMatrix());
 
+    canvas->getMetaData().setBool(kImageColorXformMetaData, inSplitScreen);
     fSlides[fCurrentSlide]->draw(canvas);
     canvas->restoreToCount(count);
+}
+
+void Viewer::onPaint(SkCanvas* canvas) {
+    drawSlide(canvas, false);
+    if (fSplitScreen && fWindow->supportsContentRect()) {
+        drawSlide(canvas, true);
+    }
 
     if (fDisplayStats) {
         drawStats(canvas);
     }
     fCommands.drawHelp(canvas);
 }
 
 bool Viewer::onTouch(intptr_t owner, Window::InputState state, float x, float y) {
     void* castedOwner = reinterpret_cast<void*>(owner);
     SkPoint touchPoint = fDefaultMatrixInv.mapXY(x, y);
@@ skipping 109 matching lines @@
 
     // FPS state
     Json::Value fpsState(Json::objectValue);
     fpsState[kName] = kFpsStateName;
     double measurement = fMeasurements[
             (fCurrentMeasurement + (kMeasurementCount-1)) % kMeasurementCount
     ];
     fpsState[kValue] = SkStringPrintf("%8.3lf ms", measurement).c_str();
     fpsState[kOptions] = Json::Value(Json::arrayValue);
 
+    // Split screen state
+    Json::Value splitScreenState(Json::objectValue);
+    splitScreenState[kName] = kSplitScreenStateName;
+    splitScreenState[kValue] = fSplitScreen ? kON : kOFF;
+    splitScreenState[kOptions] = Json::Value(Json::arrayValue);
+    splitScreenState[kOptions].append(kON);
+    splitScreenState[kOptions].append(kOFF);
+
     Json::Value state(Json::arrayValue);
     state.append(slideState);
     state.append(backendState);
     state.append(softkeyState);
     state.append(fpsState);
+    state.append(splitScreenState);
 
     fWindow->setUIState(state);
 }
 
 void Viewer::onUIStateChanged(const SkString& stateName, const SkString& stateValue) {
     // For those who will add more features to handle the state change in this function:
     // After the change, please call updateUIState no notify the frontend (e.g., Android app).
     // For example, after slide change, updateUIState is called inside setupCurrentSlide;
     // after backend change, updateUIState is called in this function.
     if (stateName.equals(kSlideStateName)) {
@@ skipping 22 matching lines @@
                     updateUIState();
                 }
                 break;
             }
         }
     } else if (stateName.equals(kSoftkeyStateName)) {
         if (!stateValue.equals(kSoftkeyHint)) {
             fCommands.onSoftkey(stateValue);
             updateUIState(); // This is still needed to reset the value to kSoftkeyHint
         }
+    } else if (stateName.equals(kSplitScreenStateName)) {
+        bool newSplitScreen = stateValue.equals(kON);
+        if (newSplitScreen != fSplitScreen) {
+            fSplitScreen = newSplitScreen;
+            fWindow->inval();
+            updateUIState();
+        }
     } else {
         SkDebugf("Unknown stateName: %s", stateName.c_str());
     }
 }