Add tile rendering to GM

gm/gmmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 393 matching lines @@
             // size) overwrite our previous allocation
             bitmap->setConfig(SkBitmap::kARGB_8888_Config, size.fWidth,
                               size.fHeight);
             canvas->readPixels(bitmap, 0, 0);
         }
 #endif
         complete_bitmap(bitmap);
         return kEmpty_ErrorCombination;
     }
 
+    static void bitmap_copy_subset(const SkBitmap& src, SkBitmap* dst, int xDst,
+                                   int yDst) {
+        for (int y = 0; y <src.height() && y + yDst < dst->height() ; y++) {
+            for (int x = 0; x < src.width() && x + xDst < dst->width() ; x++) {
+                *dst->getAddr32(xDst + x, yDst + y) = *src.getAddr32(x, y);
+            }
+        }
+    }
+
     static void generate_image_from_picture(GM* gm, const ConfigData& gRec,
                                             SkPicture* pict, SkBitmap* bitmap,
-                                            SkScalar scale = SK_Scalar1) {
+                                            SkScalar scale = SK_Scalar1,
+                                            bool tile = false) {
         SkISize size = gm->getISize();
         setup_bitmap(gRec, size, bitmap);
-        SkCanvas canvas(*bitmap);
-        installFilter(&canvas);
-        canvas.scale(scale, scale);
-        canvas.drawPicture(*pict);
-        complete_bitmap(bitmap);
+
+        if (tile) {
+            // Generate the result image by rendering to tiles and accumulating
+            // the results in 'bitmap'
+
+            // This 16x16 tiling matches the settings applied to 'pict' in 
+            // 'generate_new_picture'
+            SkISize tileSize = SkISize::Make(16, 16);
+
+            SkBitmap tileBM;
+            setup_bitmap(gRec, tileSize, &tileBM);
+            SkCanvas tileCanvas(tileBM);
+            installFilter(&tileCanvas);
+
+            for (int yTile = 0; yTile < (size.height()+15)/16; ++yTile) {
+                for (int xTile = 0; xTile < (size.width()+15)/16; ++xTile) {
+                    int saveCount = tileCanvas.save();
+                    SkMatrix mat(tileCanvas.getTotalMatrix());
+                    mat.postTranslate(SkIntToScalar(-xTile*tileSize.width()), 
+                                      SkIntToScalar(-yTile*tileSize.height()));
+                    tileCanvas.setMatrix(mat);
+                    pict->draw(&tileCanvas);
+                    tileCanvas.flush();
+                    tileCanvas.restoreToCount(saveCount);
+                    bitmap_copy_subset(tileBM, bitmap, 

[bsalomon, 2013/04/01 17:36:43]

Maybe create an SkCanvas around bitmap and drawBitmap(tileBM) to it?

[robertphillips, 2013/04/01 18:21:52]

What does that buy us?

[bsalomon, 2013/04/01 18:28:27]

Faster, works with different src/dst bitmap types, fewer lines of code, maybe
easier to read

// three lines of setup
SkCanvas bmpCanvas(*bitmap);
SkPaint bmpPaint;
bmpPaint.setXfermodeMode(SkXfermode::kSrc_Mode);

// one to draw.
bmpCanvas.drawBitmap(tileBmp, xTile * tileSize.width(), yTile *
tileSize.height(), &bmpPaint);

    

[robertphillips, 2013/04/02 13:29:53]

Done.

+                                       xTile * tileSize.width(), 
+                                       yTile * tileSize.height());
+                }
+            }
+        } else {
+            SkCanvas canvas(*bitmap);
+            installFilter(&canvas);
+            canvas.scale(scale, scale);
+            canvas.drawPicture(*pict);
+            complete_bitmap(bitmap);
+        }
     }
 
     static void generate_pdf(GM* gm, SkDynamicMemoryWStream& pdf) {
 #ifdef SK_SUPPORT_PDF
         SkMatrix initialTransform = gm->getInitialTransform();
         SkISize pageSize = gm->getISize();
         SkPDFDevice* dev = NULL;
         if (initialTransform.isIdentity()) {
             dev = new SkPDFDevice(pageSize, pageSize, initialTransform);
         } else {
@@ skipping 878 matching lines @@
             if ((gmFlags & GM::kSkipScaledReplay_Flag) && replayScale != 1) {
                 continue;
             }
             // We record with the reciprocal scale to obtain a replay
             // result that can be validated against comparisonBitmap.
             SkScalar recordScale = SkScalarInvert(replayScale);
             SkPicture* pict = gmmain.generate_new_picture(
                 gm, kTileGrid_BbhType, SkPicture::kUsePathBoundsForClip_RecordingFlag, recordScale);
             SkAutoUnref aur(pict);
             SkBitmap bitmap;
-            gmmain.generate_image_from_picture(gm, compareConfig, pict, &bitmap, replayScale);
+            // We cannot yet pass 'true' to generate_image_from_picture to
+            // perform actual tiled rendering (see Issue 1198 -
+            // https://code.google.com/p/skia/issues/detail?id=1198)
+            gmmain.generate_image_from_picture(gm, compareConfig, pict, &bitmap, 
+                                               replayScale /*, true */);
             SkString suffix("-tilegrid");
             if (SK_Scalar1 != replayScale) {
                 suffix += "-scale-";
                 suffix.appendScalar(replayScale);
             }
             errorsForAllModes.add(gmmain.compare_test_results_to_reference_bitmap(
                 gm, compareConfig, suffix.c_str(), bitmap, &comparisonBitmap));
         }
     }
 
@@ skipping 324 matching lines @@
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif