Expand GatherPixelRefs unit test

tests/PictureTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 #include "TestClassDef.h"
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
 #include "SkError.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
 #include "SkPictureUtils.h"
 #include "SkRandom.h"
 #include "SkRRect.h"
 #include "SkShader.h"
 #include "SkStream.h"
 
+static const int gColorScale = 30;
+static const int gColorOffset = 60;
 
 static void make_bm(SkBitmap* bm, int w, int h, SkColor color, bool immutable) {
     bm->setConfig(SkBitmap::kARGB_8888_Config, w, h);
     bm->allocPixels();
     bm->eraseColor(color);
     if (immutable) {
         bm->setImmutable();
     }
 }
 
-typedef void (*DrawBitmapProc)(SkCanvas*, const SkBitmap&, const SkPoint&);
-
-static void drawbitmap_proc(SkCanvas* canvas, const SkBitmap& bm,
-                            const SkPoint& pos) {
+void make_checkerboard(SkBitmap* bm, int w, int h, bool immutable) {
+    SkASSERT(w % 2 == 0);
+    SkASSERT(h % 2 == 0);
+    bm->setConfig(SkBitmap::kA8_Config, w, h);
+    bm->allocPixels();
+    SkAutoLockPixels lock(*bm);
+    for (int y = 0; y < h; y += 2) {
+        uint8_t* s = bm->getAddr8(0, y);
+        for (int x = 0; x < w; x += 2) {
+            *s++ = 0xFF;
+            *s++ = 0x00;
+        }
+        s = bm->getAddr8(0, y + 1);
+        for (int x = 0; x < w; x += 2) {
+            *s++ = 0x00;
+            *s++ = 0xFF;
+        }
+    }
+    if (immutable) {
+        bm->setImmutable();
+    }
+}
+
+static void init_paint(SkPaint* paint, const SkBitmap &bm) {
+    SkShader* shader = SkShader::CreateBitmapShader(bm,
+                                                    SkShader::kClamp_TileMode,
+                                                    SkShader::kClamp_TileMode);
+    paint->setShader(shader)->unref();
+}
+
+typedef void (*DrawBitmapProc)(SkCanvas*, const SkBitmap&, const SkBitmap&, const SkPoint&);
+
+static void drawpaint_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                           const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    canvas->drawPaint(paint);
+}
+
+static void drawpoints_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                            const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    // draw a slightly inset rect
+    SkPoint points[5] = {
+        { pos.fX + 1, pos.fY + 1 }, 
+        { pos.fX + bm.width() - 2, pos.fY + 1 }, 
+        { pos.fX + bm.width() - 2, pos.fY + bm.height() - 2 }, 
+        { pos.fX + 1, pos.fY + bm.height() - 2 }, 
+        { pos.fX + 1, pos.fY + 1 }, 
+    };
+
+    canvas->drawPoints(SkCanvas::kPolygon_PointMode, 5, points, paint);
+}
+
+static void drawrect_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                          const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
+    r.offset(pos.fX, pos.fY);
+
+    canvas->drawRect(r, paint);
+}
+
+static void drawoval_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                          const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
+    r.offset(pos.fX, pos.fY);
+
+    canvas->drawOval(r, paint);
+}
+
+static void drawrrect_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                           const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+    
+    SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
+    r.offset(pos.fX, pos.fY);
+
+    SkRRect rr;
+    rr.setRectXY(r, SkIntToScalar(bm.width())/4, SkIntToScalar(bm.height())/4);
+    canvas->drawRRect(rr, paint);
+}
+
+static void drawpath_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                          const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    SkPath path;
+    path.lineTo(bm.width()/2.0f, SkIntToScalar(bm.height()));
+    path.lineTo(SkIntToScalar(bm.width()), 0);
+    path.close();
+    path.offset(pos.fX, pos.fY);
+
+    canvas->drawPath(path, paint);
+}
+
+static void drawbitmap_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                            const SkBitmap& altBM, const SkPoint& pos) {
     canvas->drawBitmap(bm, pos.fX, pos.fY, NULL);
 }
 
-static void drawbitmaprect_proc(SkCanvas* canvas, const SkBitmap& bm,
-                                const SkPoint& pos) {
-    SkRect r = {
-        0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height())
+static void drawbitmap_withshader_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                                       const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    // The bitmap in the paint is ignored unless we're drawing an A8 bitmap
+    canvas->drawBitmap(altBM, pos.fX, pos.fY, &paint);
+}
+
+static void drawsprite_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                            const SkBitmap& altBM, const SkPoint& pos) {
+    const SkMatrix& ctm = canvas->getTotalMatrix();
+
+    SkPoint p(pos);
+    ctm.mapPoints(&p, 1);
+
+    canvas->drawSprite(bm, (int)p.fX, (int)p.fY, NULL);
+}
+
+#if 0
+// Although specifiable, this case doesn't seem to make sense (i.e., the
+// bitmap in the shader is never used).
+static void drawsprite_withshader_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                                       const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    const SkMatrix& ctm = canvas->getTotalMatrix();
+
+    SkPoint p(pos);
+    ctm.mapPoints(&p, 1);
+
+    canvas->drawSprite(altBM, (int)p.fX, (int)p.fY, &paint);
+}
+#endif
+
+static void drawbitmaprect_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                                const SkBitmap& altBM, const SkPoint& pos) {
+    SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
+
+    r.offset(pos.fX, pos.fY);
+    canvas->drawBitmapRectToRect(bm, NULL, r, NULL);
+}
+
+static void drawbitmaprect_withshader_proc(SkCanvas* canvas, 
+                                           const SkBitmap& bm, 
+                                           const SkBitmap& altBM, 
+                                           const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    SkRect r = { 0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) };
+    r.offset(pos.fX, pos.fY);
+
+    // The bitmap in the paint is ignored unless we're drawing an A8 bitmap
+    canvas->drawBitmapRectToRect(altBM, NULL, r, &paint);
+}
+
+static void drawtext_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                          const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+    paint.setTextSize(SkIntToScalar(1.5*bm.width()));
+
+    canvas->drawText("0", 1, pos.fX, pos.fY+bm.width(), paint);
+}
+
+static void drawpostext_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                             const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+    paint.setTextSize(SkIntToScalar(1.5*bm.width()));
+
+    SkPoint point = { pos.fX, pos.fY + bm.height() };
+    canvas->drawPosText("O", 1, &point, paint);
+}
+
+static void drawtextonpath_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                                const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+
+    init_paint(&paint, bm);
+    paint.setTextSize(SkIntToScalar(1.5*bm.width()));
+
+    SkPath path;
+    path.lineTo(SkIntToScalar(bm.width()), 0);
+    path.offset(pos.fX, pos.fY+bm.height());
+
+    canvas->drawTextOnPath("O", 1, path, NULL, paint);
+}
+
+static void drawverts_proc(SkCanvas* canvas, const SkBitmap& bm, 
+                           const SkBitmap& altBM, const SkPoint& pos) {
+    SkPaint paint;
+    init_paint(&paint, bm);
+
+    SkPoint verts[4] = { 
+        { pos.fX+1, pos.fY+1 }, 
+        { pos.fX + bm.width()-1, pos.fY+1 }, 
+        { pos.fX + bm.width()-1, pos.fY + bm.height()-1 }, 
+        { pos.fX+1, pos.fY + bm.height()-1 } 
     };
-    r.offset(pos.fX, pos.fY);
-    canvas->drawBitmapRectToRect(bm, NULL, r, NULL);
-}
-
-static void drawshader_proc(SkCanvas* canvas, const SkBitmap& bm,
-                            const SkPoint& pos) {
-    SkRect r = {
-        0, 0, SkIntToScalar(bm.width()), SkIntToScalar(bm.height())
-    };
-    r.offset(pos.fX, pos.fY);
-
-    SkShader* s = SkShader::CreateBitmapShader(bm,
-                                               SkShader::kClamp_TileMode,
-                                               SkShader::kClamp_TileMode);
-    SkPaint paint;
-    paint.setShader(s)->unref();
-    canvas->drawRect(r, paint);
-    canvas->drawOval(r, paint);
-    SkRRect rr;
-    rr.setRectXY(r, 10, 10);
-    canvas->drawRRect(rr, paint);
+    SkPoint texs[4] = { { 0, 0 }, 
+                        { SkIntToScalar(bm.width()), 0 }, 
+                        { SkIntToScalar(bm.width()), SkIntToScalar(bm.height()) }, 
+                        { 0, SkIntToScalar(bm.height()) } };
+    uint16_t indices[6] = { 0, 1, 2, 0, 2, 3 };
+
+    canvas->drawVertices(SkCanvas::kTriangles_VertexMode, 4, verts, texs, NULL, NULL, 
+                         indices, 6, paint);
 }
 
 // Return a picture with the bitmaps drawn at the specified positions.
 static SkPicture* record_bitmaps(const SkBitmap bm[], const SkPoint pos[],
                                  int count, DrawBitmapProc proc) {
     SkPicture* pic = new SkPicture;
     SkCanvas* canvas = pic->beginRecording(1000, 1000);
     for (int i = 0; i < count; ++i) {
-        proc(canvas, bm[i], pos[i]);
+        canvas->save();
+        SkRect clipRect = SkRect::MakeXYWH(pos[i].fX, pos[i].fY,
+                                           SkIntToScalar(bm[i].width()),
+                                           SkIntToScalar(bm[i].height()));
+        canvas->clipRect(clipRect, SkRegion::kIntersect_Op);
+        proc(canvas, bm[i], bm[count+i], pos[i]);
+        canvas->restore();
     }
     pic->endRecording();
     return pic;
 }
 
 static void rand_rect(SkRect* rect, SkRandom& rand, SkScalar W, SkScalar H) {
     rect->fLeft   = rand.nextRangeScalar(-W, 2*W);
     rect->fTop    = rand.nextRangeScalar(-H, 2*H);
     rect->fRight  = rect->fLeft + rand.nextRangeScalar(0, W);
     rect->fBottom = rect->fTop + rand.nextRangeScalar(0, H);
 
     // we integralize rect to make our tests more predictable, since Gather is
     // a little sloppy.
     SkIRect ir;
     rect->round(&ir);
     rect->set(ir);
 }
 
-// Allocate result to be large enough to hold subset, and then draw the picture
-// into it, offsetting by subset's top/left corner.
-static void draw(SkPicture* pic, const SkRect& subset, SkBitmap* result) {
-    SkIRect ir;
-    subset.roundOut(&ir);
-    int w = ir.width();
-    int h = ir.height();
-    make_bm(result, w, h, 0, false);
+static void draw(SkPicture* pic, int width, int height, SkBitmap* result) {
+    make_bm(result, width, height, SK_ColorBLACK, false);
 
     SkCanvas canvas(*result);
-    canvas.translate(-SkIntToScalar(ir.left()), -SkIntToScalar(ir.top()));
     canvas.drawPicture(*pic);
 }
 
 template <typename T> int find_index(const T* array, T elem, int count) {
     for (int i = 0; i < count; ++i) {
         if (array[i] == elem) {
             return i;
         }
     }
     return -1;
 }
 
 // Return true if 'ref' is found in array[]
 static bool find(SkPixelRef const * const * array, SkPixelRef const * ref, int count) {
     return find_index<const SkPixelRef*>(array, ref, count) >= 0;
 }
 
-// Look at each pixel in bm, and if its color appears in colors[], find the
-// corresponding value in refs[] and append that ref into array, skipping
-// duplicates of the same value.
-static void gather_from_colors(const SkBitmap& bm, SkPixelRef* const refs[],
-                               int count, SkTDArray<SkPixelRef*>* array) {
+// Look at each pixel that is inside 'subset', and if its color appears in 
+// colors[], find the corresponding value in refs[] and append that ref into 
+// array, skipping duplicates of the same value.
+// Note that gathering pixelRefs from rendered colors suffers from the problem
+// that multiple simultaneous textures (e.g., A8 for alpha and 8888 for color)
+// isn't easy to reconstruct.
+static void gather_from_image(const SkBitmap& bm, SkPixelRef* const refs[],
+                              int count, SkTDArray<SkPixelRef*>* array,
+                              const SkRect& subset) {
+    SkIRect ir;
+    subset.roundOut(&ir);
+
+    if (!ir.intersect(0, 0, bm.width()-1, bm.height()-1)) {
+        return;
+    }
+
     // Since we only want to return unique values in array, when we scan we just
     // set a bit for each index'd color found. In practice we only have a few
     // distinct colors, so we just use an int's bits as our array. Hence the
     // assert that count <= number-of-bits-in-our-int.
     SkASSERT((unsigned)count <= 32);
     uint32_t bitarray = 0;
 
     SkAutoLockPixels alp(bm);
 
-    for (int y = 0; y < bm.height(); ++y) {
-        for (int x = 0; x < bm.width(); ++x) {
+    for (int y = ir.fTop; y < ir.fBottom; ++y) {
+        for (int x = ir.fLeft; x < ir.fRight; ++x) {
             SkPMColor pmc = *bm.getAddr32(x, y);
             // the only good case where the color is not found would be if
             // the color is transparent, meaning no bitmap was drawn in that
             // pixel.
             if (pmc) {
                 uint32_t index = SkGetPackedR32(pmc);
                 SkASSERT(SkGetPackedG32(pmc) == index);
                 SkASSERT(SkGetPackedB32(pmc) == index);
+                if (0 == index) {
+                    continue;           // background color
+                }
+                SkASSERT(0 == (index - gColorOffset) % gColorScale);
+                index = (index - gColorOffset) / gColorScale;
                 SkASSERT(static_cast<int>(index) < count);
                 bitarray |= 1 << index;
             }
         }
     }
 
     for (int i = 0; i < count; ++i) {
         if (bitarray & (1 << i)) {
             *array->append() = refs[i];
         }
     }
 }
 
 static void test_gatherpixelrefs(skiatest::Reporter* reporter) {
-    const int IW = 8;
+    const int IW = 32;
     const int IH = IW;
     const SkScalar W = SkIntToScalar(IW);
     const SkScalar H = W;
 
     static const int N = 4;
-    SkBitmap bm[N];
-    SkPixelRef* refs[N];
+    SkBitmap bm[2*N];
+    SkPixelRef* refs[2*N];
 
-    const SkPoint pos[] = {
+    const SkPoint pos[N] = {
         { 0, 0 }, { W, 0 }, { 0, H }, { W, H }
     };
 
-    // Our convention is that the color components contain the index of their
-    // corresponding bitmap/pixelref
+    // Our convention is that the color components contain an encoding of 
+    // the index of their corresponding bitmap/pixelref. (0,0,0,0) is 
+    // reserved for the background
     for (int i = 0; i < N; ++i) {
-        make_bm(&bm[i], IW, IH, SkColorSetARGB(0xFF, i, i, i), true);
+        make_bm(&bm[i], IW, IH, 
+                SkColorSetARGB(0xFF, 
+                               gColorScale*i+gColorOffset, 
+                               gColorScale*i+gColorOffset, 
+                               gColorScale*i+gColorOffset), 
+                true);
         refs[i] = bm[i].pixelRef();
     }
 
+    // The A8 alternate bitmaps are all BW checkerboards
+    for (int i = 0; i < N; ++i) {
+        make_checkerboard(&bm[N+i], IW, IH, true);
+        refs[N+i] = bm[N+i].pixelRef();
+    }
+
     static const DrawBitmapProc procs[] = {
-        drawbitmap_proc, drawbitmaprect_proc, drawshader_proc
+            drawpaint_proc,
+            drawpoints_proc,
+            drawrect_proc,
+            drawoval_proc,
+            drawrrect_proc,
+            drawpath_proc,
+            drawbitmap_proc, 
+            drawbitmap_withshader_proc,
+            drawsprite_proc,
+#if 0
+            drawsprite_withshader_proc,
+#endif
+            drawbitmaprect_proc, 
+            drawbitmaprect_withshader_proc,
+            drawtext_proc,
+            drawpostext_proc,
+            drawtextonpath_proc,
+            drawverts_proc,
     };
 
     SkRandom rand;
     for (size_t k = 0; k < SK_ARRAY_COUNT(procs); ++k) {
         SkAutoTUnref<SkPicture> pic(record_bitmaps(bm, pos, N, procs[k]));
 
         REPORTER_ASSERT(reporter, pic->willPlayBackBitmaps() || N == 0);
         // quick check for a small piece of each quadrant, which should just
         // contain 1 bitmap.
         for (size_t  i = 0; i < SK_ARRAY_COUNT(pos); ++i) {
             SkRect r;
             r.set(2, 2, W - 2, H - 2);
             r.offset(pos[i].fX, pos[i].fY);
             SkAutoDataUnref data(SkPictureUtils::GatherPixelRefs(pic, r));
             REPORTER_ASSERT(reporter, data);
             if (data) {
+                SkPixelRef** gatheredRefs = (SkPixelRef**)data->data();
                 int count = static_cast<int>(data->size() / sizeof(SkPixelRef*));
-                REPORTER_ASSERT(reporter, 1 == count);
-                REPORTER_ASSERT(reporter, *(SkPixelRef**)data->data() == refs[i]);
+                REPORTER_ASSERT(reporter, 1 == count || 2 == count);
+                if (1 == count) {
+                    REPORTER_ASSERT(reporter, gatheredRefs[0] == refs[i]);
+                } else if (2 == count) {
+                    REPORTER_ASSERT(reporter, 
+                        (gatheredRefs[0] == refs[i] && gatheredRefs[1] == refs[i+N]) ||
+                        (gatheredRefs[1] == refs[i] && gatheredRefs[0] == refs[i+N]));
+                }
             }
         }
 
+        SkBitmap image;
+        draw(pic, 2*IW, 2*IH, &image);
+
         // Test a bunch of random (mostly) rects, and compare the gather results
         // with a deduced list of refs by looking at the colors drawn.
         for (int j = 0; j < 100; ++j) {
             SkRect r;
             rand_rect(&r, rand, 2*W, 2*H);
 
-            SkBitmap result;
-            draw(pic, r, &result);
             SkTDArray<SkPixelRef*> array;
 
             SkData* data = SkPictureUtils::GatherPixelRefs(pic, r);
             size_t dataSize = data ? data->size() : 0;
             int gatherCount = static_cast<int>(dataSize / sizeof(SkPixelRef*));
             SkASSERT(gatherCount * sizeof(SkPixelRef*) == dataSize);
             SkPixelRef** gatherRefs = data ? (SkPixelRef**)(data->data()) : NULL;
             SkAutoDataUnref adu(data);
 
-            gather_from_colors(result, refs, N, &array);
+            gather_from_image(image, refs, N, &array, r);
 
             /*
              *  GatherPixelRefs is conservative, so it can return more bitmaps
              *  that we actually can see (usually because of conservative bounds
              *  inflation for antialiasing). Thus our check here is only that
              *  Gather didn't miss any that we actually saw. Even that isn't
              *  a strict requirement on Gather, which is meant to be quick and
              *  only mostly-correct, but at the moment this test should work.
              */
             for (int i = 0; i < array.count(); ++i) {
@@ skipping 399 matching lines @@
     test_bad_bitmap();
 #endif
     test_peephole();
     test_gatherpixelrefs(reporter);
     test_bitmap_with_encoded_data(reporter);
     test_clone_empty(reporter);
     test_clip_bound_opt(reporter);
     test_clip_expansion(reporter);
     test_hierarchical(reporter);
 }